diff --git a/app/expert-finder/components/ExpertSearchLiveStatus.tsx b/app/expert-finder/components/ExpertSearchLiveStatus.tsx
new file mode 100644
index 000000000..9d893d1cf
--- /dev/null
+++ b/app/expert-finder/components/ExpertSearchLiveStatus.tsx
@@ -0,0 +1,81 @@
+'use client';
+
+import { Loader2, Users } from 'lucide-react';
+import { Progress } from '@/components/ui/Progress';
+import { cn } from '@/utils/styles';
+import type { SearchStatus } from '@/services/expertFinder.service';
+
+export interface ExpertSearchLiveStatusProps {
+  progress: number;
+  currentStep: string;
+  status: SearchStatus | null;
+  expertsFound: number;
+  isAppendRun?: boolean;
+  className?: string;
+}
+
+function statusLabel(status: SearchStatus | null): string {
+  if (status === 'pending') return 'Starting…';
+  if (status === 'processing') return 'Searching…';
+  if (status === 'completed') return 'Complete';
+  if (status === 'failed') return 'Failed';
+  return 'Connecting…';
+}
+
+export function ExpertSearchLiveStatus({
+  progress,
+  currentStep,
+  status,
+  expertsFound,
+  isAppendRun = false,
+  className,
+}: Readonly<ExpertSearchLiveStatusProps>) {
+  const clampedProgress = Math.min(100, Math.max(0, progress));
+  const stepText = currentStep.trim() || 'Finding experts… This can take a bit of time.';
+  const showSpinner = status !== 'completed' && status !== 'failed';
+  const expertsLabel =
+    expertsFound === 1
+      ? isAppendRun
+        ? 'new expert found'
+        : 'expert found'
+      : isAppendRun
+        ? 'new experts found'
+        : 'experts found';
+
+  return (
+    <div
+      className={cn(
+        'rounded-xl border border-gray-200 bg-gradient-to-b from-white to-gray-50/80 px-4 py-4 shadow-sm',
+        className
+      )}
+      aria-live="polite"
+    >
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <div className="flex min-w-0 items-center gap-2">
+          {showSpinner ? (
+            <Loader2 className="h-4 w-4 shrink-0 animate-spin text-primary-600" aria-hidden />
+          ) : null}
+          <span className="text-sm font-semibold text-gray-900">{statusLabel(status)}</span>
+        </div>
+        {expertsFound > 0 ? (
+          <span className="inline-flex items-center gap-1.5 text-sm text-gray-700">
+            <Users className="h-3.5 w-3.5 text-gray-500" aria-hidden />
+            <span className="tabular-nums font-medium">{expertsFound}</span>
+            <span className="text-gray-500">{expertsLabel}</span>
+          </span>
+        ) : null}
+      </div>
+
+      <Progress value={clampedProgress} max={100} size="sm" variant="primary" className="mt-3" />
+
+      <div className="mt-2 flex flex-wrap items-baseline justify-between gap-x-3 gap-y-1">
+        <p className="min-w-0 flex-1 text-sm text-gray-600 transition-opacity duration-200">
+          {stepText}
+        </p>
+        <span className="shrink-0 text-xs font-medium tabular-nums text-gray-500">
+          {Math.round(clampedProgress)}%
+        </span>
+      </div>
+    </div>
+  );
+}
diff --git a/app/expert-finder/library/[searchId]/components/ExpertSourceLinkIcon.tsx b/app/expert-finder/library/[searchId]/components/ExpertSourceLinkIcon.tsx
index 714aa0fdd..aae794111 100644
--- a/app/expert-finder/library/[searchId]/components/ExpertSourceLinkIcon.tsx
+++ b/app/expert-finder/library/[searchId]/components/ExpertSourceLinkIcon.tsx
@@ -4,6 +4,7 @@ import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { faGoogle, faLinkedin, faOrcid, faXTwitter } from '@fortawesome/free-brands-svg-icons';
 import { ExternalLink, GraduationCap } from 'lucide-react';
 import type { ExpertSourceLink } from '@/types/expertFinder';
+import { cn } from '@/utils/styles';
 import { ensureAbsoluteHttpUrl, isLinkedInUrl, isXUrl } from '@/utils/url';
 
 export type ExpertSourceIconType =
@@ -12,10 +13,30 @@ export type ExpertSourceIconType =
   | 'linkedin'
   | 'x'
   | 'google-scholar'
+  | 'openalex'
   | 'generic';
 
 const ICON_CLASS = 'h-4 w-4 shrink-0';
 
+/** OpenAlex-style tricon (three joined dots / open A). Brand is black on light backgrounds. */
+function OpenAlexIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      viewBox="0 0 24 24"
+      className={cn(className)}
+      fill="currentColor"
+      aria-hidden
+      focusable="false"
+    >
+      <circle cx="12" cy="5.25" r="2.35" />
+      <circle cx="5.5" cy="18.25" r="2.35" />
+      <circle cx="18.5" cy="18.25" r="2.35" />
+      <path d="M10.55 6.85 6.55 16.15a1.15 1.15 0 0 0 2.12.9l3.55-8.25a1.15 1.15 0 0 0-1.67-.95Z" />
+      <path d="M13.45 6.85 17.45 16.15a1.15 1.15 0 0 1-2.12.9l-3.55-8.25a1.15 1.15 0 0 1 1.67-.95Z" />
+    </svg>
+  );
+}
+
 export function getExpertSourceIconType(url: string, text?: string): ExpertSourceIconType {
   const normalized = ensureAbsoluteHttpUrl(url) || url;
   const combined = `${normalized} ${text ?? ''}`.toLowerCase();
@@ -43,6 +64,10 @@ export function getExpertSourceIconType(url: string, text?: string): ExpertSourc
     return 'google-scholar';
   }
 
+  if (hostname.includes('openalex.org') || combined.includes('openalex')) {
+    return 'openalex';
+  }
+
   if (hostname.endsWith('.edu') || hostname.includes('.edu.')) {
     return 'edu';
   }
@@ -72,6 +97,8 @@ export function ExpertSourceLinkIcon({ url, text }: Pick<ExpertSourceLink, 'url'
       return (
         <FontAwesomeIcon icon={faGoogle} className={`${ICON_CLASS} text-[#4285F4]`} aria-hidden />
       );
+    case 'openalex':
+      return <OpenAlexIcon className={`${ICON_CLASS} text-gray-900`} />;
     default:
       return <ExternalLink className={`${ICON_CLASS} text-primary-600`} aria-hidden />;
   }
