fix: address open triage issues (#21,#26,#45,#46,#47,#30-33)

- #45: re-read local folder when recursive checkbox toggles
- #47: clear Identify crop spinner when image is already cached
- #46: search selected people by person_ids; AND for "First Last"
- #21: enqueue network import without blocking API walk
- #26: serve resized grid thumbnails for photos
- #30/#31/#33: re-enable small-face filters in auto-match

admin-frontend/src/api/photos.ts

@@ -136,6 +136,7 @@ export const photosApi = {
   searchPhotos: async (params: {
     search_type: 'name' | 'date' | 'tags' | 'no_faces' | 'no_tags' | 'processed' | 'unprocessed' | 'favorites'
     person_name?: string
+    person_ids?: string
     tag_names?: string
     match_all?: boolean
     date_from?: string

admin-frontend/src/pages/Identify.tsx

@@ -600,6 +600,21 @@ export default function Identify() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [currentFace?.id, compareEnabled])
 
+  // Clear loading when crop is already cached (browser may skip onLoad) — #47
+  useEffect(() => {
+    if (!currentFace || !restorationCompleteRef.current) return
+    const baseUrl = apiClient.defaults.baseURL || ''
+    const url = `${baseUrl}/api/v1/faces/${currentFace.id}/crop`
+    const probe = new Image()
+    probe.onload = () => setImageLoading(false)
+    probe.onerror = () => setImageLoading(false)
+    probe.src = url
+    // If already complete from cache, onload may have fired sync before handlers
+    if (probe.complete && probe.naturalWidth > 0) {
+      setImageLoading(false)
+    }
+  }, [currentFace?.id])
+
   // Preload images for next/previous faces
   useEffect(() => {
     if (!currentFace || faces.length === 0) return
@@ -1293,6 +1308,12 @@ export default function Identify() {
                     className="max-w-full max-h-full object-contain pointer-events-none"
                     crossOrigin="anonymous"
                     loading="eager"
+                    ref={(el) => {
+                      // Cached images often skip onLoad — clear spinner if already complete (#47)
+                      if (el && el.complete && el.naturalWidth > 0) {
+                        setImageLoading(false)
+                      }
+                    }}
                     onLoad={() => setImageLoading(false)}
                     onError={(e) => {
                       const target = e.target as HTMLImageElement

admin-frontend/src/pages/Scan.tsx

@@ -76,6 +76,8 @@ export default function Scan() {
   } | null>(null)
   const [selectedFiles, setSelectedFiles] = useState<File[]>([])
   const fileInputRef = useRef<HTMLInputElement | null>(null)
+  // Keep directory handle so toggling "recursive" can re-read without re-picking the folder (#45)
+  const dirHandleRef = useRef<FileSystemDirectoryHandle | null>(null)
   const [currentJob, setCurrentJob] = useState<JobResponse | null>(null)
   const [jobProgress, setJobProgress] = useState<JobProgress | null>(null)
   const [importResult, setImportResult] = useState<{
@@ -95,6 +97,36 @@ export default function Scan() {
     }
   }, [])
 
+  // Re-read local folder when recursive checkbox changes (#45)
+  useEffect(() => {
+    const handle = dirHandleRef.current
+    if (!handle || scanMode !== 'local' || isImporting) return
+
+    let cancelled = false
+    ;(async () => {
+      try {
+        const files = await readDirectoryRecursive(handle, recursive)
+        if (cancelled) return
+        setSelectedFiles(files)
+        setImportResult(null)
+        if (files.length === 0) {
+          setError('No supported image or video files found with current recursive setting.')
+        } else {
+          setError(null)
+        }
+      } catch (err: any) {
+        if (!cancelled) {
+          setError(err?.message || 'Failed to re-read folder after recursive toggle')
+        }
+      }
+    })()
+
+    return () => {
+      cancelled = true
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [recursive])
+
   const handleFolderBrowse = () => {
     setError(null)
     setShowFolderBrowser(true)
@@ -215,10 +247,11 @@ export default function Scan() {
           // Show directory picker
           // @ts-ignore - File System Access API types may not be available
           const dirHandle = await window.showDirectoryPicker()
+          dirHandleRef.current = dirHandle
           const folderName = dirHandle.name
           setFolderPath(folderName)
 
-          // Read all files from the directory
+          // Read all files from the directory (respects current recursive checkbox)
           const files = await readDirectoryRecursive(dirHandle, recursive)
           
           if (files.length === 0) {
@@ -246,6 +279,8 @@ export default function Scan() {
         }
       } else if (isWebkitDirectorySupported()) {
         // Fallback: Use webkitdirectory input (Firefox, older browsers)
+        // webkitdirectory is always recursive — checkbox cannot re-filter without re-pick
+        dirHandleRef.current = null
         fileInputRef.current?.click()
       } else {
         setError('Folder selection is not supported in your browser. Please use Chrome, Edge, Safari, or Firefox.')
@@ -542,6 +577,11 @@ export default function Scan() {
                 className="ml-2 block text-sm text-gray-700"
               >
                 Scan subdirectories recursively
+                {scanMode === 'local' && dirHandleRef.current ? (
+                  <span className="ml-2 text-xs text-gray-500">(re-reads folder when toggled)</span>
+                ) : scanMode === 'network' ? (
+                  <span className="ml-2 text-xs text-gray-500">(applies on next Start Scanning)</span>
+                ) : null}
               </label>
             </div>
 

admin-frontend/src/pages/Search.tsx

@@ -239,27 +239,21 @@ export default function Search() {
       }
 
       if (currentSearchType === 'name') {
-        // Combine selected people names and free text input
-        // For selected people, use last name (most unique) or first+last if last name is empty
-        const selectedNames = selectedPeople.map(p => {
-          if (p.last_name) {
-            return p.last_name.trim()
-          } else if (p.first_name) {
-            return p.first_name.trim()
-          }
-          return formatPersonName(p).trim()
-        })
+        // Selected people → exact person_ids (avoids last-name substring false hits, #46)
+        if (selectedPeople.length > 0) {
+          params.person_ids = selectedPeople.map(p => p.id).join(',')
+        }
         const freeText = inputValue.trim()
-        const allNames = [...selectedNames, freeText].filter(Boolean)
-        
-        if (allNames.length === 0) {
+        if (freeText) {
+          params.person_name = freeText
+        }
+        if (!params.person_ids && !params.person_name) {
           if (showValidationErrors) {
             alert('Please enter at least one name or select a person to search.')
           }
           setLoading(false)
           return
         }
-        params.person_name = allNames.join(', ')
         // Add tags filter if provided
         if (selectedTags.length > 0) {
           params.tag_names = selectedTags.join(', ')
@@ -828,20 +822,12 @@ export default function Search() {
       }
 
       if (searchType === 'name') {
-        // Combine selected people names and free text input
-        // For selected people, use last name (most unique) or first+last if last name is empty
-        const selectedNames = selectedPeople.map(p => {
-          if (p.last_name) {
-            return p.last_name.trim()
-          } else if (p.first_name) {
-            return p.first_name.trim()
-          }
-          return formatPersonName(p).trim()
-        })
+        if (selectedPeople.length > 0) {
+          baseParams.person_ids = selectedPeople.map(p => p.id).join(',')
+        }
         const freeText = inputValue.trim()
-        const allNames = [...selectedNames, freeText].filter(Boolean)
-        if (allNames.length > 0) {
-          baseParams.person_name = allNames.join(', ')
+        if (freeText) {
+          baseParams.person_name = freeText
         }
         // Add tags filter if provided
         if (selectedTags.length > 0) {

backend/api/photos.py

@@ -37,7 +37,6 @@ from backend.schemas.search import (
     SearchPhotosResponse,
 )
 from backend.services.photo_service import (
-    find_photos_in_folder,
     import_photo_from_path,
 )
 from backend.services.search_service import (
@@ -63,6 +62,10 @@ def search_photos(
     current_user: Annotated[dict, Depends(get_current_user)],
     search_type: str = Query("name", description="Search type: name, date, tags, no_faces, no_tags, processed, unprocessed, favorites"),
     person_name: Optional[str] = Query(None, description="Person name for name search"),
+    person_ids: Optional[str] = Query(
+        None,
+        description="Comma-separated person IDs for exact name search (preferred over substring when selecting people)",
+    ),
     tag_names: Optional[str] = Query(None, description="Comma-separated tag names for tag search"),
     match_all: bool = Query(False, description="Match all tags (for tag search)"),
     date_from: Optional[str] = Query(None, description="Date from (YYYY-MM-DD)"),
@@ -111,13 +114,36 @@ def search_photos(
         tag_list = [t.strip() for t in tag_names.split(",") if t.strip()]
     
     if search_type == "name":
-        if not person_name:
+        parsed_person_ids: list[int] = []
+        if person_ids:
+            for part in person_ids.split(","):
+                part = part.strip()
+                if not part:
+                    continue
+                try:
+                    parsed_person_ids.append(int(part))
+                except ValueError:
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail=f"Invalid person_ids value: {part}",
+                    )
+        if not person_name and not parsed_person_ids:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail="person_name is required for name search",
+                detail="person_name or person_ids is required for name search",
             )
         results, total = search_photos_by_name(
-            db, person_name, folder_path, media_type, df, dt, tag_list, match_all, page, page_size
+            db,
+            person_name or "",
+            folder_path,
+            media_type,
+            df,
+            dt,
+            tag_list,
+            match_all,
+            page,
+            page_size,
+            person_ids=parsed_person_ids or None,
         )
         for photo, full_name in results:
             tags = get_photo_tags(db, photo.id)
@@ -360,23 +386,20 @@ def import_photos(
             detail=f"Folder not found: {request.folder_path}",
         )
 
-    # Estimate number of photos (quick scan)
-    estimated_photos = len(find_photos_in_folder(request.folder_path, request.recursive))
-
-    # Enqueue job
-    # Pass function as string path to avoid serialization issues
+    # Do NOT walk the tree on the API thread (#21) — that blocked SharePoint/SMB
+    # imports for minutes with no progress. Counting happens inside the RQ job.
     job = queue.enqueue(
         "backend.services.tasks.import_photos_task",
         request.folder_path,
         request.recursive,
-        job_timeout="1h",  # Allow up to 1 hour for large imports
+        job_timeout="2h",  # Network shares can be slow
     )
 
     return PhotoImportResponse(
         job_id=job.id,
         message=f"Photo import job queued for {request.folder_path}",
         folder_path=request.folder_path,
-        estimated_photos=estimated_photos,
+        estimated_photos=None,
     )
 
 

backend/services/face_service.py

@@ -2337,27 +2337,22 @@ def find_auto_match_matches(
     for person_id, reference_face, person_name in person_faces_list:
         reference_face_id = reference_face.id
         
-        # TEMPORARILY DISABLED: Check if reference face is too small (exclude from auto-match)
-        # reference_photo = db.query(Photo).filter(Photo.id == reference_face.photo_id).first()
-        # if reference_photo:
-        #     ref_size_ratio = _calculate_face_size_ratio(reference_face, reference_photo)
-        #     if ref_size_ratio < MIN_AUTO_MATCH_FACE_SIZE_RATIO:
-        #         # Skip this person - reference face is too small
-        #         continue
-        
+        # Skip people whose reference face is too small (reduces false positives, #30/#31/#33)
+        reference_photo = db.query(Photo).filter(Photo.id == reference_face.photo_id).first()
+        if reference_photo:
+            ref_size_ratio = _calculate_face_size_ratio(reference_face, reference_photo)
+            if ref_size_ratio < MIN_AUTO_MATCH_FACE_SIZE_RATIO:
+                continue
+
         # Use find_similar_faces which matches desktop _get_filtered_similar_faces logic
-        # Desktop: similar_faces = self.face_processor._get_filtered_similar_faces(
-        #     reference_face_id, tolerance, include_same_photo=False, face_status=None)
-        # This filters by: person_id is None (unidentified), confidence >= 50% (increased from 40%), sorts by distance
-        # Auto-match always excludes excluded faces
-        # TEMPORARILY DISABLED: filter_small_faces=True to exclude small match faces
+        # Filters: person_id is None, confidence floor, exclude small faces, sort by distance
         similar_faces_with_debug = find_similar_faces(
             db, reference_face_id, tolerance=tolerance,
             filter_frontal_only=filter_frontal_only,
             include_excluded=False,  # Auto-match always excludes excluded faces
-            filter_small_faces=False,  # TEMPORARILY DISABLED: Exclude small faces from auto-match
+            filter_small_faces=True,  # Exclude tiny faces that inflate false matches
             min_face_size_ratio=MIN_AUTO_MATCH_FACE_SIZE_RATIO,
-            use_distance_based_thresholds=use_distance_based_thresholds  # Use distance-based thresholds if enabled
+            use_distance_based_thresholds=use_distance_based_thresholds
         )
         # Strip debug_info for internal use
         similar_faces = [(f, dist, conf) for f, dist, conf, _ in similar_faces_with_debug]

backend/services/search_service.py

@@ -22,57 +22,78 @@ def search_photos_by_name(
     match_all: bool = False,
     page: int = 1,
     page_size: int = 50,
+    person_ids: Optional[List[int]] = None,
 ) -> Tuple[List[Tuple[Photo, str]], int]:
-    """Search photos by person name(s) (partial, case-insensitive).
-    
+    """Search photos by person name(s) and/or exact person IDs.
+
     Supports multiple names separated by commas (OR logic - photos matching any name).
-    
-    Matches desktop behavior exactly:
+    When person_ids is provided, those people are included exactly (no substring match).
+
+    Matches desktop behavior for free-text:
     - Searches first_name, last_name, middle_name, maiden_name
     - Returns (photo, full_name) tuples
-    - Filters by folder_path if provided
-    - Filters by media_type if provided ("image" or "video", None/"all" for all)
-    - Multiple names: comma-separated, searches for photos with ANY matching person
     """
     search_name = (person_name or "").strip()
-    if not search_name:
-        return [], 0
-    
+    explicit_ids = [int(pid) for pid in (person_ids or []) if pid is not None]
+
     # Split by comma and clean up names
-    search_names = [name.strip().lower() for name in search_name.split(',') if name.strip()]
-    if not search_names:
+    search_names = [name.strip().lower() for name in search_name.split(',') if name.strip()] if search_name else []
+
+    if not search_names and not explicit_ids:
         return [], 0
-    
-    # Build OR conditions for each search name
-    name_conditions = []
-    for search_name_lower in search_names:
-        name_conditions.append(
-            or_(
-                func.lower(Person.first_name).contains(search_name_lower),
-                func.lower(Person.last_name).contains(search_name_lower),
-                func.lower(Person.middle_name).contains(search_name_lower),
-                func.lower(Person.maiden_name).contains(search_name_lower),
-            )
+
+    matching_people: List[Person] = []
+
+    if explicit_ids:
+        matching_people.extend(
+            db.query(Person).filter(Person.id.in_(explicit_ids)).all()
         )
-    
-    # Find matching people (any of the search names)
-    matching_people = (
-        db.query(Person)
-        .filter(or_(*name_conditions))
-        .all()
-    )
-    
-    if not matching_people:
+
+    if search_names:
+        # Build OR conditions for each search name
+        name_conditions = []
+        for search_name_lower in search_names:
+            # Multi-word "First Last" → require first AND last (reduces false hits, #46)
+            parts = [p for p in search_name_lower.split() if p]
+            if len(parts) >= 2:
+                first, last = parts[0], parts[-1]
+                name_conditions.append(
+                    (func.lower(Person.first_name).contains(first))
+                    & (func.lower(Person.last_name).contains(last))
+                )
+            else:
+                name_conditions.append(
+                    or_(
+                        func.lower(Person.first_name).contains(search_name_lower),
+                        func.lower(Person.last_name).contains(search_name_lower),
+                        func.lower(Person.middle_name).contains(search_name_lower),
+                        func.lower(Person.maiden_name).contains(search_name_lower),
+                    )
+                )
+
+        matching_people.extend(
+            db.query(Person).filter(or_(*name_conditions)).all()
+        )
+
+    # Deduplicate people by id
+    seen = set()
+    unique_people: List[Person] = []
+    for p in matching_people:
+        if p.id not in seen:
+            seen.add(p.id)
+            unique_people.append(p)
+
+    if not unique_people:
         return [], 0
-    
-    person_ids = [p.id for p in matching_people]
-    
+
+    person_ids_resolved = [p.id for p in unique_people]
+
     # Query photos with faces linked to matching people
     query = (
         db.query(Photo, Person)
         .join(Face, Photo.id == Face.photo_id)
         .join(Person, Face.person_id == Person.id)
-        .filter(Face.person_id.in_(person_ids))
+        .filter(Face.person_id.in_(person_ids_resolved))
         .distinct()
     )
     

viewer-frontend/app/api/photos/[id]/image/route.ts

@@ -260,6 +260,38 @@ export async function GET(
         },
       });
 
+    // Grid thumbnails: resize photos (videos handled above) — #26
+    if (thumbnail && sharp) {
+      try {
+        let pipeline = sharp(imageBuffer).rotate().resize({
+          width: 480,
+          height: 480,
+          fit: 'inside',
+          withoutEnlargement: true,
+        });
+        if (watermark) {
+          const metadata = await pipeline.metadata();
+          const baseWidth = metadata.width ?? 480;
+          const baseHeight = metadata.height ?? 480;
+          const overlayBuffer = await getWatermarkOverlay(baseWidth, baseHeight);
+          pipeline = sharp(imageBuffer)
+            .rotate()
+            .resize({ width: 480, height: 480, fit: 'inside', withoutEnlargement: true })
+            .composite([{ input: overlayBuffer, gravity: 'center', blend: 'hard-light' }]);
+        }
+        const result = await pipeline.jpeg({ quality: 75 }).toBuffer();
+        return new NextResponse(result as unknown as BodyInit, {
+          headers: {
+            'Content-Type': 'image/jpeg',
+            'Cache-Control': 'public, max-age=86400',
+          },
+        });
+      } catch (error) {
+        console.error('Error generating image thumbnail:', error);
+        // fall through to original / watermarked full image
+      }
+    }
+
     if (!watermark) {
       return createOriginalResponse();
     }

viewer-frontend/components/PhotoGrid.tsx

@@ -620,7 +620,7 @@ export function PhotoGrid({
                     onMouseLeave={() => setHoveredFace(null)}
                   >
                     <Image
-                      src={getImageSrc(photo, { watermark: !isLoggedIn, thumbnail: isVideoPhoto })}
+                      src={getImageSrc(photo, { watermark: !isLoggedIn, thumbnail: true })}
                       alt={photo.filename}
                       fill
                       className="object-contain bg-black/5 transition-transform duration-300 group-hover:scale-105"

viewer-frontend/lib/photo-utils.ts

@@ -22,9 +22,14 @@ export function isVideo(photo: Photo): boolean {
  * - Videos → use thumbnail endpoint (for grid display)
  */
 export function getImageSrc(photo: Photo, options?: { watermark?: boolean; thumbnail?: boolean }): string {
-  // For videos, use thumbnail endpoint if requested (for grid display)
-  if (options?.thumbnail && isVideo(photo)) {
-    return `/api/photos/${photo.id}/image?thumbnail=true`;
+  // Grid thumbnails: resize on server (images) or video poster (#26)
+  if (options?.thumbnail) {
+    const params = new URLSearchParams();
+    params.set('thumbnail', 'true');
+    if (options.watermark) {
+      params.set('watermark', 'true');
+    }
+    return `/api/photos/${photo.id}/image?${params.toString()}`;
   }
 
   if (isUrl(photo.path)) {