diff --git a/app/expert-finder/library/[searchId]/components/FindMoreExpertsModal.tsx b/app/expert-finder/library/[searchId]/components/FindMoreExpertsModal.tsx
new file mode 100644
index 000000000..e67124e95
--- /dev/null
+++ b/app/expert-finder/library/[searchId]/components/FindMoreExpertsModal.tsx
@@ -0,0 +1,133 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { ChevronDown } from 'lucide-react';
+import { BaseModal } from '@/components/ui/BaseModal';
+import { Alert } from '@/components/ui/Alert';
+import { Button } from '@/components/ui/Button';
+import { Dropdown, DropdownItem } from '@/components/ui/form/Dropdown';
+import { Textarea } from '@/components/ui/form/Textarea';
+import { LoadingButton } from '@/components/ui/LoadingButton';
+import { cn } from '@/utils/styles';
+import {
+  EXPERT_SEARCH_ADDITIONAL_CONTEXT_MAX_LENGTH,
+  clampExpertCount,
+  getExpertCountOptions,
+  type ExpertCountOption,
+  type FindMoreExpertsPayload,
+} from '@/services/expertFinder.service';
+
+export interface FindMoreExpertsModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  initialAdditionalContext: string;
+  isSubmitting: boolean;
+  error: string | null;
+  onSubmit: (payload: FindMoreExpertsPayload) => Promise<void>;
+}
+
+const INITIAL_EXPERT_COUNT: ExpertCountOption = 10;
+
+export function FindMoreExpertsModal({
+  isOpen,
+  onClose,
+  initialAdditionalContext,
+  isSubmitting,
+  error,
+  onSubmit,
+}: Readonly<FindMoreExpertsModalProps>) {
+  const expertCountOptions = getExpertCountOptions();
+  const [expertCount, setExpertCount] = useState<ExpertCountOption>(() =>
+    clampExpertCount(INITIAL_EXPERT_COUNT)
+  );
+  const [additionalContext, setAdditionalContext] = useState(initialAdditionalContext);
+  const [countOpen, setCountOpen] = useState(false);
+
+  useEffect(() => {
+    if (!isOpen) return;
+    setExpertCount(clampExpertCount(INITIAL_EXPERT_COUNT));
+    setAdditionalContext(initialAdditionalContext);
+    setCountOpen(false);
+  }, [isOpen, initialAdditionalContext]);
+
+  const handleSubmit = async () => {
+    const payload: FindMoreExpertsPayload = { expert_count: expertCount };
+    if (additionalContext !== initialAdditionalContext) {
+      payload.additional_context = additionalContext;
+    }
+    await onSubmit(payload);
+  };
+
+  return (
+    <BaseModal isOpen={isOpen} onClose={onClose} title="Find more experts" size="md">
+      <div className="space-y-4">
+        <p className="text-sm text-gray-600">
+          Request additional experts for this search. New results are appended; existing experts
+          stay.
+        </p>
+
+        <Dropdown
+          label="Number of researchers"
+          helperText={`Up to ${expertCount} more researchers will be found`}
+          trigger={
+            <Button
+              type="button"
+              variant="outlined"
+              size="md"
+              className="w-full justify-between text-left text-gray-900 font-normal"
+              disabled={isSubmitting}
+            >
+              {expertCount}
+              <ChevronDown
+                className={cn(
+                  'ml-2 h-4 w-4 shrink-0 transition-transform',
+                  countOpen && 'rotate-180'
+                )}
+              />
+            </Button>
+          }
+          className="max-h-60 overflow-y-auto py-1"
+          onOpenChange={setCountOpen}
+        >
+          <div className="py-1 max-h-60 overflow-y-auto">
+            {expertCountOptions.map((option) => (
+              <DropdownItem
+                key={option}
+                onClick={() => setExpertCount(option)}
+                className={expertCount === option ? 'bg-primary-50 text-primary-900' : ''}
+              >
+                {option}
+              </DropdownItem>
+            ))}
+          </div>
+        </Dropdown>
+
+        <Textarea
+          label="Additional guidance (optional)"
+          value={additionalContext}
+          onChange={(e) => setAdditionalContext(e.target.value)}
+          maxLength={EXPERT_SEARCH_ADDITIONAL_CONTEXT_MAX_LENGTH}
+          rows={4}
+          disabled={isSubmitting}
+          helperText="Leave unchanged to keep the current search guidance. Clearing the field replaces it with empty guidance."
+        />
+
+        {error ? <Alert variant="error">{error}</Alert> : null}
+
+        <div className="flex justify-end gap-2 pt-1">
+          <Button type="button" variant="outlined" onClick={onClose} disabled={isSubmitting}>
+            Cancel
+          </Button>
+          <LoadingButton
+            type="button"
+            variant="default"
+            onClick={() => void handleSubmit()}
+            isLoading={isSubmitting}
+          >
+            Find more
+          </LoadingButton>
+        </div>
+      </div>
+    </BaseModal>
+  );
+}
diff --git a/app/expert-finder/library/[searchId]/components/SearchDetailContent.tsx b/app/expert-finder/library/[searchId]/components/SearchDetailContent.tsx
index a07db8297..7dedd1ec7 100644
--- a/app/expert-finder/library/[searchId]/components/SearchDetailContent.tsx
+++ b/app/expert-finder/library/[searchId]/components/SearchDetailContent.tsx
@@ -1,19 +1,12 @@
 'use client';
 
-import { useState, useCallback, useMemo } from 'react';
+import { useState, useCallback, useEffect, useMemo } from 'react';
 import Link from 'next/link';
 import { usePathname, useSearchParams } from 'next/navigation';
+import { ExpertSearchLiveStatus } from '@/app/expert-finder/components/ExpertSearchLiveStatus';
 import { TAB_EXPERT_RESULTS, TAB_OUTREACH } from '@/app/expert-finder/lib/searchDetailTabs';
-import {
-  Loader2,
-  RefreshCw,
-  Download,
-  Mail,
-  MailCheck,
-  MailX,
-  UserPlus,
-  MoreVertical,
-} from 'lucide-react';
+import { Download, Mail, MailCheck, MailX, UserPlus, MoreVertical, Search } from 'lucide-react';
+import toast from 'react-hot-toast';
 import { Alert } from '@/components/ui/Alert';
 import { Breadcrumbs } from '@/components/ui/Breadcrumbs';
 import { Button } from '@/components/ui/Button';
@@ -21,16 +14,36 @@ import { BaseMenu, BaseMenuItem } from '@/components/ui/form/BaseMenu';
 import { Tabs } from '@/components/ui/Tabs';
 import { Tooltip } from '@/components/ui/Tooltip';
 import { cn } from '@/utils/styles';
-import { useExpertSearchDetail } from '@/hooks/useExpertFinder';
+import { useExpertSearchDetail, useFindMoreExperts } from '@/hooks/useExpertFinder';
+import {
+  clearExpertSearchAppendBaseline,
+  getExpertSearchAppendBaseline,
+  markExpertSearchAppendBaseline,
+  useExpertSearchProgress,
+} from '@/hooks/useExpertSearchProgress';
+import { ApiError } from '@/services/types/api';
+import type { FindMoreExpertsPayload } from '@/services/expertFinder.service';
 import { SearchDetailHeader } from './SearchDetailHeader';
 import { ExpertResultCard } from './ExpertResultCard';
 import { GenerateEmailModal, type GenerateEmailConfirmPayload } from './GenerateEmailModal';
 import { GenerateEmailProgressModal } from './GenerateEmailProgressModal';
 import { ExpertFormModal } from './ExpertFormModal';
+import { FindMoreExpertsModal } from './FindMoreExpertsModal';
 import { GeneratedEmailsList } from '@/app/expert-finder/library/[searchId]/outreach/components/GeneratedEmailsList';
 import { SearchDetailSkeleton } from '@/components/ExpertFinder/SearchDetailSkeleton';
 import { expertHasOutreachHistory, type ExpertResult } from '@/types/expertFinder';
 
+function isFindMoreStep(step: string | null | undefined): boolean {
+  return /find(?:ing)? more/i.test(step ?? '');
+}
+
+function existingExpertsBaseline(detail: {
+  expertResults: { length: number };
+  expertCount: number;
+}): number {
+  return Math.max(detail.expertResults.length, detail.expertCount);
+}
+
 export interface SearchDetailContentProps {
   searchId: string;
 }
@@ -86,7 +99,18 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
   const tab = searchParams?.get('tab') === TAB_OUTREACH ? TAB_OUTREACH : TAB_EXPERT_RESULTS;
 
   const [{ searchDetail, isLoading, error }, refetch] = useExpertSearchDetail(searchId);
+  const [{ isLoading: isFindMoreSubmitting, error: findMoreError }, findMore] =
+    useFindMoreExperts();
+
   const [showAddExpertModal, setShowAddExpertModal] = useState(false);
+  const [showFindMoreModal, setShowFindMoreModal] = useState(false);
+  const [liveRunKey, setLiveRunKey] = useState(0);
+  const [liveExpertsBaseline, setLiveExpertsBaseline] = useState(() =>
+    getExpertSearchAppendBaseline(searchId)
+  );
+  const [appendLiveActive, setAppendLiveActive] = useState(
+    () => getExpertSearchAppendBaseline(searchId) > 0
+  );
 
   const [selectedIndices, setSelectedIndices] = useState<Set<number>>(new Set());
   const [hideContacted, setHideContacted] = useState(false);
@@ -95,6 +119,81 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
   const [generateExperts, setGenerateExperts] = useState<ExpertResult[]>([]);
   const [generatePayload, setGeneratePayload] = useState<GenerateEmailConfirmPayload | null>(null);
 
+  const serverInProgress =
+    searchDetail != null &&
+    (searchDetail.status === 'pending' || searchDetail.status === 'processing');
+  const isInProgress = appendLiveActive || serverInProgress;
+
+  const handleLiveTerminal = useCallback(() => {
+    setAppendLiveActive(false);
+    clearExpertSearchAppendBaseline(searchId);
+    void refetch();
+  }, [refetch, searchId]);
+
+  const beginAppendLiveRun = useCallback(() => {
+    const baseline = searchDetail ? existingExpertsBaseline(searchDetail) : 0;
+    markExpertSearchAppendBaseline(searchId, baseline);
+    setLiveExpertsBaseline(baseline);
+    setLiveRunKey((key) => key + 1);
+    setAppendLiveActive(true);
+  }, [searchDetail, searchId]);
+
+  // Recover append baseline after refresh / remount while find-more is still running.
+  useEffect(() => {
+    if (!serverInProgress || !searchDetail) return;
+    const stored = getExpertSearchAppendBaseline(searchId);
+    if (stored > 0) {
+      setLiveExpertsBaseline(stored);
+      setAppendLiveActive(true);
+      setLiveRunKey((key) => (key > 0 ? key : 1));
+      return;
+    }
+    if (isFindMoreStep(searchDetail.currentStep) && searchDetail.expertResults.length > 0) {
+      const baseline = existingExpertsBaseline(searchDetail);
+      markExpertSearchAppendBaseline(searchId, baseline);
+      setLiveExpertsBaseline(baseline);
+      setAppendLiveActive(true);
+      setLiveRunKey((key) => (key > 0 ? key : 1));
+    }
+  }, [serverInProgress, searchDetail, searchId]);
+
+  const isAppendLiveRun =
+    liveRunKey > 0 || liveExpertsBaseline > 0 || getExpertSearchAppendBaseline(searchId) > 0;
+
+  const liveSeed = useMemo(() => {
+    if (appendLiveActive && searchDetail?.status === 'completed') {
+      return {
+        status: 'processing' as const,
+        progress: 0,
+        currentStep: 'Finding more experts…',
+      };
+    }
+    if (!searchDetail) {
+      return appendLiveActive
+        ? { status: 'processing' as const, progress: 0, currentStep: 'Finding more experts…' }
+        : undefined;
+    }
+    return {
+      status: appendLiveActive ? 'processing' : searchDetail.status,
+      progress: searchDetail.progress,
+      currentStep: searchDetail.currentStep || (isAppendLiveRun ? 'Finding more experts…' : ''),
+    };
+  }, [searchDetail, isAppendLiveRun, appendLiveActive]);
+
+  const {
+    progress: liveProgress,
+    currentStep: liveCurrentStep,
+    status: liveStatus,
+    expertsFound: liveExpertsFound,
+  } = useExpertSearchProgress({
+    searchId,
+    enabled: isInProgress,
+    runKey: liveRunKey,
+    expertsBaseline: liveExpertsBaseline,
+    seed: liveSeed,
+    onTerminal: handleLiveTerminal,
+  });
+
   const toggleSelection = useCallback((index: number) => {
     setSelectedIndices((prev) => {
       const next = new Set(prev);
@@ -124,6 +223,34 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
     setSelectedIndices(new Set());
   }, []);
 
+  const abortAppendLiveRun = useCallback(() => {
+    setAppendLiveActive(false);
+    setLiveExpertsBaseline(0);
+    clearExpertSearchAppendBaseline(searchId);
+  }, [searchId]);
+
+  const handleFindMoreSubmit = useCallback(
+    async (payload: FindMoreExpertsPayload) => {
+      beginAppendLiveRun();
+      try {
+        await findMore(searchId, payload);
+        setShowFindMoreModal(false);
+        await refetch();
+      } catch (err: unknown) {
+        if (err instanceof ApiError && err.status === 409) {
+          // Already running — keep live mode and sync status.
+          toast.error('Search is already running');
+          setShowFindMoreModal(false);
+          await refetch();
+          return;
+        }
+        abortAppendLiveRun();
+        // Modal surfaces findMoreError from the hook
+      }
+    },
+    [beginAppendLiveRun, abortAppendLiveRun, findMore, searchId, refetch]
+  );
+
   const expertResults = searchDetail?.expertResults ?? [];
 
   const visibleExpertEntries = useMemo(
@@ -159,10 +286,6 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
   const expertResultsTabHref = pathname ? `${pathname}?tab=${TAB_EXPERT_RESULTS}` : undefined;
   const outreachTabHref = pathname ? `${pathname}?tab=${TAB_OUTREACH}` : undefined;
 
-  const isInProgress =
-    searchDetail != null &&
-    (searchDetail.status === 'pending' || searchDetail.status === 'processing');
-
   if (isLoading && !searchDetail) {
     return <SearchDetailSkeleton activeTab={tab} />;
   }
@@ -187,10 +310,19 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
     return null;
   }
 
-  const displayedExpertTotal =
-    searchDetail.status === 'completed'
-      ? Math.max(searchDetail.expertCount, searchDetail.expertResults.length)
-      : searchDetail.expertResults.length;
+  const displayedExpertTotal = Math.max(
+    searchDetail.expertCount,
+    searchDetail.expertResults.length
+  );
+
+  const statusAllowsFindMore =
+    searchDetail.status === 'completed' || searchDetail.status === 'failed';
+  const canFindMore = statusAllowsFindMore && !isInProgress;
+
+  const showCompletedResults =
+    searchDetail.status === 'completed' ||
+    (searchDetail.status === 'failed' && searchDetail.expertResults.length > 0) ||
+    (isInProgress && searchDetail.expertResults.length > 0);
 
   const visibleIndices = visibleExpertEntries.map(({ index }) => index);
   const allVisibleSelected =
@@ -203,6 +335,18 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
   // grant (funding round) document.
   const isGrantLinked = searchDetail.work?.contentType === 'funding_request';
 
+  const findMoreButton = canFindMore ? (
+    <Button
+      variant="outlined"
+      size="sm"
+      className="gap-2"
+      onClick={() => setShowFindMoreModal(true)}
+    >
+      <Search className="h-4 w-4" aria-hidden />
+      Find more experts
+    </Button>
+  ) : null;
+
   return (
     <div className="w-full max-w-5xl mx-auto px-4 py-8 space-y-6">
       <Breadcrumbs
@@ -219,12 +363,12 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
 
       <SearchDetailHeader search={searchDetail} />
 
-      {searchDetail.status === 'failed' && (
+      {searchDetail.status === 'failed' ? (
         <div className="space-y-3">
           <Alert variant="error">
             <div>
               <p className="font-semibold mb-1">Search failed</p>
-              <p className="font-normal">
+              <p className="font-normal whitespace-pre-wrap">
                 {searchDetail.errorMessage || 'An error occurred while running the search.'}
               </p>
               {searchDetail.currentStep ? (
@@ -234,10 +378,38 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
               ) : null}
             </div>
           </Alert>
+          {canFindMore && searchDetail.expertResults.length === 0 ? (
+            <div className="flex flex-wrap items-center gap-2">{findMoreButton}</div>
+          ) : null}
         </div>
+      ) : null}
+
+      {searchDetail.status === 'completed' && searchDetail.errorMessage.trim() !== '' && (
+        <Alert variant="warning">
+          <div>
+            <p className="font-semibold mb-1">Find more did not finish cleanly</p>
+            <p className="font-normal text-sm whitespace-pre-wrap">{searchDetail.errorMessage}</p>
+            <p className="font-normal text-sm mt-2 text-amber-900/80">
+              Existing experts from this search are still available below.
+            </p>
+          </div>
+        </Alert>
       )}
 
-      {searchDetail.status === 'completed' && (
+      {isInProgress ? (
+        <ExpertSearchLiveStatus
+          progress={liveProgress}
+          currentStep={
+            liveCurrentStep ||
+            (isAppendLiveRun ? 'Finding more experts…' : searchDetail.currentStep)
+          }
+          status={liveStatus ?? (appendLiveActive ? 'processing' : searchDetail.status)}
+          expertsFound={liveExpertsFound}
+          isAppendRun={isAppendLiveRun}
+        />
+      ) : null}
+
+      {showCompletedResults && (
         <>
           <Tabs
             tabs={[
@@ -301,6 +473,7 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
                     <span className="text-sm text-gray-600">{selectedIndices.size} selected</span>
                   </div>
                   <div className="flex flex-wrap items-center gap-2">
+                    {findMoreButton}
                     <Button
                       variant="default"
                       size="sm"
@@ -391,7 +564,8 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
           ) : tab === TAB_EXPERT_RESULTS ? (
             <div className="rounded-lg border border-gray-200 bg-white p-6 text-center text-gray-600 space-y-3">
               <p>No experts found for this search.</p>
-              <div className="flex justify-center">
+              <div className="flex flex-wrap justify-center gap-2">
+                {findMoreButton}
                 <SearchActionsMenu
                   reportPdfUrl={searchDetail.reportPdfUrl}
                   reportCsvUrl={searchDetail.reportCsvUrl}
@@ -409,6 +583,14 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
         searchId={searchId}
         onSuccess={refetch}
       />
+      <FindMoreExpertsModal
+        isOpen={showFindMoreModal}
+        onClose={() => setShowFindMoreModal(false)}
+        initialAdditionalContext={searchDetail.additionalContext}
+        isSubmitting={isFindMoreSubmitting}
+        error={findMoreError}
+        onSubmit={handleFindMoreSubmit}
+      />
       <GenerateEmailModal
         isOpen={showGenerateModal}
         onClose={() => setShowGenerateModal(false)}
@@ -424,28 +606,6 @@ export function SearchDetailContent({ searchId }: SearchDetailContentProps) {
         generation={generatePayload}
         onDone={handleProgressDone}
       />
-
-      {isInProgress && (
-        <div className="flex flex-wrap items-center gap-3">
-          <p className="text-sm text-gray-500">
-            Re-check status when the search has had time to complete.
-          </p>
-          <Button
-            variant="secondary"
-            size="sm"
-            className="gap-2"
-            onClick={refetch}
-            disabled={isLoading}
-          >
-            {isLoading ? (
-              <Loader2 className="h-4 w-4 animate-spin shrink-0" aria-hidden />
-            ) : (
-              <RefreshCw className="h-4 w-4 shrink-0" aria-hidden />
-            )}
-            <span>{isLoading ? 'Refreshing…' : 'Refresh'}</span>
-          </Button>
-        </div>
-      )}
     </div>
   );
 }
diff --git a/app/expert-finder/library/new/components/ExpertFinderForm.tsx b/app/expert-finder/library/new/components/ExpertFinderForm.tsx
index 62cd327ce..6a127c256 100644
--- a/app/expert-finder/library/new/components/ExpertFinderForm.tsx
+++ b/app/expert-finder/library/new/components/ExpertFinderForm.tsx
@@ -21,15 +21,22 @@ import {
   EXPERT_SEARCH_ADDITIONAL_CONTEXT_MAX_LENGTH,
   ExpertFinderService,
   EXPERTISE_LEVEL_ALL,
+  clampExpertCount,
 } from '@/services/expertFinder.service';
-import { expertFinderFormSchema, type ExpertFinderFormValues, DEFAULT_STATE } from '../schema';
-import { AdvancedConfig } from './AdvancedConfig';
+import {
+  expertFinderFormSchema,
+  type ExpertFinderFormValues,
+  type ExpertCountOption,
+  DEFAULT_STATE,
+} from '../schema';
+import { SearchSettings } from './SearchSettings';
 import { SearchSubmissionProgress } from './SearchSubmissionProgress';
 import { WorkPreviewCard } from './WorkPreviewCard';
 import type { Work } from '@/types/work';
 import { ExpertSearchResult } from '@/types/expertFinder';
 
 const DEFAULT_URL_PLACEHOLDER = 'e.g., https://researchhub.com/paper/123/...';
+const INITIAL_EXPERT_COUNT: ExpertCountOption = 10;
 
 function getAvailableInputTypes(work: Work | null): InputType[] {
   if (work?.contentType === 'paper') {
@@ -44,8 +51,8 @@ const defaultValues: ExpertFinderFormValues = {
   unifiedDocumentId: null,
   url: '',
   additionalContext: '',
-  advanced: {
-    expertCount: 25,
+  settings: {
+    expertCount: INITIAL_EXPERT_COUNT,
     expertiseLevel: [],
     region: DEFAULT_REGION,
     state: DEFAULT_STATE,
@@ -59,6 +66,7 @@ export function ExpertFinderForm() {
   const searchParams = useSearchParams();
   const [{ error: submitError }, createSearch] = useCreateExpertSearch();
   const [createdSearchId, setCreatedSearchId] = useState<number | null>(null);
+  const [createdWsUrl, setCreatedWsUrl] = useState<string | null>(null);
   const [resolveError, setResolveError] = useState<string | null>(null);
   const [selectedSearchId, setSelectedSearchId] = useState<number | null>(null);
   const [isResolvingUrl, setIsResolvingUrl] = useState(false);
@@ -151,7 +159,7 @@ export function ExpertFinderForm() {
       setSelectedSearchId(search?.searchId ?? null);
       if (!search) return;
       const config = search.config as Record<string, unknown>;
-      const expertCount = (config.expert_count as number) ?? 25;
+      const expertCount = clampExpertCount(config.expert_count);
       const rawLevel = config.expertise_level;
       let expertiseLevel: ExpertiseLevel[];
       if (Array.isArray(rawLevel)) {
@@ -171,13 +179,13 @@ export function ExpertFinderForm() {
         unifiedDocumentId: unifiedId,
         url: current.url,
         additionalContext: search.additionalContext ?? current.additionalContext,
-        advanced: {
+        settings: {
           expertCount,
           expertiseLevel,
           region,
           state,
           inputType,
-          searchName: current.advanced.searchName ?? '',
+          searchName: current.settings.searchName ?? '',
         },
       });
       if (search.work) {
@@ -203,25 +211,26 @@ export function ExpertFinderForm() {
     }
 
     try {
-      const adv = data.advanced;
+      const settings = data.settings;
 
       const trimmedAdditionalContext = data.additionalContext?.trim() ?? '';
 
       const payload: ExpertSearchCreatePayload = {
         unified_document_id: unifiedDocumentId,
-        input_type: adv.inputType,
+        input_type: settings.inputType,
         config: {
-          expert_count: adv.expertCount,
-          expertise_level: adv.expertiseLevel,
-          region: adv.region,
-          state: adv.state,
+          expert_count: settings.expertCount,
+          expertise_level: settings.expertiseLevel,
+          region: settings.region,
+          state: settings.state,
         },
-        ...(adv.searchName?.trim() && { name: adv.searchName.trim() }),
+        ...(settings.searchName?.trim() && { name: settings.searchName.trim() }),
         ...(trimmedAdditionalContext && { additional_context: trimmedAdditionalContext }),
       };
 
       const response = await createSearch(payload);
       setCreatedSearchId(response.searchId);
+      setCreatedWsUrl(response.wsUrl);
     } catch (err) {
       const message =
         err instanceof Error ? err.message : 'Failed to start search. Please try again.';
@@ -230,7 +239,7 @@ export function ExpertFinderForm() {
   };
 
   if (createdSearchId !== null) {
-    return <SearchSubmissionProgress searchId={createdSearchId} />;
+    return <SearchSubmissionProgress searchId={createdSearchId} wsUrl={createdWsUrl} />;
   }
 
   const urlRegister = register('url');
@@ -282,13 +291,13 @@ export function ExpertFinderForm() {
         )}
 
         <Controller
-          name="advanced"
+          name="settings"
           control={control}
           render={({ field }) => (
-            <AdvancedConfig
+            <SearchSettings
               values={field.value}
               onChange={field.onChange}
-              errors={errors.advanced}
+              errors={errors.settings}
               availableInputTypes={availableInputTypes}
               contentType={fetchedWork?.contentType}
               onRerunSelect={handleRerunSelect}
diff --git a/app/expert-finder/library/new/components/AdvancedConfig.tsx b/app/expert-finder/library/new/components/SearchSettings.tsx
similarity index 96%
rename from app/expert-finder/library/new/components/AdvancedConfig.tsx
rename to app/expert-finder/library/new/components/SearchSettings.tsx
index 46f14baf1..5e7a96be9 100644
--- a/app/expert-finder/library/new/components/AdvancedConfig.tsx
+++ b/app/expert-finder/library/new/components/SearchSettings.tsx
@@ -11,13 +11,13 @@ import { Textarea } from '@/components/ui/form/Textarea';
 import { Dropdown, DropdownItem, MultiSelectDropdown } from '@/components/ui/form/Dropdown';
 import type { ExpertSearchResult } from '@/types/expertFinder';
 import type { ContentType } from '@/types/work';
-import type { AdvancedConfigFormValues, ExpertFinderFormValues } from '../schema';
-import { EXPERT_COUNT_OPTIONS } from '../schema';
+import type { ExpertFinderFormValues, SearchSettingsFormValues } from '../schema';
 import {
   EXPERTISE_LEVEL_OPTIONS,
   ExpertiseLevel,
   InputType,
   REGION_OPTIONS,
+  getExpertCountOptions,
   getRegionLabel,
 } from '@/services/expertFinder.service';
 import { getFieldErrorMessage } from '@/utils/form';
@@ -30,10 +30,10 @@ const INPUT_TYPE_OPTIONS: { value: InputType; label: string }[] = [
   { value: 'abstract', label: 'Abstract' },
 ];
 
-interface AdvancedConfigProps {
-  values: AdvancedConfigFormValues;
-  onChange: (values: AdvancedConfigFormValues) => void;
-  errors?: FieldErrors<AdvancedConfigFormValues>;
+interface SearchSettingsProps {
+  values: SearchSettingsFormValues;
+  onChange: (values: SearchSettingsFormValues) => void;
+  errors?: FieldErrors<SearchSettingsFormValues>;
   availableInputTypes?: InputType[];
   contentType?: ContentType;
   onRerunSelect: (search: ExpertSearchResult | null) => void;
@@ -44,7 +44,7 @@ interface AdvancedConfigProps {
   additionalContextMaxLength: number;
 }
 
-export function AdvancedConfig({
+export function SearchSettings({
   values,
   onChange,
   errors,
@@ -56,7 +56,7 @@ export function AdvancedConfig({
   additionalContextError,
   additionalContextCharCount,
   additionalContextMaxLength,
-}: AdvancedConfigProps) {
+}: SearchSettingsProps) {
   const hideInputType = contentType !== 'paper';
   const [isExpanded, setIsExpanded] = useState(false);
   const [isLoadingRerun, setIsLoadingRerun] = useState(false);
@@ -77,10 +77,11 @@ export function AdvancedConfig({
   }, [availableInputTypes, values.inputType]);
 
   const regionLabel = getRegionLabel(values.region);
+  const expertCountOptions = getExpertCountOptions();
 
   return (
     <CollapsibleSection
-      title="Advanced Configuration"
+      title="Search settings"
       icon={<Settings className="w-5 h-5" />}
       isExpanded={isExpanded}
       onToggle={() => setIsExpanded(!isExpanded)}
@@ -201,7 +202,7 @@ export function AdvancedConfig({
               onOpenChange={setExpertCountOpen}
             >
               <div className="py-1 max-h-60 overflow-y-auto">
-                {EXPERT_COUNT_OPTIONS.map((option) => (
+                {expertCountOptions.map((option) => (
                   <DropdownItem
                     key={option}
                     onClick={() => onChange({ ...values, expertCount: option })}
diff --git a/app/expert-finder/library/new/components/SearchSubmissionProgress.tsx b/app/expert-finder/library/new/components/SearchSubmissionProgress.tsx
index 51fa0a593..c0216a95a 100644
--- a/app/expert-finder/library/new/components/SearchSubmissionProgress.tsx
+++ b/app/expert-finder/library/new/components/SearchSubmissionProgress.tsx
@@ -1,19 +1,20 @@
 'use client';
 
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useCallback } from 'react';
 import { useRouter } from 'next/navigation';
 import Link from 'next/link';
-import { Loader2, Copy, Check, AlertCircle } from 'lucide-react';
+import { Copy, Check, AlertCircle } from 'lucide-react';
 import { Button, buttonVariants } from '@/components/ui/Button';
 import { cn } from '@/utils/styles';
+import { ExpertSearchLiveStatus } from '@/app/expert-finder/components/ExpertSearchLiveStatus';
 import { useExpertSearchProgress } from '@/hooks/useExpertSearchProgress';
-import { ExpertFinderService } from '@/services/expertFinder.service';
 import toast from 'react-hot-toast';
 
 const SEARCH_DETAIL_PATH = '/expert-finder/library';
 
 interface SearchSubmissionProgressProps {
   searchId: number;
+  wsUrl?: string | null;
 }
 
 function getDetailPageUrl(searchId: number): string {
@@ -21,42 +22,34 @@ function getDetailPageUrl(searchId: number): string {
   return `${globalThis.window.location.origin}${SEARCH_DETAIL_PATH}/${searchId}`;
 }
 
-export function SearchSubmissionProgress({ searchId }: SearchSubmissionProgressProps) {
+export function SearchSubmissionProgress({
+  searchId,
+  wsUrl = null,
+}: SearchSubmissionProgressProps) {
   const router = useRouter();
-  const { status, error, currentStep } = useExpertSearchProgress(searchId);
   const [isCopied, setIsCopied] = useState(false);
-  const [detailErrorMessage, setDetailErrorMessage] = useState<string | null>(null);
   const detailUrl = getDetailPageUrl(searchId);
 
-  const inProgress =
-    status !== 'completed' && status !== 'failed' && status !== null && status !== undefined;
+  const handleTerminal = useCallback(
+    (event: { kind: 'search_finished' | 'search_failed'; status: string }) => {
+      if (event.kind === 'search_finished' && event.status !== 'failed') {
+        router.push(`${SEARCH_DETAIL_PATH}/${searchId}`);
+      }
+    },
+    [router, searchId]
+  );
+
+  const { status, error, currentStep, progress, expertsFound } = useExpertSearchProgress({
+    searchId,
+    wsUrl,
+    onTerminal: handleTerminal,
+  });
 
   useEffect(() => {
     if (status !== 'completed') return;
     router.push(`${SEARCH_DETAIL_PATH}/${searchId}`);
   }, [status, searchId, router]);
 
-  useEffect(() => {
-    if (status !== 'failed') {
-      setDetailErrorMessage(null);
-      return;
-    }
-    let cancelled = false;
-    void (async () => {
-      try {
-        const d = await ExpertFinderService.getSearch(searchId);
-        if (!cancelled && d.errorMessage?.trim()) {
-          setDetailErrorMessage(d.errorMessage.trim());
-        }
-      } catch {
-        /* ignore */
-      }
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [status, searchId]);
-
   const handleCopy = () => {
     if (!detailUrl) return;
     navigator.clipboard.writeText(detailUrl).then(
@@ -69,7 +62,7 @@ export function SearchSubmissionProgress({ searchId }: SearchSubmissionProgressP
     );
   };
 
-  const failureMessage = error?.trim() || detailErrorMessage;
+  const failureMessage = error?.trim() || null;
 
   let statusHeading: string;
   if (status === 'failed') {
@@ -80,6 +73,8 @@ export function SearchSubmissionProgress({ searchId }: SearchSubmissionProgressP
     statusHeading = 'Search in progress';
   }
 
+  const showLiveStatus = status !== 'failed';
+
   return (
     <div className="rounded-lg border border-gray-200 bg-white p-6 shadow-sm">
       <h3 className="text-sm font-semibold text-gray-900 mb-3">{statusHeading}</h3>
@@ -110,22 +105,15 @@ export function SearchSubmissionProgress({ searchId }: SearchSubmissionProgressP
             </Link>
           </div>
         </div>
-      ) : (
-        <>
-          <div className="flex items-center gap-3 mb-4">
-            <Loader2 className="h-6 w-6 animate-spin text-primary-600 shrink-0" />
-            <div className="min-w-0">
-              <p className="text-sm text-gray-600">Finding experts… This can take a bit of time.</p>
-              {inProgress && currentStep ? (
-                <p className="text-sm text-gray-500 mt-1">
-                  <span className="font-medium text-gray-700">Progress:</span> {currentStep}
-                </p>
-              ) : null}
-            </div>
-          </div>
-          {error ? <p className="text-sm text-red-600 mb-4">{error}</p> : null}
-        </>
-      )}
+      ) : showLiveStatus ? (
+        <ExpertSearchLiveStatus
+          className="mb-4"
+          progress={progress}
+          currentStep={currentStep}
+          status={status}
+          expertsFound={expertsFound}
+        />
+      ) : null}
 
       <p className="text-sm text-gray-500 mb-4">
         Feel free to close this window and check results later by visiting the search details page.
diff --git a/app/expert-finder/library/new/schema.ts b/app/expert-finder/library/new/schema.ts
index 921bb4f52..24218b3b4 100644
--- a/app/expert-finder/library/new/schema.ts
+++ b/app/expert-finder/library/new/schema.ts
@@ -1,15 +1,17 @@
 import { z } from 'zod';
 import {
   ExpertiseLevel,
+  EXPERT_COUNT_OPTIONS,
   EXPERT_SEARCH_ADDITIONAL_CONTEXT_MAX_LENGTH,
   InputType,
   Region,
+  type ExpertCountOption,
 } from '@/services/expertFinder.service';
 
 const INPUT_TYPES: InputType[] = ['abstract', 'pdf', 'full_content'];
 
-export const EXPERT_COUNT_OPTIONS = [5, 10, 25, 50, 100] as const;
-export type ExpertCountOption = (typeof EXPERT_COUNT_OPTIONS)[number];
+export { EXPERT_COUNT_OPTIONS };
+export type { ExpertCountOption };
 
 export const DEFAULT_STATE = 'All States';
 
@@ -30,14 +32,24 @@ export const REGION_VALUES: [Region, ...Region[]] = [
   'africa_mena',
 ];
 
-export const advancedConfigSchema = z.object({
-  expertCount: z.number().default(25),
-  expertiseLevel: z.array(z.enum(EXPERTISE_LEVELS_SPECIFIC)).default([]),
-  region: z.enum(REGION_VALUES),
-  state: z.string(),
-  inputType: z.enum(INPUT_TYPES as [InputType, ...InputType[]]).default('full_content'),
-  searchName: z.string().optional().default(''),
-});
+export const searchSettingsSchema = z
+  .object({
+    expertCount: z.number(),
+    expertiseLevel: z.array(z.enum(EXPERTISE_LEVELS_SPECIFIC)).default([]),
+    region: z.enum(REGION_VALUES),
+    state: z.string(),
+    inputType: z.enum(INPUT_TYPES as [InputType, ...InputType[]]).default('full_content'),
+    searchName: z.string().optional().default(''),
+  })
+  .superRefine((data, ctx) => {
+    if (!(EXPERT_COUNT_OPTIONS as readonly number[]).includes(data.expertCount)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Must be ${EXPERT_COUNT_OPTIONS.join(', ')}`,
+        path: ['expertCount'],
+      });
+    }
+  });
 
 export const DOCUMENT_REQUIRED_MESSAGE =
   'Document is required. Paste a ResearchHub URL and click the checkmark to select a document.';
@@ -47,7 +59,7 @@ export const expertFinderFormSchema = z
     unifiedDocumentId: z.number().nullable().default(null),
     url: z.string().optional().default(''),
     additionalContext: z.string().max(EXPERT_SEARCH_ADDITIONAL_CONTEXT_MAX_LENGTH).default(''),
-    advanced: advancedConfigSchema,
+    settings: searchSettingsSchema,
   })
   .refine((data) => data.unifiedDocumentId != null, {
     message: DOCUMENT_REQUIRED_MESSAGE,
@@ -55,4 +67,4 @@ export const expertFinderFormSchema = z
   });
 
 export type ExpertFinderFormValues = z.infer<typeof expertFinderFormSchema>;
-export type AdvancedConfigFormValues = z.infer<typeof advancedConfigSchema>;
+export type SearchSettingsFormValues = z.infer<typeof searchSettingsSchema>;
diff --git a/hooks/useExpertFinder.ts b/hooks/useExpertFinder.ts
index c97201168..6f5dd0260 100644
--- a/hooks/useExpertFinder.ts
+++ b/hooks/useExpertFinder.ts
@@ -7,11 +7,13 @@ import {
   type AddExpertPayload,
   type CreateSavedTemplatePayload,
   type ExpertSearchCreatePayload,
+  type FindMoreExpertsPayload,
   type PatchExpertPayload,
   type UpdateGeneratedEmailPayload,
   type UpdateSavedTemplatePayload,
 } from '@/services/expertFinder.service';
 import { extractApiErrorMessage } from '@/services/lib/serviceUtils';
+import { ApiError } from '@/services/types/api';
 import type {
   ExpertResult,
   ExpertSearchCreated,
@@ -273,6 +275,58 @@ export function useCreateExpertSearch(): UseCreateExpertSearchReturn {
   return [{ created, isLoading, error }, createSearch];
 }
 
+// ── useFindMoreExperts ───────────────────────────────────────────────────────
+
+interface UseFindMoreExpertsState {
+  isLoading: boolean;
+  error: string | null;
+  alreadyRunning: boolean;
+}
+
+type FindMoreExpertsFn = (
+  searchId: number | string,
+  payload?: FindMoreExpertsPayload
+) => Promise<ExpertSearchCreated>;
+type UseFindMoreExpertsReturn = [UseFindMoreExpertsState, FindMoreExpertsFn];
+
+/**
+ * Request additional experts for an existing search.
+ * Callers should treat alreadyRunning (409) by refreshing search status.
+ */
+export function useFindMoreExperts(): UseFindMoreExpertsReturn {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [alreadyRunning, setAlreadyRunning] = useState(false);
+
+  const findMore = useCallback(
+    async (
+      searchId: number | string,
+      payload?: FindMoreExpertsPayload
+    ): Promise<ExpertSearchCreated> => {
+      setIsLoading(true);
+      setError(null);
+      setAlreadyRunning(false);
+      try {
+        return await ExpertFinderService.findMoreExperts(searchId, payload);
+      } catch (err: unknown) {
+        if (err instanceof ApiError && err.status === 409) {
+          setAlreadyRunning(true);
+          setError(extractApiErrorMessage(err, 'Search is already running'));
+          throw err;
+        }
+        const message = extractApiErrorMessage(err, 'Failed to find more experts');
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    []
+  );
+
+  return [{ isLoading, error, alreadyRunning }, findMore];
+}
+
 // ── usePatchExpert ────────────────────────────────────────────────────────────
 
 interface UsePatchExpertState {
diff --git a/hooks/useExpertSearchProgress.ts b/hooks/useExpertSearchProgress.ts
index a92cba212..a40655498 100644
--- a/hooks/useExpertSearchProgress.ts
+++ b/hooks/useExpertSearchProgress.ts
@@ -1,160 +1,221 @@
 'use client';
 
-import { useState, useEffect, useRef, useCallback } from 'react';
-import { transformExpertSearchProgressEvent } from '@/types/expertFinder';
-import { SearchStatus, ExpertFinderService } from '@/services/expertFinder.service';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { parseExpertSearchWsEvent, type ExpertSearchWsEvent } from '@/types/expertFinder';
+import { ExpertFinderService, type SearchStatus } from '@/services/expertFinder.service';
+import { WS_ROUTES } from '@/services/websocket';
+import { useReconnectingSocket, type SocketStatus } from './useReconnectingSocket';
 
-interface UseExpertSearchProgressReturn {
+const FATAL_CLOSE_CODES: ReadonlySet<number> = new Set([4401, 4403, 4404]);
+
+const appendBaselinesBySearchId = new Map<string, number>();
+
+export function markExpertSearchAppendBaseline(searchId: number | string, baseline: number): void {
+  appendBaselinesBySearchId.set(String(searchId), Math.max(0, Math.floor(baseline)));
+}
+
+export function clearExpertSearchAppendBaseline(searchId: number | string): void {
+  appendBaselinesBySearchId.delete(String(searchId));
+}
+
+export function getExpertSearchAppendBaseline(searchId: number | string): number {
+  return appendBaselinesBySearchId.get(String(searchId)) ?? 0;
+}
+
+export interface ExpertSearchProgressSeed {
+  status?: SearchStatus | null;
+  progress?: number;
+  currentStep?: string;
+}
+
+interface UseExpertSearchProgressOptions {
+  searchId: number | string | null;
+  wsUrl?: string | null;
+  enabled?: boolean;
+  /**
+   * Bump when starting a new live run on the same search (e.g. find-more) so progress
+   * and the new-experts counter reset.
+   */
+  runKey?: number;
+  expertsBaseline?: number;
+  seed?: ExpertSearchProgressSeed;
+  onTerminal?: (
+    event: Extract<ExpertSearchWsEvent, { kind: 'search_finished' | 'search_failed' }>
+  ) => void;
+}
+
+export interface UseExpertSearchProgressReturn {
   progress: number;
   currentStep: string;
-  status: SearchStatus | 'connected' | null;
+  status: SearchStatus | null;
+  /** Experts found in the current live run only (not prior append baseline). */
+  expertsFound: number;
   error: string | null;
   isConnected: boolean;
+  isTerminal: boolean;
+  socketStatus: SocketStatus;
+}
+
+function toRunExpertsFound(reported: number, baseline: number, prevShown = 0): number {
+  const n = Math.max(0, reported);
+  if (baseline <= 0) return n;
+  if (n > baseline) return n - baseline;
+  if (n < baseline) return n;
+  // n === baseline
+  if (prevShown === baseline - 1 || prevShown === baseline) return n;
+  return 0;
+}
+
+function resolveBaseline(searchId: number | string | null, expertsBaseline: number): number {
+  if (expertsBaseline > 0) return expertsBaseline;
+  if (searchId == null) return 0;
+  return getExpertSearchAppendBaseline(searchId);
 }
 
 /**
- * SSE hook for tracking expert search progress.
- *
- * The hook automatically cleans up when:
- * - The search reaches "completed" or "failed" status
- * - The component unmounts
- * - The searchId changes
+ * Live expert-search progress over WebSocket (Token subprotocol).
+ * Progress % comes from search_progress / terminal events; expert count from experts_found only.
  */
-export const useExpertSearchProgress = (
-  searchId: number | string | null
-): UseExpertSearchProgressReturn => {
+export function useExpertSearchProgress({
+  searchId,
+  wsUrl = null,
+  enabled = true,
+  runKey = 0,
+  expertsBaseline = 0,
+  seed,
+  onTerminal,
+}: UseExpertSearchProgressOptions): UseExpertSearchProgressReturn {
   const [progress, setProgress] = useState(0);
   const [currentStep, setCurrentStep] = useState('');
-  const [status, setStatus] = useState<SearchStatus | 'connected' | null>(null);
+  const [status, setStatus] = useState<SearchStatus | null>(null);
+  const [expertsFound, setExpertsFound] = useState(0);
   const [error, setError] = useState<string | null>(null);
-  const [isConnected, setIsConnected] = useState(false);
-  const abortControllerRef = useRef<AbortController | null>(null);
-  const readerRef = useRef<ReadableStreamDefaultReader<Uint8Array> | null>(null);
-
-  const cleanup = useCallback(() => {
-    if (readerRef.current) {
-      readerRef.current.releaseLock();
-      readerRef.current = null;
-    }
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      abortControllerRef.current = null;
-    }
-    setIsConnected(false);
-  }, []);
-
-  useEffect(() => {
-    if (!searchId) return;
-
-    const abortController = new AbortController();
-    abortControllerRef.current = abortController;
-
-    const connect = async () => {
-      try {
-        const response = await ExpertFinderService.openProgressStream(
-          searchId,
-          abortController.signal
+  const [isTerminal, setIsTerminal] = useState(false);
+
+  const onTerminalRef = useRef(onTerminal);
+  onTerminalRef.current = onTerminal;
+  const terminalHandledRef = useRef(false);
+  // True after the first WS progress/terminal frame for this run — stop adopting REST seed.
+  const wsProgressReceivedRef = useRef(false);
+  const baseline = resolveBaseline(searchId, expertsBaseline);
+  const expertsBaselineRef = useRef(baseline);
+  expertsBaselineRef.current = baseline;
+
+  const resolvedUrl = useMemo(() => {
+    if (searchId == null) return null;
+    const fromApi = wsUrl?.trim();
+    if (fromApi) return fromApi;
+    return WS_ROUTES.EXPERT_FINDER_SEARCH(searchId);
+  }, [searchId, wsUrl]);
+
+  const socketEnabled = enabled && searchId != null && !isTerminal && resolvedUrl != null;
+
+  const applyDetailSnapshot = useCallback(async () => {
+    if (searchId == null) return;
+    try {
+      const detail = await ExpertFinderService.getSearch(searchId);
+      setStatus(detail.status);
+      // Prefer REST progress until WS has sent a progress frame for this run.
+      if (!wsProgressReceivedRef.current && typeof detail.progress === 'number') {
+        setProgress((prev) => Math.max(prev, detail.progress));
+      }
+      if (detail.currentStep) {
+        setCurrentStep((prev) =>
+          wsProgressReceivedRef.current ? prev || detail.currentStep : detail.currentStep
         );
+      }
+      if (detail.errorMessage?.trim()) setError(detail.errorMessage.trim());
+      if (detail.status === 'completed' || detail.status === 'failed') {
+        setIsTerminal(true);
+        if (searchId != null) clearExpertSearchAppendBaseline(searchId);
+      }
+    } catch {}
+  }, [searchId]);
+
+  const handleEvent = useCallback(
+    (event: ExpertSearchWsEvent) => {
+      if (event.kind === 'search_progress') {
+        wsProgressReceivedRef.current = true;
+        setStatus(event.status);
+        setProgress(event.progress);
+        if (event.currentStep) setCurrentStep(event.currentStep);
+        return;
+      }
 
-        if (!response.ok) {
-          throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
-        }
+      if (event.kind === 'experts_found') {
+        setExpertsFound((prev) => {
+          const next = toRunExpertsFound(event.expertCount, expertsBaselineRef.current, prev);
+          return Math.max(prev, next);
+        });
+        return;
+      }
 
-        if (!response.body) {
-          throw new Error('ReadableStream not supported');
+      if (event.kind === 'search_finished' || event.kind === 'search_failed') {
+        wsProgressReceivedRef.current = true;
+        setStatus(event.status);
+        setProgress(event.progress);
+        if (event.currentStep) setCurrentStep(event.currentStep);
+        if (event.kind === 'search_finished' && event.expertCount != null) {
+          const baseline = expertsBaselineRef.current;
+          const absolute = Math.max(0, event.expertCount);
+          const next = baseline > 0 ? Math.max(0, absolute - baseline) : absolute;
+          setExpertsFound(next);
         }
-
-        setIsConnected(true);
-
-        const reader = response.body.getReader();
-        readerRef.current = reader;
-        const decoder = new TextDecoder();
-        let buffer = '';
-
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done || abortController.signal.aborted) {
-            break;
-          }
-
-          buffer += decoder.decode(value, { stream: true });
-          const messages = buffer.split('\n\n');
-          buffer = messages.pop() || '';
-
-          for (const message of messages) {
-            if (!message.trim()) continue;
-
-            const lines = message.split('\n');
-            let eventType = '';
-            let eventData = '';
-
-            for (const line of lines) {
-              if (line.startsWith('event: ')) {
-                eventType = line.slice(7).trim();
-              } else if (line.startsWith('data: ')) {
-                eventData = line.slice(6);
-              }
-            }
-
-            if (!eventData) continue;
-
-            try {
-              const data = transformExpertSearchProgressEvent(JSON.parse(eventData));
-
-              if (eventType === 'connected') {
-                setStatus('connected');
-                continue;
-              }
-
-              if (eventType === 'complete') {
-                setStatus('completed');
-                cleanup();
-                return;
-              }
-
-              if (eventType === 'progress') {
-                if (data.status && data.status !== 'connected') {
-                  setStatus(data.status);
-                }
-                if (typeof data.progress === 'number') {
-                  setProgress(data.progress);
-                }
-                if (data.currentStep) {
-                  setCurrentStep(data.currentStep);
-                }
-                if (data.error) {
-                  setError(data.error);
-                }
-                if (data.status === 'completed' || data.status === 'failed') {
-                  cleanup();
-                  return;
-                }
-              }
-            } catch {
-              /* skip malformed event data */
-            }
-          }
+        if (event.error) setError(event.error);
+        setIsTerminal(true);
+        if (searchId != null) clearExpertSearchAppendBaseline(searchId);
+        if (!terminalHandledRef.current) {
+          terminalHandledRef.current = true;
+          onTerminalRef.current?.(event);
         }
-      } catch (err: any) {
-        if (err?.name === 'AbortError') return;
-        setError(err?.message || 'Failed to connect to progress stream');
-        setIsConnected(false);
       }
-    };
+    },
+    [searchId]
+  );
+
+  const socketStatus = useReconnectingSocket({
+    url: resolvedUrl,
+    enabled: socketEnabled,
+    fatalCloseCodes: FATAL_CLOSE_CODES,
+    onMessage: (data) => {
+      const event = parseExpertSearchWsEvent(data);
+      if (event) handleEvent(event);
+    },
+    onReconnect: () => {
+      void applyDetailSnapshot();
+    },
+  });
 
-    connect();
+  useEffect(() => {
+    terminalHandledRef.current = false;
+    wsProgressReceivedRef.current = false;
+    setIsTerminal(false);
+    setError(null);
+    setExpertsFound(0);
+    setProgress(seed?.progress ?? 0);
+    setCurrentStep(seed?.currentStep ?? '');
+    setStatus(seed?.status ?? null);
+  }, [searchId, runKey, baseline]);
 
-    return () => {
-      cleanup();
-    };
-  }, [searchId, cleanup]);
+  useEffect(() => {
+    if (!enabled || wsProgressReceivedRef.current) return;
+    if (seed?.status != null) setStatus(seed.status);
+    if (typeof seed?.progress === 'number') {
+      setProgress((prev) => Math.max(prev, seed.progress!));
+    }
+    if (seed?.currentStep) {
+      setCurrentStep((prev) => prev || seed.currentStep!);
+    }
+  }, [enabled, seed?.status, seed?.progress, seed?.currentStep]);
 
   return {
     progress,
     currentStep,
     status,
+    expertsFound,
     error,
-    isConnected,
+    isConnected: socketStatus === 'open',
+    isTerminal,
+    socketStatus,
   };
-};
+}
diff --git a/services/expertFinder.service.ts b/services/expertFinder.service.ts
index 10167d2d0..5da98a9e6 100644
--- a/services/expertFinder.service.ts
+++ b/services/expertFinder.service.ts
@@ -82,6 +82,24 @@ export function getRegionLabel(value: Region): string {
   return REGION_OPTIONS.find((o) => o.value === value)?.label ?? value;
 }
 
+/** Allowed `expert_count` values (API: 5–25). */
+export const EXPERT_COUNT_OPTIONS = [5, 10, 25] as const;
+
+export type ExpertCountOption = (typeof EXPERT_COUNT_OPTIONS)[number];
+
+export function getExpertCountOptions(): readonly ExpertCountOption[] {
+  return EXPERT_COUNT_OPTIONS;
+}
+
+/** Coerce a count into a valid option; default 10. */
+export function clampExpertCount(count: unknown): ExpertCountOption {
+  const n = Number(count);
+  if ((EXPERT_COUNT_OPTIONS as readonly number[]).includes(n)) {
+    return n as ExpertCountOption;
+  }
+  return 10;
+}
+
 export interface ExpertSearchCreatePayload {
   unified_document_id: number;
   input_type: InputType;
@@ -95,6 +113,12 @@ export interface ExpertSearchCreatePayload {
   additional_context?: string;
 }
 
+/** POST body for find-more on an existing search. */
+export interface FindMoreExpertsPayload {
+  expert_count?: number;
+  additional_context?: string;
+}
+
 /** PATCH body for canonical expert (wire format, snake_case). */
 export type PatchExpertPayload = Partial<{
   honorific: string;
@@ -217,6 +241,26 @@ export class ExpertFinderService {
     return transformExpertSearchCreateResponse(raw);
   }
 
+  /**
+   * Request additional experts for an existing search (appended when done).
+   * POST /api/research_ai/expert-finder/searches/:searchId/find-more/
+   */
+  static async findMoreExperts(
+    searchId: number | string,
+    payload?: FindMoreExpertsPayload
+  ): Promise<ExpertSearchCreated> {
+    const body: Record<string, unknown> = {};
+    if (payload?.expert_count != null) body.expert_count = payload.expert_count;
+    if (payload && 'additional_context' in payload) {
+      body.additional_context = payload.additional_context ?? '';
+    }
+    const raw = await ApiClient.post<Record<string, unknown>>(
+      `${this.BASE_PATH}/searches/${searchId}/find-more/`,
+      body
+    );
+    return transformExpertSearchCreateResponse(raw);
+  }
+
   /**
    * Fetch full detail for a single expert search.
    * GET /api/research_ai/expert-finder/searches/:searchId/
@@ -276,19 +320,6 @@ export class ExpertFinderService {
     };
   }
 
-  /**
-   * Open an authenticated SSE stream for expert search progress.
-   *
-   * @param searchId – expert search id
-   * @param signal – optional AbortSignal to cancel the request
-   * @returns Response with response.body as ReadableStream (SSE)
-   */
-  static openProgressStream(searchId: number | string, signal?: AbortSignal): Promise<Response> {
-    return ApiClient.getStream(`${this.BASE_PATH}/progress/${searchId}/`, {
-      signal,
-    });
-  }
-
   /**
    * Fetches a work by content type and document ID (for preview, etc.).
    *
diff --git a/services/websocket.ts b/services/websocket.ts
index c0b8e9b3c..5f7b58488 100644
--- a/services/websocket.ts
+++ b/services/websocket.ts
@@ -7,6 +7,8 @@ export const WS_ROUTES = {
   NOTE_VERSIONS: (noteId: string | number) => `${getWebSocketBaseUrl()}/notebook/notes/${noteId}/`,
   ASSISTANT_CHAT: (chatId: string | number) =>
     `${getWebSocketBaseUrl()}/assistant/chats/${chatId}/`,
+  EXPERT_FINDER_SEARCH: (searchId: string | number) =>
+    `${getWebSocketBaseUrl()}/expert-finder/searches/${searchId}/`,
 };
 
 function getWebSocketBaseUrl(): string {
diff --git a/types/expertFinder.ts b/types/expertFinder.ts
index bf6e8ff7a..e139eb8ea 100644
--- a/types/expertFinder.ts
+++ b/types/expertFinder.ts
@@ -183,22 +183,129 @@ export interface ExpertSearchListResponse {
   offset: number;
 }
 
-/** Result of creating an expert search. */
+/** Result of creating an expert search (or find-more). */
 export interface ExpertSearchCreated {
   searchId: number;
   status: SearchStatus;
   message: string;
-  sseUrl: string | null;
+  wsUrl: string | null;
+  expertCount?: number;
+  append?: boolean;
 }
 
-/** SSE progress event. */
-export interface ExpertSearchProgress {
-  status: SearchStatus | 'connected';
-  progress?: number;
-  currentStep?: string;
-  taskType?: string;
-  taskId?: string;
-  error?: string;
+const SEARCH_STATUSES: readonly SearchStatus[] = ['pending', 'processing', 'completed', 'failed'];
+
+/** Normalize API status (often uppercase) to client SearchStatus. */
+export function normalizeSearchStatus(
+  raw: unknown,
+  fallback: SearchStatus = 'pending'
+): SearchStatus {
+  const value = String(raw ?? '')
+    .trim()
+    .toLowerCase();
+  return (SEARCH_STATUSES as readonly string[]).includes(value)
+    ? (value as SearchStatus)
+    : fallback;
+}
+
+export type ExpertSearchWsEventKind =
+  | 'search_progress'
+  | 'experts_found'
+  | 'search_finished'
+  | 'search_failed';
+
+export type ExpertSearchWsEvent =
+  | {
+      kind: 'search_progress';
+      searchId: number;
+      status: SearchStatus;
+      progress: number;
+      currentStep: string;
+    }
+  | {
+      kind: 'experts_found';
+      searchId: number;
+      expertCount: number;
+    }
+  | {
+      kind: 'search_finished';
+      searchId: number;
+      status: SearchStatus;
+      progress: number;
+      currentStep: string;
+      expertCount?: number;
+      error?: string;
+    }
+  | {
+      kind: 'search_failed';
+      searchId: number;
+      status: SearchStatus;
+      progress: number;
+      currentStep: string;
+      error?: string;
+    };
+
+const WS_EVENT_KINDS: readonly ExpertSearchWsEventKind[] = [
+  'search_progress',
+  'experts_found',
+  'search_finished',
+  'search_failed',
+];
+
+function parseOptionalNumber(raw: unknown): number | undefined {
+  if (raw == null || raw === '') return undefined;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+/** Parse a WebSocket JSON frame into a typed expert-search event, or null. */
+export function parseExpertSearchWsEvent(raw: unknown): ExpertSearchWsEvent | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const obj = raw as Record<string, unknown>;
+  const kind = String(obj.kind ?? '').trim();
+  if (!(WS_EVENT_KINDS as readonly string[]).includes(kind)) return null;
+
+  const searchId = Number(obj.search_id ?? 0);
+  if (!Number.isFinite(searchId)) return null;
+
+  if (kind === 'experts_found') {
+    const expertCount = parseOptionalNumber(obj.expert_count);
+    if (expertCount == null) return null;
+    return { kind, searchId, expertCount };
+  }
+
+  const status = normalizeSearchStatus(
+    obj.status,
+    kind === 'search_failed' ? 'failed' : 'processing'
+  );
+  const progress = parseOptionalNumber(obj.progress) ?? (kind === 'search_finished' ? 100 : 0);
+  const currentStep = obj.current_step != null ? String(obj.current_step) : '';
+  const error =
+    obj.error != null && String(obj.error).trim() !== '' ? String(obj.error).trim() : undefined;
+  const expertCount = parseOptionalNumber(obj.expert_count);
+
+  if (kind === 'search_progress') {
+    return { kind, searchId, status, progress, currentStep };
+  }
+  if (kind === 'search_finished') {
+    return {
+      kind,
+      searchId,
+      status: status === 'failed' ? 'failed' : 'completed',
+      progress,
+      currentStep,
+      ...(expertCount !== undefined ? { expertCount } : {}),
+      ...(error !== undefined ? { error } : {}),
+    };
+  }
+  return {
+    kind: 'search_failed',
+    searchId,
+    status: 'failed',
+    progress,
+    currentStep,
+    ...(error !== undefined ? { error } : {}),
+  };
 }
 
 function defaultSourceLabel(url: string, text: string): string {
@@ -206,7 +313,9 @@ function defaultSourceLabel(url: string, text: string): string {
   if (isLinkedInUrl(url)) return 'LinkedIn';
   if (isXUrl(url)) return 'X';
   try {
-    return new URL(url).hostname.replace(/^www\./, '') || 'Source';
+    const hostname = new URL(url).hostname.replace(/^www\./, '').toLowerCase();
+    if (hostname.includes('openalex.org')) return 'OpenAlex';
+    return hostname || 'Source';
   } catch {
     return 'Source';
   }
@@ -236,6 +345,8 @@ function transformExpertSource(raw: string | Record<string, unknown>): ExpertSou
     (typeHint === 'x' || typeHint === 'twitter' || typeHint.includes('twitter'))
   ) {
     text = 'X';
+  } else if (!text && (typeHint === 'openalex' || typeHint.includes('openalex'))) {
+    text = 'OpenAlex';
   }
 
   return { url: normalized, text: defaultSourceLabel(normalized, text) };
@@ -384,7 +495,7 @@ export const transformExpertSearch = createTransformer<any, ExpertSearchResult>(
     inputType: raw.input_type ?? 'abstract',
     config: raw.config ?? {},
     llmModel: raw.llm_model ?? '',
-    status: raw.status ?? 'pending',
+    status: normalizeSearchStatus(raw.status),
     progress: raw.progress ?? 0,
     currentStep: raw.current_step ?? '',
     expertResults,
@@ -408,7 +519,7 @@ export const transformExpertSearchListItem = createTransformer<any, ExpertSearch
     searchId: raw.search_id ?? 0,
     name: raw.name ?? '',
     query: raw.query ?? '',
-    status: raw.status ?? 'pending',
+    status: normalizeSearchStatus(raw.status),
     expertCount: raw.expert_count ?? 0,
     createdAt: raw.created_at ?? '',
     completedAt: raw.completed_at ?? null,
@@ -417,23 +528,22 @@ export const transformExpertSearchListItem = createTransformer<any, ExpertSearch
 );
 
 export const transformExpertSearchCreateResponse = createTransformer<any, ExpertSearchCreated>(
-  (raw) => ({
-    searchId: raw.search_id ?? 0,
-    status: raw.status ?? 'pending',
-    message: raw.message ?? '',
-    sseUrl: raw.sse_url ?? null,
-  })
-);
-
-export const transformExpertSearchProgressEvent = createTransformer<any, ExpertSearchProgress>(
-  (raw) => ({
-    status: raw.status ?? 'pending',
-    progress: raw.progress,
-    currentStep: raw.current_step,
-    taskType: raw.task_type,
-    taskId: raw.task_id,
-    error: raw.error,
-  })
+  (raw) => {
+    const expertCountRaw = raw.expert_count;
+    const expertCount =
+      expertCountRaw != null && Number.isFinite(Number(expertCountRaw))
+        ? Number(expertCountRaw)
+        : undefined;
+    const wsUrlRaw = raw.ws_url != null ? String(raw.ws_url).trim() : '';
+    return {
+      searchId: raw.search_id ?? 0,
+      status: normalizeSearchStatus(raw.status),
+      message: raw.message ?? '',
+      wsUrl: wsUrlRaw || null,
+      ...(expertCount !== undefined ? { expertCount } : {}),
+      ...(typeof raw.append === 'boolean' ? { append: raw.append } : {}),
+    };
+  }
 );
 
 // ── Generated emails ─────────────────────────────────