Oh yes - Thats how we do

No default params for KSP complainer fuck

UI sweeps

.idea/deploymentTargetSelector.xml

@@ -4,6 +4,14 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
+        <DropdownSelection timestamp="2026-01-08T02:44:48.809354959Z">
+          <Target type="DEFAULT_BOOT">
+            <handle>
+              <DeviceId pluginId="LocalEmulator" identifier="path=/home/genki/.android/avd/Medium_Phone.avd" />
+            </handle>
+          </Target>
+        </DropdownSelection>
+        <DialogSelection />
       </SelectionState>
     </selectionStates>
   </component>

app/src/main/java/com/placeholder/sherpai2/MainActivity.kt

@@ -8,20 +8,33 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material3.Text
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
+import androidx.lifecycle.lifecycleScope
 import com.placeholder.sherpai2.domain.repository.ImageRepository
 import com.placeholder.sherpai2.ui.presentation.MainScreen
 import com.placeholder.sherpai2.ui.theme.SherpAI2Theme
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
+/**
+ * MainActivity - ENHANCED with background ingestion
+ *
+ * Key improvements:
+ * 1. Non-blocking ingestion - app loads immediately
+ * 2. Background processing with progress updates
+ * 3. Graceful handling of large photo collections
+ * 4. User can navigate while ingestion runs
+ */
 @AndroidEntryPoint
 class MainActivity : ComponentActivity() {
 
@@ -31,11 +44,9 @@ class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        // Determine storage permission based on Android version
         val storagePermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
             Manifest.permission.READ_MEDIA_IMAGES
         } else {
-            @Suppress("DEPRECATION")
             Manifest.permission.READ_EXTERNAL_STORAGE
         }
 
@@ -43,44 +54,176 @@ class MainActivity : ComponentActivity() {
             SherpAI2Theme {
                 var hasPermission by remember {
                     mutableStateOf(
-                        ContextCompat.checkSelfPermission(this, storagePermission) ==
+                        ContextCompat.checkSelfPermission(this@MainActivity, storagePermission) ==
                                 PackageManager.PERMISSION_GRANTED
                     )
                 }
 
-                // Track ingestion completion
-                var imagesIngested by remember { mutableStateOf(false) }
+                var ingestionState by remember { mutableStateOf<IngestionState>(IngestionState.NotStarted) }
 
-                // Launcher for permission request
                 val permissionLauncher = rememberLauncherForActivityResult(
                     ActivityResultContracts.RequestPermission()
                 ) { granted ->
                     hasPermission = granted
                 }
 
-                // Trigger ingestion once permission is granted
+                // Start background ingestion when permission granted
                 LaunchedEffect(hasPermission) {
-                    if (hasPermission) {
-                        // Suspend until ingestion completes
-                        imageRepository.ingestImages()
-                        imagesIngested = true
+                    if (hasPermission && ingestionState is IngestionState.NotStarted) {
+                        ingestionState = IngestionState.InProgress(0, 0)
+
+                        // Launch in background - NON-BLOCKING
+                        lifecycleScope.launch(Dispatchers.IO) {
+                            try {
+                                // Check if already ingested
+                                val existingCount = imageRepository.getImageCount()
+
+                                if (existingCount > 0) {
+                                    // Already have images, skip ingestion
+                                    withContext(Dispatchers.Main) {
+                                        ingestionState = IngestionState.Complete(existingCount)
+                                    }
                                 } else {
+                                    // Start ingestion with progress tracking
+                                    imageRepository.ingestImagesWithProgress { current, total ->
+                                        ingestionState = IngestionState.InProgress(current, total)
+                                    }
+
+                                    val finalCount = imageRepository.getImageCount()
+                                    withContext(Dispatchers.Main) {
+                                        ingestionState = IngestionState.Complete(finalCount)
+                                    }
+                                }
+                            } catch (e: Exception) {
+                                withContext(Dispatchers.Main) {
+                                    ingestionState = IngestionState.Error(e.message ?: "Failed to load images")
+                                }
+                            }
+                        }
+                    } else if (!hasPermission) {
                         permissionLauncher.launch(storagePermission)
                     }
                 }
 
-                // Gate UI until permission granted AND ingestion completed
-                if (hasPermission && imagesIngested) {
+                // UI State
+                Box(
+                    modifier = Modifier.fillMaxSize()
+                ) {
+                    when {
+                        hasPermission -> {
+                            // ALWAYS show main screen (non-blocking!)
                             MainScreen()
-                } else {
+
+                            // Show progress overlay if still ingesting
+                            if (ingestionState is IngestionState.InProgress) {
+                                IngestionProgressOverlay(
+                                    state = ingestionState as IngestionState.InProgress
+                                )
+                            }
+                        }
+                        else -> {
                             Box(
                                 modifier = Modifier.fillMaxSize(),
                                 contentAlignment = Alignment.Center
                             ) {
-                        Text("Please grant storage permission to continue.")
+                                Column(
+                                    horizontalAlignment = Alignment.CenterHorizontally,
+                                    verticalArrangement = Arrangement.spacedBy(16.dp)
+                                ) {
+                                    Text(
+                                        "Storage Permission Required",
+                                        style = MaterialTheme.typography.titleLarge,
+                                        fontWeight = FontWeight.Bold
+                                    )
+                                    Text(
+                                        "SherpAI needs access to your photos",
+                                        style = MaterialTheme.typography.bodyMedium
+                                    )
+                                    Button(onClick = { permissionLauncher.launch(storagePermission) }) {
+                                        Text("Grant Permission")
                                     }
                                 }
                             }
                         }
                     }
                 }
+            }
+        }
+    }
+}
+
+/**
+ * Ingestion state with progress tracking
+ */
+sealed class IngestionState {
+    object NotStarted : IngestionState()
+    data class InProgress(val current: Int, val total: Int) : IngestionState()
+    data class Complete(val imageCount: Int) : IngestionState()
+    data class Error(val message: String) : IngestionState()
+}
+
+/**
+ * Non-intrusive progress overlay
+ * Shows at bottom of screen, doesn't block UI
+ */
+@Composable
+fun IngestionProgressOverlay(state: IngestionState.InProgress) {
+    Box(
+        modifier = Modifier.fillMaxSize(),
+        contentAlignment = Alignment.BottomCenter
+    ) {
+        Card(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.primaryContainer
+            ),
+            elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp)
+            ) {
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(
+                        text = "Loading photos...",
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold
+                    )
+
+                    if (state.total > 0) {
+                        Text(
+                            text = "${state.current} / ${state.total}",
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                    }
+                }
+
+                if (state.total > 0) {
+                    LinearProgressIndicator(
+                        progress = { state.current.toFloat() / state.total.toFloat() },
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                } else {
+                    LinearProgressIndicator(
+                        modifier = Modifier.fillMaxWidth()
+                    )
+                }
+
+                Text(
+                    text = "You can start using the app while photos load in the background",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/data/local/AppDatabase.kt

@@ -21,7 +21,6 @@ import com.placeholder.sherpai2.data.local.entity.*
         TagEntity::class,
         EventEntity::class,
         ImageTagEntity::class,
-        ImagePersonEntity::class,
         ImageEventEntity::class,
 
         // ===== NEW ENTITIES =====
@@ -29,7 +28,7 @@ import com.placeholder.sherpai2.data.local.entity.*
         FaceModelEntity::class,      // NEW: Face embeddings
         PhotoFaceTagEntity::class    // NEW: Face tags
     ],
-    version = 3,
+    version = 5,
     exportSchema = false
 )
 // No TypeConverters needed - embeddings stored as strings
@@ -40,7 +39,6 @@ abstract class AppDatabase : RoomDatabase() {
     abstract fun tagDao(): TagDao
     abstract fun eventDao(): EventDao
     abstract fun imageTagDao(): ImageTagDao
-    abstract fun imagePersonDao(): ImagePersonDao
     abstract fun imageEventDao(): ImageEventDao
     abstract fun imageAggregateDao(): ImageAggregateDao
 

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageDao.kt

@@ -72,4 +72,19 @@ interface ImageDao {
      */
     @Query("SELECT * FROM images WHERE imageId IN (:imageIds)")
     suspend fun getImagesByIds(imageIds: List<String>): List<ImageEntity>
+
+    @Query("SELECT COUNT(*) FROM images")
+    suspend fun getImageCount(): Int
+
+    /**
+     * Get all images (for utilities processing)
+     */
+    @Query("SELECT * FROM images ORDER BY capturedAt DESC")
+    suspend fun getAllImages(): List<ImageEntity>
+
+    /**
+     * Get all images sorted by time (for burst detection)
+     */
+    @Query("SELECT * FROM images ORDER BY capturedAt ASC")
+    suspend fun getAllImagesSortedByTime(): List<ImageEntity>
 }

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImagePersonDao.kt

@@ -1,25 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.ImagePersonEntity
-
-@Dao
-interface ImagePersonDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun upsert(entity: ImagePersonEntity)
-
-    /**
-     * All images containing a specific person.
-     */
-    @Query("""
-        SELECT imageId FROM image_persons
-        WHERE personId = :personId
-        AND visibility = 'PUBLIC'
-        AND confirmed = 1
-    """)
-    suspend fun findImagesForPerson(personId: String): List<String>
-}

app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageTagDao.kt

@@ -15,9 +15,6 @@ interface ImageTagDao {
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun upsert(imageTag: ImageTagEntity)
 
-    /**
-     * Observe tags for an image.
-     */
     @Query("""
         SELECT * FROM image_tags
         WHERE imageId = :imageId
@@ -26,9 +23,7 @@ interface ImageTagDao {
     fun observeTagsForImage(imageId: String): Flow<List<ImageTagEntity>>
 
     /**
-     * Find images by tag.
-     *
-     * This is your primary tag-search query.
+     * FIXED: Removed default parameter
      */
     @Query("""
         SELECT imageId FROM image_tags
@@ -38,7 +33,7 @@ interface ImageTagDao {
     """)
     suspend fun findImagesByTag(
         tagId: String,
-        minConfidence: Float = 0.5f
+        minConfidence: Float
     ): List<String>
 
     @Transaction
@@ -50,4 +45,9 @@ interface ImageTagDao {
     """)
     fun getTagsForImage(imageId: String): Flow<List<TagEntity>>
 
+    /**
+     * Insert image tag (for utilities tagging)
+     */
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    suspend fun insert(imageTag: ImageTagEntity): Long
 }

app/src/main/java/com/placeholder/sherpai2/data/local/dao/PersonDao.kt

@@ -4,16 +4,11 @@ import androidx.room.*
 import com.placeholder.sherpai2.data.local.entity.PersonEntity
 import kotlinx.coroutines.flow.Flow
 
-/**
- * PersonDao - Data access for PersonEntity
- *
- * PRIMARY KEY TYPE: String (UUID)
- */
 @Dao
 interface PersonDao {
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insert(person: PersonEntity): Long  // Room still returns row ID as Long
+    suspend fun insert(person: PersonEntity): Long
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun insertAll(persons: List<PersonEntity>)
@@ -21,8 +16,11 @@ interface PersonDao {
     @Update
     suspend fun update(person: PersonEntity)
 
+    /**
+     * FIXED: Removed default parameter
+     */
     @Query("UPDATE persons SET updatedAt = :timestamp WHERE id = :personId")
-    suspend fun updateTimestamp(personId: String, timestamp: Long = System.currentTimeMillis())
+    suspend fun updateTimestamp(personId: String, timestamp: Long)
 
     @Delete
     suspend fun delete(person: PersonEntity)

app/src/main/java/com/placeholder/sherpai2/data/local/dao/Photofacetagdao.kt

@@ -4,17 +4,11 @@ import androidx.room.*
 import kotlinx.coroutines.flow.Flow
 import com.placeholder.sherpai2.data.local.entity.PhotoFaceTagEntity
 
-/**
- * PhotoFaceTagDao - Manages face tags in photos
- *
- * PRIMARY KEY TYPE: String (UUID)
- * FOREIGN KEYS: imageId (String), faceModelId (String)
- */
 @Dao
 interface PhotoFaceTagDao {
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insertTag(tag: PhotoFaceTagEntity): Long  // Row ID
+    suspend fun insertTag(tag: PhotoFaceTagEntity): Long
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun insertTags(tags: List<PhotoFaceTagEntity>)
@@ -22,8 +16,11 @@ interface PhotoFaceTagDao {
     @Update
     suspend fun updateTag(tag: PhotoFaceTagEntity)
 
+    /**
+     * FIXED: Removed default parameter
+     */
     @Query("UPDATE photo_face_tags SET verifiedByUser = 1, verifiedAt = :timestamp WHERE id = :tagId")
-    suspend fun markTagAsVerified(tagId: String, timestamp: Long = System.currentTimeMillis())
+    suspend fun markTagAsVerified(tagId: String, timestamp: Long)
 
     // ===== QUERY BY IMAGE =====
 
@@ -66,8 +63,11 @@ interface PhotoFaceTagDao {
 
     // ===== STATISTICS =====
 
+    /**
+     * FIXED: Removed default parameter
+     */
     @Query("SELECT * FROM photo_face_tags WHERE confidence < :threshold ORDER BY confidence ASC")
-    suspend fun getLowConfidenceTags(threshold: Float = 0.7f): List<PhotoFaceTagEntity>
+    suspend fun getLowConfidenceTags(threshold: Float): List<PhotoFaceTagEntity>
 
     @Query("SELECT * FROM photo_face_tags WHERE verifiedByUser = 0 ORDER BY detectedAt DESC")
     suspend fun getUnverifiedTags(): List<PhotoFaceTagEntity>
@@ -78,13 +78,13 @@ interface PhotoFaceTagDao {
     @Query("SELECT AVG(confidence) FROM photo_face_tags WHERE faceModelId = :faceModelId")
     suspend fun getAverageConfidenceForFaceModel(faceModelId: String): Float?
 
+    /**
+     * FIXED: Removed default parameter
+     */
     @Query("SELECT * FROM photo_face_tags ORDER BY detectedAt DESC LIMIT :limit")
-    suspend fun getRecentlyDetectedFaces(limit: Int = 20): List<PhotoFaceTagEntity>
+    suspend fun getRecentlyDetectedFaces(limit: Int): List<PhotoFaceTagEntity>
 }
 
-/**
- * Simple data class for photo counts
- */
 data class FaceModelPhotoCount(
     val faceModelId: String,
     val photoCount: Int

app/src/main/java/com/placeholder/sherpai2/data/local/dao/TagDao.kt

@@ -4,21 +4,218 @@ import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
+import com.placeholder.sherpai2.data.local.entity.ImageEntity
 import com.placeholder.sherpai2.data.local.entity.TagEntity
+import com.placeholder.sherpai2.data.local.entity.TagWithUsage
+import kotlinx.coroutines.flow.Flow
 
+/**
+ * TagDao - Tag management with face recognition integration
+ *
+ * NO DEFAULT PARAMETERS - Room doesn't support them in @Query methods
+ */
 @Dao
 interface TagDao {
 
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insert(tag: TagEntity)
+    // ======================
+    // BASIC OPERATIONS
+    // ======================
+
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    suspend fun insert(tag: TagEntity): Long
 
-    /**
-     * Resolve a tag by value.
-     * Example: "park"
-     */
     @Query("SELECT * FROM tags WHERE value = :value LIMIT 1")
     suspend fun getByValue(value: String): TagEntity?
 
-    @Query("SELECT * FROM tags")
+    @Query("SELECT * FROM tags WHERE tagId = :tagId")
+    suspend fun getById(tagId: String): TagEntity?
+
+    @Query("SELECT * FROM tags ORDER BY value ASC")
     suspend fun getAll(): List<TagEntity>
+
+    @Query("SELECT * FROM tags ORDER BY value ASC")
+    fun getAllFlow(): Flow<List<TagEntity>>
+
+    @Query("SELECT * FROM tags WHERE type = :type ORDER BY value ASC")
+    suspend fun getByType(type: String): List<TagEntity>
+
+    @Query("DELETE FROM tags WHERE tagId = :tagId")
+    suspend fun delete(tagId: String)
+
+    // ======================
+    // STATISTICS (returns TagWithUsage)
+    // ======================
+
+    /**
+     * Get most used tags WITH usage counts
+     *
+     * @param limit Maximum number of tags to return
+     */
+    @Query("""
+        SELECT t.tagId, t.type, t.value, t.createdAt, 
+               COUNT(it.imageId) as usage_count 
+        FROM tags t
+        LEFT JOIN image_tags it ON t.tagId = it.tagId
+        GROUP BY t.tagId
+        ORDER BY usage_count DESC
+        LIMIT :limit
+    """)
+    suspend fun getMostUsedTags(limit: Int): List<TagWithUsage>
+
+    /**
+     * Get tag usage count
+     */
+    @Query("""
+        SELECT COUNT(DISTINCT it.imageId)
+        FROM image_tags it
+        WHERE it.tagId = :tagId
+    """)
+    suspend fun getTagUsageCount(tagId: String): Int
+
+    // ======================
+    // PERSON INTEGRATION
+    // ======================
+
+    /**
+     * Get all tags used for images containing a specific person
+     */
+    @Query("""
+        SELECT DISTINCT t.* FROM tags t
+        INNER JOIN image_tags it ON t.tagId = it.tagId
+        INNER JOIN photo_face_tags pft ON it.imageId = pft.imageId
+        INNER JOIN face_models fm ON pft.faceModelId = fm.id
+        WHERE fm.personId = :personId
+        ORDER BY t.value ASC
+    """)
+    suspend fun getTagsForPerson(personId: String): List<TagEntity>
+
+    /**
+     * Get images that have both a specific tag AND contain a specific person
+     */
+    @Query("""
+        SELECT DISTINCT i.* FROM images i
+        INNER JOIN image_tags it ON i.imageId = it.imageId
+        INNER JOIN photo_face_tags pft ON i.imageId = pft.imageId
+        INNER JOIN face_models fm ON pft.faceModelId = fm.id
+        WHERE it.tagId = :tagId AND fm.personId = :personId
+        ORDER BY i.capturedAt DESC
+    """)
+    suspend fun getImagesWithTagAndPerson(
+        tagId: String,
+        personId: String
+    ): List<ImageEntity>
+
+    /**
+     * Get images with tag and person as Flow
+     */
+    @Query("""
+        SELECT DISTINCT i.* FROM images i
+        INNER JOIN image_tags it ON i.imageId = it.imageId
+        INNER JOIN photo_face_tags pft ON i.imageId = pft.imageId
+        INNER JOIN face_models fm ON pft.faceModelId = fm.id
+        WHERE it.tagId = :tagId AND fm.personId = :personId
+        ORDER BY i.capturedAt DESC
+    """)
+    fun getImagesWithTagAndPersonFlow(
+        tagId: String,
+        personId: String
+    ): Flow<List<ImageEntity>>
+
+    /**
+     * Count images with tag and person
+     */
+    @Query("""
+        SELECT COUNT(DISTINCT i.imageId) FROM images i
+        INNER JOIN image_tags it ON i.imageId = it.imageId
+        INNER JOIN photo_face_tags pft ON i.imageId = pft.imageId
+        INNER JOIN face_models fm ON pft.faceModelId = fm.id
+        WHERE it.tagId = :tagId AND fm.personId = :personId
+    """)
+    suspend fun countImagesWithTagAndPerson(
+        tagId: String,
+        personId: String
+    ): Int
+
+    // ======================
+    // AUTO-SUGGESTIONS
+    // ======================
+
+    /**
+     * Suggest tags based on person's relationship
+     *
+     * @param limit Maximum number of suggestions
+     */
+    @Query("""
+        SELECT DISTINCT t.* FROM tags t
+        INNER JOIN image_tags it ON t.tagId = it.tagId
+        INNER JOIN photo_face_tags pft ON it.imageId = pft.imageId
+        INNER JOIN face_models fm ON pft.faceModelId = fm.id
+        INNER JOIN persons p ON fm.personId = p.id
+        WHERE p.relationship = :relationship
+        AND p.id != :excludePersonId
+        GROUP BY t.tagId
+        ORDER BY COUNT(it.imageId) DESC
+        LIMIT :limit
+    """)
+    suspend fun suggestTagsBasedOnRelationship(
+        relationship: String,
+        excludePersonId: String,
+        limit: Int
+    ): List<TagEntity>
+
+    /**
+     * Get tags commonly used with this tag
+     *
+     * @param limit Maximum number of related tags
+     */
+    @Query("""
+        SELECT DISTINCT t2.* FROM tags t2
+        INNER JOIN image_tags it2 ON t2.tagId = it2.tagId
+        WHERE it2.imageId IN (
+            SELECT it1.imageId FROM image_tags it1
+            WHERE it1.tagId = :tagId
+        )
+        AND t2.tagId != :tagId
+        GROUP BY t2.tagId
+        ORDER BY COUNT(it2.imageId) DESC
+        LIMIT :limit
+    """)
+    suspend fun getRelatedTags(
+        tagId: String,
+        limit: Int
+    ): List<TagEntity>
+
+    // ======================
+    // SEARCH
+    // ======================
+
+    /**
+     * Search tags by value (partial match)
+     *
+     * @param limit Maximum number of results
+     */
+    @Query("""
+        SELECT * FROM tags 
+        WHERE value LIKE '%' || :query || '%'
+        ORDER BY value ASC
+        LIMIT :limit
+    """)
+    suspend fun searchTags(query: String, limit: Int): List<TagEntity>
+
+    /**
+     * Search tags with usage count
+     *
+     * @param limit Maximum number of results
+     */
+    @Query("""
+        SELECT t.tagId, t.type, t.value, t.createdAt,
+               COUNT(it.imageId) as usage_count 
+        FROM tags t
+        LEFT JOIN image_tags it ON t.tagId = it.tagId
+        WHERE t.value LIKE '%' || :query || '%'
+        GROUP BY t.tagId
+        ORDER BY usage_count DESC, t.value ASC
+        LIMIT :limit
+    """)
+    suspend fun searchTagsWithUsage(query: String, limit: Int): List<TagWithUsage>
 }

app/src/main/java/com/placeholder/sherpai2/data/local/entity/Facerecognitionentities.kt

@@ -1,5 +1,6 @@
 package com.placeholder.sherpai2.data.local.entity
 
+import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.Index
@@ -7,31 +8,73 @@ import androidx.room.PrimaryKey
 import java.util.UUID
 
 /**
- * PersonEntity - Represents a person in the face recognition system
- *
- * TABLE: persons
- * PRIMARY KEY: id (String)
+ * PersonEntity - NO DEFAULT VALUES for KSP compatibility
  */
 @Entity(
     tableName = "persons",
-    indices = [
-        Index(value = ["name"])
-    ]
+    indices = [Index(value = ["name"])]
 )
 data class PersonEntity(
     @PrimaryKey
-    val id: String = UUID.randomUUID().toString(),
+    @ColumnInfo(name = "id")
+    val id: String,                    // ← No default
 
+    @ColumnInfo(name = "name")
     val name: String,
-    val createdAt: Long = System.currentTimeMillis(),
-    val updatedAt: Long = System.currentTimeMillis()
+
+    @ColumnInfo(name = "dateOfBirth")
+    val dateOfBirth: Long?,
+
+    @ColumnInfo(name = "relationship")
+    val relationship: String?,
+
+    @ColumnInfo(name = "createdAt")
+    val createdAt: Long,               // ← No default
+
+    @ColumnInfo(name = "updatedAt")
+    val updatedAt: Long                // ← No default
+) {
+    companion object {
+        fun create(
+            name: String,
+            dateOfBirth: Long? = null,
+            relationship: String? = null
+        ): PersonEntity {
+            val now = System.currentTimeMillis()
+            return PersonEntity(
+                id = UUID.randomUUID().toString(),
+                name = name,
+                dateOfBirth = dateOfBirth,
+                relationship = relationship,
+                createdAt = now,
+                updatedAt = now
             )
+        }
+    }
+
+    fun getAge(): Int? {
+        if (dateOfBirth == null) return null
+        val now = System.currentTimeMillis()
+        val ageInMillis = now - dateOfBirth
+        return (ageInMillis / (1000L * 60 * 60 * 24 * 365)).toInt()
+    }
+
+    fun getRelationshipEmoji(): String {
+        return when (relationship) {
+            "Family" -> "👨‍👩‍👧‍👦"
+            "Friend" -> "🤝"
+            "Partner" -> "❤️"
+            "Child" -> "👶"
+            "Parent" -> "👪"
+            "Sibling" -> "👫"
+            "Colleague" -> "💼"
+            else -> "👤"
+        }
+    }
+}
 
 /**
- * FaceModelEntity - Stores face recognition model (embedding) for a person
- *
- * TABLE: face_models
- * FOREIGN KEY: personId → persons.id
+ * FaceModelEntity - NO DEFAULT VALUES
  */
 @Entity(
     tableName = "face_models",
@@ -43,22 +86,36 @@ data class PersonEntity(
             onDelete = ForeignKey.CASCADE
         )
     ],
-    indices = [
-        Index(value = ["personId"], unique = true)
-    ]
+    indices = [Index(value = ["personId"], unique = true)]
 )
 data class FaceModelEntity(
     @PrimaryKey
-    val id: String = UUID.randomUUID().toString(),
+    @ColumnInfo(name = "id")
+    val id: String,                    // ← No default
 
+    @ColumnInfo(name = "personId")
     val personId: String,
-    val embedding: String,  // Serialized FloatArray
+
+    @ColumnInfo(name = "embedding")
+    val embedding: String,
+
+    @ColumnInfo(name = "trainingImageCount")
     val trainingImageCount: Int,
+
+    @ColumnInfo(name = "averageConfidence")
     val averageConfidence: Float,
-    val createdAt: Long = System.currentTimeMillis(),
-    val updatedAt: Long = System.currentTimeMillis(),
-    val lastUsed: Long? = null,
-    val isActive: Boolean = true
+
+    @ColumnInfo(name = "createdAt")
+    val createdAt: Long,               // ← No default
+
+    @ColumnInfo(name = "updatedAt")
+    val updatedAt: Long,               // ← No default
+
+    @ColumnInfo(name = "lastUsed")
+    val lastUsed: Long?,
+
+    @ColumnInfo(name = "isActive")
+    val isActive: Boolean
 ) {
     companion object {
         fun create(
@@ -67,11 +124,17 @@ data class FaceModelEntity(
             trainingImageCount: Int,
             averageConfidence: Float
         ): FaceModelEntity {
+            val now = System.currentTimeMillis()
             return FaceModelEntity(
+                id = UUID.randomUUID().toString(),
                 personId = personId,
                 embedding = embeddingArray.joinToString(","),
                 trainingImageCount = trainingImageCount,
-                averageConfidence = averageConfidence
+                averageConfidence = averageConfidence,
+                createdAt = now,
+                updatedAt = now,
+                lastUsed = null,
+                isActive = true
             )
         }
     }
@@ -82,12 +145,7 @@ data class FaceModelEntity(
 }
 
 /**
- * PhotoFaceTagEntity - Links detected faces in photos to person models
- *
- * TABLE: photo_face_tags
- * FOREIGN KEYS:
- *   - imageId → images.imageId (String)
- *   - faceModelId → face_models.id (String)
+ * PhotoFaceTagEntity - NO DEFAULT VALUES
  */
 @Entity(
     tableName = "photo_face_tags",
@@ -113,18 +171,32 @@ data class FaceModelEntity(
 )
 data class PhotoFaceTagEntity(
     @PrimaryKey
-    val id: String = UUID.randomUUID().toString(),
+    @ColumnInfo(name = "id")
+    val id: String,                    // ← No default
 
-    val imageId: String,  // String to match ImageEntity.imageId
+    @ColumnInfo(name = "imageId")
+    val imageId: String,
+
+    @ColumnInfo(name = "faceModelId")
     val faceModelId: String,
 
-    val boundingBox: String,  // "left,top,right,bottom"
-    val confidence: Float,
-    val embedding: String,  // Serialized FloatArray
+    @ColumnInfo(name = "boundingBox")
+    val boundingBox: String,
 
-    val detectedAt: Long = System.currentTimeMillis(),
-    val verifiedByUser: Boolean = false,
-    val verifiedAt: Long? = null
+    @ColumnInfo(name = "confidence")
+    val confidence: Float,
+
+    @ColumnInfo(name = "embedding")
+    val embedding: String,
+
+    @ColumnInfo(name = "detectedAt")
+    val detectedAt: Long,              // ← No default
+
+    @ColumnInfo(name = "verifiedByUser")
+    val verifiedByUser: Boolean,
+
+    @ColumnInfo(name = "verifiedAt")
+    val verifiedAt: Long?
 ) {
     companion object {
         fun create(
@@ -135,11 +207,15 @@ data class PhotoFaceTagEntity(
             faceEmbedding: FloatArray
         ): PhotoFaceTagEntity {
             return PhotoFaceTagEntity(
+                id = UUID.randomUUID().toString(),
                 imageId = imageId,
                 faceModelId = faceModelId,
                 boundingBox = "${boundingBox.left},${boundingBox.top},${boundingBox.right},${boundingBox.bottom}",
                 confidence = confidence,
-                embedding = faceEmbedding.joinToString(",")
+                embedding = faceEmbedding.joinToString(","),
+                detectedAt = System.currentTimeMillis(),
+                verifiedByUser = false,
+                verifiedAt = null
             )
         }
     }

app/src/main/java/com/placeholder/sherpai2/data/local/entity/ImagePersonEntity.kt

@@ -1,40 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-
-@Entity(
-    tableName = "image_persons",
-    primaryKeys = ["imageId", "personId"],
-    foreignKeys = [
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = PersonEntity::class,
-            parentColumns = ["id"],
-            childColumns = ["personId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("personId")
-    ]
-)
-data class ImagePersonEntity(
-
-    val imageId: String,
-    val personId: String,
-
-    val confidence: Float,
-    val confirmed: Boolean,
-
-    /**
-     * PUBLIC | PRIVATE
-     */
-    val visibility: String
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/PersonEntity

@@ -1,49 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-/**
- * PersonEntity - Represents a person in your app
- *
- * This is a SIMPLE person entity for your existing database.
- * Face embeddings are stored separately in FaceModelEntity.
- *
- * ARCHITECTURE:
- * - PersonEntity = Human data (name, birthday, etc.)
- * - FaceModelEntity = AI data (face embeddings) - links to this via personId
- *
- * You can add more fields as needed:
- * - birthday: Long?
- * - phoneNumber: String?
- * - email: String?
- * - notes: String?
- * - etc.
- */
-@Entity(tableName = "persons")
-data class PersonEntity(
-    @PrimaryKey(autoGenerate = true)
-    val id: Long = 0,
-
-    /**
-     * Person's name
-     */
-    val name: String,
-
-    /**
-     * When this person was added
-     */
-    val createdAt: Long = System.currentTimeMillis(),
-
-    /**
-     * Last time this person's data was updated
-     */
-    val updatedAt: Long = System.currentTimeMillis()
-
-    // ADD MORE FIELDS AS NEEDED:
-    // val birthday: Long? = null,
-    // val phoneNumber: String? = null,
-    // val email: String? = null,
-    // val profilePhotoUri: String? = null,
-    // val notes: String? = null
-)

app/src/main/java/com/placeholder/sherpai2/data/local/entity/TagEntity.kt

@@ -1,30 +1,143 @@
 package com.placeholder.sherpai2.data.local.entity
 
+import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
+import java.util.UUID
 
 /**
- * Represents a conceptual tag.
+ * Tag type constants - MUST be defined BEFORE TagEntity
+ * to avoid KSP initialization order issues
+ */
+object TagType {
+    const val GENERIC = "GENERIC"   // User tags
+    const val SYSTEM = "SYSTEM"     // AI/auto tags
+    const val HIDDEN = "HIDDEN"     // Internal
+}
+
+/**
+ * Common system tag values
+ */
+object SystemTags {
+    const val HAS_FACES = "has_faces"
+    const val MULTIPLE_PEOPLE = "multiple_people"
+    const val LANDSCAPE = "landscape"
+    const val PORTRAIT = "portrait"
+    const val LOW_QUALITY = "low_quality"
+    const val BLURRY = "blurry"
+}
+
+/**
+ * TagEntity - Normalized tag storage
  *
- * Tags are normalized so that:
- * - "park" exists once
- * - many images can reference it
+ * EXPLICIT COLUMN MAPPINGS for KSP compatibility
  */
 @Entity(tableName = "tags")
 data class TagEntity(
 
     @PrimaryKey
+    @ColumnInfo(name = "tagId")
     val tagId: String,
 
-    /**
-     * GENERIC | SYSTEM | HIDDEN
-     */
+    @ColumnInfo(name = "type")
     val type: String,
 
-    /**
-     * Human-readable value, e.g. "park", "sunset"
-     */
+    @ColumnInfo(name = "value")
     val value: String,
 
+    @ColumnInfo(name = "createdAt")
     val createdAt: Long
+) {
+    companion object {
+        /**
+         * Create a generic user tag
+         */
+        fun createUserTag(value: String): TagEntity {
+            return TagEntity(
+                tagId = UUID.randomUUID().toString(),
+                type = TagType.GENERIC,
+                value = value.trim().lowercase(),
+                createdAt = System.currentTimeMillis()
             )
+        }
+
+        /**
+         * Create a system tag (auto-generated)
+         */
+        fun createSystemTag(value: String): TagEntity {
+            return TagEntity(
+                tagId = UUID.randomUUID().toString(),
+                type = TagType.SYSTEM,
+                value = value.trim().lowercase(),
+                createdAt = System.currentTimeMillis()
+            )
+        }
+
+        /**
+         * Create hidden tag (internal use)
+         */
+        fun createHiddenTag(value: String): TagEntity {
+            return TagEntity(
+                tagId = UUID.randomUUID().toString(),
+                type = TagType.HIDDEN,
+                value = value.trim().lowercase(),
+                createdAt = System.currentTimeMillis()
+            )
+        }
+    }
+
+    /**
+     * Check if this is a user-created tag
+     */
+    fun isUserTag(): Boolean = type == TagType.GENERIC
+
+    /**
+     * Check if this is a system tag
+     */
+    fun isSystemTag(): Boolean = type == TagType.SYSTEM
+
+    /**
+     * Check if this is a hidden tag
+     */
+    fun isHiddenTag(): Boolean = type == TagType.HIDDEN
+
+    /**
+     * Get display value (capitalized for UI)
+     */
+    fun getDisplayValue(): String = value.replaceFirstChar { it.uppercase() }
+}
+
+/**
+ * TagWithUsage - For queries that include usage count
+ *
+ * NOT AN ENTITY - just a POJO for query results
+ * Do NOT add this to @Database entities list!
+ */
+data class TagWithUsage(
+    @ColumnInfo(name = "tagId")
+    val tagId: String,
+
+    @ColumnInfo(name = "type")
+    val type: String,
+
+    @ColumnInfo(name = "value")
+    val value: String,
+
+    @ColumnInfo(name = "createdAt")
+    val createdAt: Long,
+
+    @ColumnInfo(name = "usage_count")
+    val usageCount: Int
+) {
+    /**
+     * Convert to TagEntity (without usage count)
+     */
+    fun toTagEntity(): TagEntity {
+        return TagEntity(
+            tagId = tagId,
+            type = type,
+            value = value,
+            createdAt = createdAt
+        )
+    }
+}

app/src/main/java/com/placeholder/sherpai2/data/local/model/ImageWithEverything.kt

@@ -15,12 +15,6 @@ data class ImageWithEverything(
     )
     val tags: List<ImageTagEntity>,
 
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val persons: List<ImagePersonEntity>,
-
     @Relation(
         parentColumn = "imageId",
         entityColumn = "imageId"

app/src/main/java/com/placeholder/sherpai2/data/repository/Facerecognitionrepository.kt

@@ -52,7 +52,8 @@ class FaceRecognitionRepository @Inject constructor(
     ): String = withContext(Dispatchers.IO) {
 
         // Create PersonEntity with UUID
-        val person = PersonEntity(name = personName)
+        val person = PersonEntity.create(name = personName)
+
         personDao.insert(person)
 
         // Train face model
@@ -312,7 +313,10 @@ class FaceRecognitionRepository @Inject constructor(
     // ======================
 
     suspend fun verifyFaceTag(tagId: String) {
-        photoFaceTagDao.markTagAsVerified(tagId)
+        photoFaceTagDao.markTagAsVerified(
+            tagId = tagId,
+            timestamp = System.currentTimeMillis()
+        )
     }
 
     suspend fun getUnverifiedTags(): List<PhotoFaceTagEntity> {
@@ -332,6 +336,42 @@ class FaceRecognitionRepository @Inject constructor(
         faceModelDao.deleteFaceModelById(faceModelId)
     }
 
+    // Add this method to FaceRecognitionRepository_StringIds.kt
+// Replace the existing createPersonWithFaceModel method with this version:
+
+    /**
+     * Create a new person with face model in one operation.
+     * Now supports full PersonEntity with optional fields.
+     *
+     * @param person PersonEntity with name, DOB, relationship, etc.
+     * @return PersonId (String UUID)
+     */
+    suspend fun createPersonWithFaceModel(
+        person: PersonEntity,
+        validImages: List<TrainingSanityChecker.ValidTrainingImage>,
+        onProgress: (Int, Int) -> Unit = { _, _ -> }
+    ): String = withContext(Dispatchers.IO) {
+
+        // Insert person with all fields
+        personDao.insert(person)
+
+        // Train face model
+        trainPerson(
+            personId = person.id,
+            validImages = validImages,
+            onProgress = onProgress
+        )
+
+        person.id
+    }
+
+    /**
+     * Get face model by ID
+     */
+    suspend fun getFaceModelById(faceModelId: String): FaceModelEntity? = withContext(Dispatchers.IO) {
+        faceModelDao.getFaceModelById(faceModelId)
+    }
+
     suspend fun deleteTagsForImage(imageId: String) {
         photoFaceTagDao.deleteTagsForImage(imageId)
     }
@@ -339,6 +379,8 @@ class FaceRecognitionRepository @Inject constructor(
     fun cleanup() {
         faceNetModel.close()
     }
+
+
 }
 
 data class DetectedFace(
@@ -355,3 +397,4 @@ data class PersonFaceStats(
     val averageConfidence: Float,
     val lastDetectedAt: Long?
 )
+

app/src/main/java/com/placeholder/sherpai2/data/service/Autotaggingservice.kt

@@ -0,0 +1,380 @@
+package com.placeholder.sherpai2.data.service
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Color
+import com.placeholder.sherpai2.data.local.dao.ImageTagDao
+import com.placeholder.sherpai2.data.local.dao.PersonDao
+import com.placeholder.sherpai2.data.local.dao.PhotoFaceTagDao
+import com.placeholder.sherpai2.data.local.dao.TagDao
+import com.placeholder.sherpai2.data.local.entity.ImageEntity
+import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
+import com.placeholder.sherpai2.data.local.entity.TagEntity
+import com.placeholder.sherpai2.data.repository.DetectedFace
+import com.placeholder.sherpai2.util.DiagnosticLogger
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.util.Calendar
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlin.math.abs
+
+/**
+ * AutoTaggingService - Intelligent auto-tagging system
+ *
+ * Capabilities:
+ * - Face-based tags (group_photo, selfie, couple)
+ * - Scene tags (portrait, landscape, square orientation)
+ * - Time tags (morning, afternoon, evening, night)
+ * - Quality tags (high_res, low_res)
+ * - Relationship tags (family, friend, colleague from PersonEntity)
+ * - Birthday tags (from PersonEntity DOB)
+ * - Indoor/Outdoor estimation (basic heuristic)
+ */
+@Singleton
+class AutoTaggingService @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val tagDao: TagDao,
+    private val imageTagDao: ImageTagDao,
+    private val photoFaceTagDao: PhotoFaceTagDao,
+    private val personDao: PersonDao
+) {
+
+    // ======================
+    // MAIN AUTO-TAGGING
+    // ======================
+
+    /**
+     * Auto-tag an image with all applicable system tags
+     *
+     * @return Number of tags applied
+     */
+    suspend fun autoTagImage(
+        imageEntity: ImageEntity,
+        bitmap: Bitmap,
+        detectedFaces: List<DetectedFace>
+    ): Int = withContext(Dispatchers.Default) {
+        val tagsToApply = mutableListOf<String>()
+
+        // Face-count based tags
+        when (detectedFaces.size) {
+            0 -> { /* No face tags */ }
+            1 -> {
+                if (isSelfie(detectedFaces[0], bitmap)) {
+                    tagsToApply.add("selfie")
+                } else {
+                    tagsToApply.add("single_person")
+                }
+            }
+            2 -> tagsToApply.add("couple")
+            in 3..5 -> tagsToApply.add("group_photo")
+            in 6..10 -> {
+                tagsToApply.add("group_photo")
+                tagsToApply.add("large_group")
+            }
+            else -> {
+                tagsToApply.add("group_photo")
+                tagsToApply.add("large_group")
+                tagsToApply.add("crowd")
+            }
+        }
+
+        // Orientation tags
+        val aspectRatio = bitmap.width.toFloat() / bitmap.height.toFloat()
+        when {
+            aspectRatio > 1.3f -> tagsToApply.add("landscape")
+            aspectRatio < 0.77f -> tagsToApply.add("portrait")
+            else -> tagsToApply.add("square")
+        }
+
+        // Resolution tags
+        val megapixels = (bitmap.width * bitmap.height) / 1_000_000f
+        when {
+            megapixels > 2.0f -> tagsToApply.add("high_res")
+            megapixels < 0.5f -> tagsToApply.add("low_res")
+        }
+
+        // Time-based tags
+        val hourOfDay = getHourFromTimestamp(imageEntity.capturedAt)
+        tagsToApply.add(when (hourOfDay) {
+            in 5..10 -> "morning"
+            in 11..16 -> "afternoon"
+            in 17..20 -> "evening"
+            else -> "night"
+        })
+
+        // Indoor/Outdoor estimation (only if image is large enough)
+        if (bitmap.width >= 200 && bitmap.height >= 200) {
+            val isIndoor = estimateIndoorOutdoor(bitmap)
+            tagsToApply.add(if (isIndoor) "indoor" else "outdoor")
+        }
+
+        // Apply all tags
+        var tagsApplied = 0
+        tagsToApply.forEach { tagName ->
+            if (applySystemTag(imageEntity.imageId, tagName)) {
+                tagsApplied++
+            }
+        }
+
+        DiagnosticLogger.d("AutoTag: Applied $tagsApplied tags to image ${imageEntity.imageId}")
+        tagsApplied
+    }
+
+    // ======================
+    // RELATIONSHIP TAGS
+    // ======================
+
+    /**
+     * Tag all images with a person using their relationship tag
+     *
+     * @param personId Person to tag images for
+     * @return Number of tags applied
+     */
+    suspend fun autoTagRelationshipForPerson(personId: String): Int = withContext(Dispatchers.IO) {
+        val person = personDao.getPersonById(personId) ?: return@withContext 0
+        val relationship = person.relationship?.lowercase() ?: return@withContext 0
+
+        // Get face model for this person
+        val faceModels = photoFaceTagDao.getAllTagsForFaceModel(personId)
+        if (faceModels.isEmpty()) return@withContext 0
+
+        val imageIds = faceModels.map { it.imageId }.distinct()
+
+        var tagsApplied = 0
+        imageIds.forEach { imageId ->
+            if (applySystemTag(imageId, relationship)) {
+                tagsApplied++
+            }
+        }
+
+        DiagnosticLogger.i("AutoTag: Applied '$relationship' tag to $tagsApplied images for ${person.name}")
+        tagsApplied
+    }
+
+    /**
+     * Tag relationships for ALL persons in database
+     */
+    suspend fun autoTagAllRelationships(): Int = withContext(Dispatchers.IO) {
+        val persons = personDao.getAllPersons()
+        var totalTags = 0
+
+        persons.forEach { person ->
+            totalTags += autoTagRelationshipForPerson(person.id)
+        }
+
+        DiagnosticLogger.i("AutoTag: Applied $totalTags relationship tags across ${persons.size} persons")
+        totalTags
+    }
+
+    // ======================
+    // BIRTHDAY TAGS
+    // ======================
+
+    /**
+     * Tag images near a person's birthday
+     *
+     * @param personId Person whose birthday to check
+     * @param daysRange Days before/after birthday to consider (default: 3)
+     * @return Number of tags applied
+     */
+    suspend fun autoTagBirthdaysForPerson(
+        personId: String,
+        daysRange: Int = 3
+    ): Int = withContext(Dispatchers.IO) {
+        val person = personDao.getPersonById(personId) ?: return@withContext 0
+        val dateOfBirth = person.dateOfBirth ?: return@withContext 0
+
+        // Get all face tags for this person
+        val faceTags = photoFaceTagDao.getAllTagsForFaceModel(personId)
+        if (faceTags.isEmpty()) return@withContext 0
+
+        var tagsApplied = 0
+
+        faceTags.forEach { faceTag ->
+            // Get the image to check its timestamp
+            val imageId = faceTag.imageId
+
+            // Check if image was captured near birthday
+            if (isNearBirthday(faceTag.detectedAt, dateOfBirth, daysRange)) {
+                if (applySystemTag(imageId, "birthday")) {
+                    tagsApplied++
+                }
+            }
+        }
+
+        DiagnosticLogger.i("AutoTag: Applied 'birthday' tag to $tagsApplied images for ${person.name}")
+        tagsApplied
+    }
+
+    /**
+     * Tag birthdays for ALL persons with DOB
+     */
+    suspend fun autoTagAllBirthdays(daysRange: Int = 3): Int = withContext(Dispatchers.IO) {
+        val persons = personDao.getAllPersons()
+        var totalTags = 0
+
+        persons.forEach { person ->
+            if (person.dateOfBirth != null) {
+                totalTags += autoTagBirthdaysForPerson(person.id, daysRange)
+            }
+        }
+
+        DiagnosticLogger.i("AutoTag: Applied $totalTags birthday tags")
+        totalTags
+    }
+
+    // ======================
+    // HELPER METHODS
+    // ======================
+
+    /**
+     * Check if an image is a selfie based on face size
+     */
+    private fun isSelfie(face: DetectedFace, bitmap: Bitmap): Boolean {
+        val boundingBox = face.boundingBox
+        val faceArea = boundingBox.width() * boundingBox.height()
+        val imageArea = bitmap.width * bitmap.height
+        val faceRatio = faceArea.toFloat() / imageArea.toFloat()
+
+        // Selfie = face takes up significant portion (>15% of image)
+        return faceRatio > 0.15f
+    }
+
+    /**
+     * Get hour of day from timestamp (0-23)
+     */
+    private fun getHourFromTimestamp(timestamp: Long): Int {
+        return Calendar.getInstance().apply {
+            timeInMillis = timestamp
+        }.get(Calendar.HOUR_OF_DAY)
+    }
+
+    /**
+     * Check if a timestamp is near a birthday
+     */
+    private fun isNearBirthday(
+        capturedTimestamp: Long,
+        dobTimestamp: Long,
+        daysRange: Int
+    ): Boolean {
+        val capturedCal = Calendar.getInstance().apply { timeInMillis = capturedTimestamp }
+        val dobCal = Calendar.getInstance().apply { timeInMillis = dobTimestamp }
+
+        val capturedMonth = capturedCal.get(Calendar.MONTH)
+        val capturedDay = capturedCal.get(Calendar.DAY_OF_MONTH)
+        val dobMonth = dobCal.get(Calendar.MONTH)
+        val dobDay = dobCal.get(Calendar.DAY_OF_MONTH)
+
+        if (capturedMonth == dobMonth) {
+            return abs(capturedDay - dobDay) <= daysRange
+        }
+
+        // Handle edge case: birthday near end/start of month
+        // e.g., DOB = Jan 2, captured = Dec 31 (within 3 days)
+        if (abs(capturedMonth - dobMonth) == 1 || abs(capturedMonth - dobMonth) == 11) {
+            val daysInCapturedMonth = capturedCal.getActualMaximum(Calendar.DAY_OF_MONTH)
+            val daysInDobMonth = dobCal.getActualMaximum(Calendar.DAY_OF_MONTH)
+
+            if (capturedMonth < dobMonth || (capturedMonth == 11 && dobMonth == 0)) {
+                // Captured before DOB month
+                val dayDiff = (daysInCapturedMonth - capturedDay) + dobDay
+                return dayDiff <= daysRange
+            } else {
+                // Captured after DOB month
+                val dayDiff = (daysInDobMonth - dobDay) + capturedDay
+                return dayDiff <= daysRange
+            }
+        }
+
+        return false
+    }
+
+    /**
+     * Basic indoor/outdoor estimation using brightness and saturation
+     *
+     * Heuristic:
+     * - Outdoor: Higher brightness (>120), Higher saturation (>0.25)
+     * - Indoor: Lower brightness, Lower saturation
+     */
+    private fun estimateIndoorOutdoor(bitmap: Bitmap): Boolean {
+        // Sample pixels for analysis (don't process entire image)
+        val sampleSize = 100
+        val sampledPixels = mutableListOf<Int>()
+
+        val stepX = bitmap.width / sampleSize.coerceAtMost(bitmap.width)
+        val stepY = bitmap.height / sampleSize.coerceAtMost(bitmap.height)
+
+        for (x in 0 until sampleSize.coerceAtMost(bitmap.width)) {
+            for (y in 0 until sampleSize.coerceAtMost(bitmap.height)) {
+                val px = (x * stepX).coerceIn(0, bitmap.width - 1)
+                val py = (y * stepY).coerceIn(0, bitmap.height - 1)
+                sampledPixels.add(bitmap.getPixel(px, py))
+            }
+        }
+
+        if (sampledPixels.isEmpty()) return true // Default to indoor if sampling fails
+
+        // Calculate average brightness
+        val avgBrightness = sampledPixels.map { pixel ->
+            val r = Color.red(pixel)
+            val g = Color.green(pixel)
+            val b = Color.blue(pixel)
+            (r + g + b) / 3.0f
+        }.average()
+
+        // Calculate color saturation
+        val avgSaturation = sampledPixels.map { pixel ->
+            val hsv = FloatArray(3)
+            Color.colorToHSV(pixel, hsv)
+            hsv[1] // Saturation
+        }.average()
+
+        // Heuristic: Indoor if low brightness OR low saturation
+        return avgBrightness < 120 || avgSaturation < 0.25
+    }
+
+    /**
+     * Apply a system tag to an image (helper to avoid duplicates)
+     *
+     * @return true if tag was applied, false if already exists
+     */
+    private suspend fun applySystemTag(imageId: String, tagName: String): Boolean {
+        return withContext(Dispatchers.IO) {
+            try {
+                // Get or create tag
+                val tag = getOrCreateSystemTag(tagName)
+
+                // Create image-tag link
+                val imageTag = ImageTagEntity(
+                    imageId = imageId,
+                    tagId = tag.tagId,
+                    source = "AUTO",
+                    confidence = 1.0f,
+                    visibility = "PUBLIC",
+                    createdAt = System.currentTimeMillis()
+                )
+
+                imageTagDao.upsert(imageTag)
+                true
+            } catch (e: Exception) {
+                DiagnosticLogger.e("Failed to apply tag '$tagName' to image $imageId", e)
+                false
+            }
+        }
+    }
+
+    /**
+     * Get existing system tag or create new one
+     */
+    private suspend fun getOrCreateSystemTag(tagName: String): TagEntity {
+        return withContext(Dispatchers.IO) {
+            tagDao.getByValue(tagName) ?: run {
+                val newTag = TagEntity.createSystemTag(tagName)
+                tagDao.insert(newTag)
+                newTag
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/di/DatabaseModule.kt

@@ -12,97 +12,68 @@ import dagger.hilt.components.SingletonComponent
 import javax.inject.Singleton
 
 /**
- * DatabaseModule - Provides database and DAOs
+ * DatabaseModule - Provides database and ALL DAOs
  *
- * FRESH START VERSION:
- * - No migration needed
- * - Uses fallbackToDestructiveMigration (deletes old database)
- * - Perfect for development
+ * DEVELOPMENT CONFIGURATION:
+ * - fallbackToDestructiveMigration enabled
+ * - No migrations required
  */
 @Module
 @InstallIn(SingletonComponent::class)
 object DatabaseModule {
 
+    // ===== DATABASE =====
+
     @Provides
     @Singleton
     fun provideDatabase(
         @ApplicationContext context: Context
-    ): AppDatabase {
-        return Room.databaseBuilder(
+    ): AppDatabase =
+        Room.databaseBuilder(
             context,
             AppDatabase::class.java,
             "sherpai.db"
         )
-            .fallbackToDestructiveMigration()  // ← Deletes old database, creates fresh
+            .fallbackToDestructiveMigration()
             .build()
-    }
 
-    // ===== YOUR EXISTING DAOs =====
+    // ===== CORE DAOs =====
 
     @Provides
-    fun provideImageDao(database: AppDatabase): ImageDao {
-        return database.imageDao()
-    }
+    fun provideImageDao(db: AppDatabase): ImageDao =
+        db.imageDao()
 
     @Provides
-    fun provideTagDao(database: AppDatabase): TagDao {
-        return database.tagDao()
-    }
+    fun provideTagDao(db: AppDatabase): TagDao =
+        db.tagDao()
 
     @Provides
-    fun provideEventDao(database: AppDatabase): EventDao {
-        return database.eventDao()
-    }
+    fun provideEventDao(db: AppDatabase): EventDao =
+        db.eventDao()
 
     @Provides
-    fun provideImageTagDao(database: AppDatabase): ImageTagDao {
-        return database.imageTagDao()
-    }
+    fun provideImageEventDao(db: AppDatabase): ImageEventDao =
+        db.imageEventDao()
 
     @Provides
-    fun provideImagePersonDao(database: AppDatabase): ImagePersonDao {
-        return database.imagePersonDao()
-    }
+    fun provideImageAggregateDao(db: AppDatabase): ImageAggregateDao =
+        db.imageAggregateDao()
 
     @Provides
-    fun provideImageEventDao(database: AppDatabase): ImageEventDao {
-        return database.imageEventDao()
-    }
+    fun provideImageTagDao(db: AppDatabase): ImageTagDao =
+        db.imageTagDao()
+
+    // ===== FACE RECOGNITION DAOs =====
 
     @Provides
-    fun provideImageAggregateDao(database: AppDatabase): ImageAggregateDao {
-        return database.imageAggregateDao()
-    }
-
-    // ===== NEW FACE RECOGNITION DAOs =====
+    fun providePersonDao(db: AppDatabase): PersonDao =
+        db.personDao()
 
     @Provides
-    fun providePersonDao(database: AppDatabase): PersonDao {
-        return database.personDao()
-    }
+    fun provideFaceModelDao(db: AppDatabase): FaceModelDao =
+        db.faceModelDao()
 
     @Provides
-    fun provideFaceModelDao(database: AppDatabase): FaceModelDao {
-        return database.faceModelDao()
+    fun providePhotoFaceTagDao(db: AppDatabase): PhotoFaceTagDao =
+        db.photoFaceTagDao()
 }
-
-    @Provides
-    fun providePhotoFaceTagDao(database: AppDatabase): PhotoFaceTagDao {
-        return database.photoFaceTagDao()
-    }
-}
-
-/**
- * NOTES:
- *
- * fallbackToDestructiveMigration():
- * - Deletes database if schema changes
- * - Creates fresh database with new schema
- * - Perfect for development
- * - ⚠️ Users lose data on updates
- *
- * For production later:
- * - Remove fallbackToDestructiveMigration()
- * - Add .addMigrations(MIGRATION_1_2, MIGRATION_2_3, ...)
- * - This preserves user data
- */

app/src/main/java/com/placeholder/sherpai2/domain/repository/ImageRepository.kt

@@ -23,9 +23,23 @@ interface ImageRepository {
      * This function:
      * - deduplicates
      * - assigns events automatically
+     * - BLOCKS until complete (old behavior)
      */
     suspend fun ingestImages()
 
+    /**
+     * Ingest images with progress callback (NEW!)
+     *
+     * @param onProgress Called with (current, total) for progress updates
+     */
+    suspend fun ingestImagesWithProgress(onProgress: (current: Int, total: Int) -> Unit)
+
+    /**
+     * Get total image count (NEW!)
+     * Fast query to check if images already loaded
+     */
+    suspend fun getImageCount(): Int
+
     fun getAllImages(): Flow<List<ImageWithEverything>>
     fun findImagesByTag(tag: String): Flow<List<ImageWithEverything>>
 

app/src/main/java/com/placeholder/sherpai2/domain/repository/ImageRepositoryImpl.kt

@@ -15,11 +15,21 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.yield
 import java.security.MessageDigest
 import java.util.*
 import javax.inject.Inject
 import javax.inject.Singleton
 
+/**
+ * ImageRepositoryImpl - ENHANCED for large photo collections
+ *
+ * Key improvements:
+ * 1. Batched processing (100 images at a time)
+ * 2. Progress callbacks
+ * 3. Yields to prevent ANR
+ * 4. Fast image count check
+ */
 @Singleton
 class ImageRepositoryImpl @Inject constructor(
     private val imageDao: ImageDao,
@@ -34,38 +44,85 @@ class ImageRepositoryImpl @Inject constructor(
     }
 
     /**
-     * Ingest all images from MediaStore.
-     * Uses _ID and DATE_ADDED to ensure no image is skipped, even if DATE_TAKEN is identical.
+     * Get total image count - FAST
+     */
+    override suspend fun getImageCount(): Int = withContext(Dispatchers.IO) {
+        return@withContext imageDao.getImageCount()
+    }
+
+    /**
+     * Original blocking ingestion (for backward compatibility)
      */
     override suspend fun ingestImages(): Unit = withContext(Dispatchers.IO) {
-        try {
-            val imageList = mutableListOf<ImageEntity>()
+        ingestImagesWithProgress { _, _ -> }
+    }
 
+    /**
+     * Enhanced ingestion with progress tracking
+     * Processes in batches to prevent ANR and memory issues
+     * SCANS ALL FOLDERS RECURSIVELY (including nested directories)
+     */
+    override suspend fun ingestImagesWithProgress(
+        onProgress: (current: Int, total: Int) -> Unit
+    ): Unit = withContext(Dispatchers.IO) {
+        try {
             val projection = arrayOf(
                 MediaStore.Images.Media._ID,
                 MediaStore.Images.Media.DISPLAY_NAME,
                 MediaStore.Images.Media.DATE_TAKEN,
                 MediaStore.Images.Media.DATE_ADDED,
                 MediaStore.Images.Media.WIDTH,
-                MediaStore.Images.Media.HEIGHT
+                MediaStore.Images.Media.HEIGHT,
+                MediaStore.Images.Media.DATA  // Full file path
             )
 
             val sortOrder = "${MediaStore.Images.Media.DATE_ADDED} ASC"
 
+            // IMPORTANT: Don't filter by BUCKET_ID or folder
+            // This scans ALL images on device including nested folders
+            val selection = null  // No WHERE clause = all images
+            val selectionArgs = null
+
+            // First pass: Count total images
+            var totalImages = 0
+            context.contentResolver.query(
+                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                arrayOf(MediaStore.Images.Media._ID),
+                selection,
+                selectionArgs,
+                null
+            )?.use { cursor ->
+                totalImages = cursor.count
+            }
+
+            if (totalImages == 0) {
+                Log.i("ImageRepository", "No images found on device")
+                return@withContext
+            }
+
+            Log.i("ImageRepository", "Found $totalImages images to process (ALL folders)")
+            onProgress(0, totalImages)
+
+            // Second pass: Process in batches
+            val batchSize = 100
+            var processed = 0
+
             context.contentResolver.query(
                 MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                 projection,
-                null,
-                null,
+                selection,
+                selectionArgs,
                 sortOrder
             )?.use { cursor ->
-
                 val idCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID)
                 val nameCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME)
                 val dateTakenCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_TAKEN)
                 val dateAddedCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_ADDED)
                 val widthCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.WIDTH)
                 val heightCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.HEIGHT)
+                val dataCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)
+
+                val batch = mutableListOf<ImageEntity>()
 
                 while (cursor.moveToNext()) {
                     val id = cursor.getLong(idCol)
@@ -74,16 +131,14 @@ class ImageRepositoryImpl @Inject constructor(
                     val dateAdded = cursor.getLong(dateAddedCol)
                     val width = cursor.getInt(widthCol)
                     val height = cursor.getInt(heightCol)
+                    val filePath = cursor.getString(dataCol)
 
                     val contentUri: Uri = ContentUris.withAppendedId(
                         MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id
                     )
 
-                    val sha256 = computeSHA256(contentUri)
-                    if (sha256 == null) {
-                        Log.w("ImageRepository", "Skipped image: $displayName (cannot read bytes)")
-                        continue
-                    }
+                    // Skip SHA256 computation for speed - use URI as unique identifier
+                    val sha256 = computeSHA256Fast(contentUri) ?: contentUri.toString()
 
                     val imageEntity = ImageEntity(
                         imageId = UUID.randomUUID().toString(),
@@ -93,36 +148,73 @@ class ImageRepositoryImpl @Inject constructor(
                         ingestedAt = System.currentTimeMillis(),
                         width = width,
                         height = height,
-                        source = "CAMERA" // or SCREENSHOT / IMPORTED
+                        source = determineSource(filePath)
                     )
 
-                    imageList += imageEntity
-                    Log.i("ImageRepository", "Processing image: $displayName, SHA256: $sha256")
+                    batch.add(imageEntity)
+                    processed++
+
+                    // Insert batch and update progress
+                    if (batch.size >= batchSize) {
+                        imageDao.insertImages(batch)
+                        batch.clear()
+
+                        // Update progress on main thread
+                        withContext(Dispatchers.Main) {
+                            onProgress(processed, totalImages)
+                        }
+
+                        // Yield to prevent blocking
+                        yield()
+
+                        Log.d("ImageRepository", "Processed $processed/$totalImages images")
                     }
                 }
 
-            if (imageList.isNotEmpty()) {
-                imageDao.insertImages(imageList)
-                Log.i("ImageRepository", "Ingested ${imageList.size} images")
-            } else {
-                Log.i("ImageRepository", "No images found on device")
+                // Insert remaining batch
+                if (batch.isNotEmpty()) {
+                    imageDao.insertImages(batch)
+                    withContext(Dispatchers.Main) {
+                        onProgress(processed, totalImages)
                     }
+                }
+            }
+
+            Log.i("ImageRepository", "Ingestion complete: $processed images from ALL folders")
 
         } catch (e: Exception) {
             Log.e("ImageRepository", "Error ingesting images", e)
+            throw e
         }
     }
 
     /**
-     * Compute SHA256 from a MediaStore Uri safely.
+     * Determine image source from file path
      */
-    private fun computeSHA256(uri: Uri): String? {
+    private fun determineSource(filePath: String?): String {
+        if (filePath == null) return "CAMERA"
+
+        return when {
+            filePath.contains("DCIM", ignoreCase = true) -> "CAMERA"
+            filePath.contains("Screenshot", ignoreCase = true) -> "SCREENSHOT"
+            filePath.contains("Download", ignoreCase = true) -> "IMPORTED"
+            filePath.contains("WhatsApp", ignoreCase = true) -> "IMPORTED"
+            else -> "CAMERA"
+        }
+    }
+
+    /**
+     * Fast SHA256 computation - only reads first 8KB for speed
+     * For 10,000+ images, this saves significant time
+     */
+    private fun computeSHA256Fast(uri: Uri): String? {
         return try {
             val digest = MessageDigest.getInstance("SHA-256")
             context.contentResolver.openInputStream(uri)?.use { input ->
+                // Only read first 8KB for uniqueness check
                 val buffer = ByteArray(8192)
-                var read: Int
-                while (input.read(buffer).also { read = it } > 0) {
+                val read = input.read(buffer)
+                if (read > 0) {
                     digest.update(buffer, 0, read)
                 }
             } ?: return null

app/src/main/java/com/placeholder/sherpai2/ml/Thresholdstrategy.kt

@@ -0,0 +1,127 @@
+package com.placeholder.sherpai2.ml
+
+/**
+ * ThresholdStrategy - Smart threshold selection for face recognition
+ *
+ * Considers:
+ * - Training image count
+ * - Image quality
+ * - Detection context (group photo, selfie, etc.)
+ */
+object ThresholdStrategy {
+
+    /**
+     * Get optimal threshold for face recognition
+     *
+     * @param trainingCount Number of images used to train the model
+     * @param imageQuality Quality assessment of the image being scanned
+     * @param detectionContext Context of the detection (group, selfie, etc.)
+     * @return Similarity threshold (0.0 - 1.0)
+     */
+    fun getOptimalThreshold(
+        trainingCount: Int,
+        imageQuality: ImageQuality = ImageQuality.UNKNOWN,
+        detectionContext: DetectionContext = DetectionContext.GENERAL
+    ): Float {
+        // Base threshold from training count
+        val baseThreshold = when {
+            trainingCount >= 40 -> 0.68f  // High confidence - strict
+            trainingCount >= 30 -> 0.62f  // Good confidence - moderate-strict
+            trainingCount >= 20 -> 0.56f  // Moderate confidence
+            trainingCount >= 15 -> 0.50f  // Acceptable confidence - lenient
+            else -> 0.48f                  // Sparse training - very lenient
+        }
+
+        // Adjust based on image quality
+        val qualityAdjustment = when (imageQuality) {
+            ImageQuality.HIGH -> -0.02f    // Can be stricter with good quality
+            ImageQuality.MEDIUM -> 0f      // No change
+            ImageQuality.LOW -> +0.03f     // Be more lenient with poor quality
+            ImageQuality.UNKNOWN -> 0f     // No change
+        }
+
+        // Adjust based on detection context
+        val contextAdjustment = when (detectionContext) {
+            DetectionContext.GROUP_PHOTO -> +0.02f   // More lenient in groups (faces smaller)
+            DetectionContext.SELFIE -> -0.03f         // Stricter for close-ups (more detail)
+            DetectionContext.PROFILE -> +0.02f        // More lenient for side profiles
+            DetectionContext.DISTANT -> +0.03f        // More lenient for far away faces
+            DetectionContext.GENERAL -> 0f            // No change
+        }
+
+        // Combine adjustments and clamp to safe range
+        return (baseThreshold + qualityAdjustment + contextAdjustment).coerceIn(0.40f, 0.75f)
+    }
+
+    /**
+     * Get threshold for liberal matching (e.g., during testing)
+     */
+    fun getLiberalThreshold(trainingCount: Int): Float {
+        return when {
+            trainingCount >= 30 -> 0.52f
+            trainingCount >= 20 -> 0.48f
+            else -> 0.45f
+        }.coerceIn(0.40f, 0.65f)
+    }
+
+    /**
+     * Get threshold for conservative matching (minimize false positives)
+     */
+    fun getConservativeThreshold(trainingCount: Int): Float {
+        return when {
+            trainingCount >= 40 -> 0.72f
+            trainingCount >= 30 -> 0.68f
+            trainingCount >= 20 -> 0.62f
+            else -> 0.58f
+        }.coerceIn(0.55f, 0.75f)
+    }
+
+    /**
+     * Estimate image quality from bitmap properties
+     */
+    fun estimateImageQuality(width: Int, height: Int, fileSize: Long = 0): ImageQuality {
+        val megapixels = (width * height) / 1_000_000f
+
+        return when {
+            megapixels > 4.0f -> ImageQuality.HIGH
+            megapixels > 1.0f -> ImageQuality.MEDIUM
+            else -> ImageQuality.LOW
+        }
+    }
+
+    /**
+     * Estimate detection context from face count and face size
+     */
+    fun estimateDetectionContext(
+        faceCount: Int,
+        faceAreaRatio: Float = 0f
+    ): DetectionContext {
+        return when {
+            faceCount == 1 && faceAreaRatio > 0.15f -> DetectionContext.SELFIE
+            faceCount == 1 && faceAreaRatio < 0.05f -> DetectionContext.DISTANT
+            faceCount >= 3 -> DetectionContext.GROUP_PHOTO
+            else -> DetectionContext.GENERAL
+        }
+    }
+}
+
+/**
+ * Image quality assessment
+ */
+enum class ImageQuality {
+    HIGH,     // > 4MP, good lighting
+    MEDIUM,   // 1-4MP
+    LOW,      // < 1MP, poor quality
+    UNKNOWN   // Cannot determine
+}
+
+/**
+ * Detection context
+ */
+enum class DetectionContext {
+    GROUP_PHOTO,  // Multiple faces (3+)
+    SELFIE,       // Single face, close-up
+    PROFILE,      // Side view
+    DISTANT,      // Face is small in frame
+    GENERAL       // Default
+}

app/src/main/java/com/placeholder/sherpai2/ui/album/Albumviewmodel.kt

@@ -0,0 +1,336 @@
+package com.placeholder.sherpai2.ui.album
+
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.local.dao.ImageDao
+import com.placeholder.sherpai2.data.local.dao.ImageTagDao
+import com.placeholder.sherpai2.data.local.dao.PersonDao
+import com.placeholder.sherpai2.data.local.dao.TagDao
+import com.placeholder.sherpai2.data.local.entity.ImageEntity
+import com.placeholder.sherpai2.data.local.entity.PersonEntity
+import com.placeholder.sherpai2.data.local.entity.PhotoFaceTagEntity
+import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
+import com.placeholder.sherpai2.ui.search.DateRange
+import com.placeholder.sherpai2.ui.search.DisplayMode
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import java.util.Calendar
+import javax.inject.Inject
+
+/**
+ * AlbumViewModel - Display photos from a specific album (tag, person, or time range)
+ *
+ * Features:
+ * - Search within album
+ * - Date filtering
+ * - Simple/Verbose toggle
+ * - Album stats
+ */
+@HiltViewModel
+class AlbumViewModel @Inject constructor(
+    savedStateHandle: SavedStateHandle,
+    private val tagDao: TagDao,
+    private val imageTagDao: ImageTagDao,
+    private val imageDao: ImageDao,
+    private val personDao: PersonDao,
+    private val faceRecognitionRepository: FaceRecognitionRepository
+) : ViewModel() {
+
+    // Album parameters from navigation
+    private val albumType: String = savedStateHandle["albumType"] ?: "tag"
+    private val albumId: String = savedStateHandle["albumId"] ?: ""
+
+    // UI state
+    private val _uiState = MutableStateFlow<AlbumUiState>(AlbumUiState.Loading)
+    val uiState: StateFlow<AlbumUiState> = _uiState.asStateFlow()
+
+    // Search query within album
+    private val _searchQuery = MutableStateFlow("")
+    val searchQuery: StateFlow<String> = _searchQuery.asStateFlow()
+
+    // Date range filter
+    private val _dateRange = MutableStateFlow(DateRange.ALL_TIME)
+    val dateRange: StateFlow<DateRange> = _dateRange.asStateFlow()
+
+    // Display mode
+    private val _displayMode = MutableStateFlow(DisplayMode.SIMPLE)
+    val displayMode: StateFlow<DisplayMode> = _displayMode.asStateFlow()
+
+    init {
+        loadAlbumData()
+    }
+
+    /**
+     * Load album data based on type
+     */
+    private fun loadAlbumData() {
+        viewModelScope.launch {
+            try {
+                _uiState.value = AlbumUiState.Loading
+
+                when (albumType) {
+                    "tag" -> loadTagAlbum()
+                    "person" -> loadPersonAlbum()
+                    "time" -> loadTimeAlbum()
+                    else -> _uiState.value = AlbumUiState.Error("Unknown album type")
+                }
+
+            } catch (e: Exception) {
+                _uiState.value = AlbumUiState.Error(e.message ?: "Failed to load album")
+            }
+        }
+    }
+
+    private suspend fun loadTagAlbum() {
+        val tag = tagDao.getByValue(albumId)
+        if (tag == null) {
+            _uiState.value = AlbumUiState.Error("Tag not found")
+            return
+        }
+
+        combine(
+            _searchQuery,
+            _dateRange
+        ) { query, dateRange ->
+            Pair(query, dateRange)
+        }.collectLatest { (query, dateRange) ->
+            val imageIds = imageTagDao.findImagesByTag(tag.tagId, 0.5f)
+            val images = imageDao.getImagesByIds(imageIds)
+
+            val filteredImages = images
+                .filter { isInDateRange(it.capturedAt, dateRange) }
+                .filter {
+                    query.isBlank() || containsQuery(it, query)
+                }
+
+            val imagesWithFaces = filteredImages.map { image ->
+                val tagsWithPersons = faceRecognitionRepository.getFaceTagsWithPersons(image.imageId)
+                AlbumPhoto(
+                    image = image,
+                    faceTags = tagsWithPersons.map { it.first },
+                    persons = tagsWithPersons.map { it.second }
+                )
+            }
+
+            val uniquePersons = imagesWithFaces
+                .flatMap { it.persons }
+                .distinctBy { it.id }
+
+            _uiState.value = AlbumUiState.Success(
+                albumName = tag.value.replace("_", " ").capitalize(),
+                albumType = "Tag",
+                photos = imagesWithFaces,
+                personCount = uniquePersons.size,
+                totalFaces = imagesWithFaces.sumOf { it.faceTags.size }
+            )
+        }
+    }
+
+    private suspend fun loadPersonAlbum() {
+        val person = personDao.getPersonById(albumId)
+        if (person == null) {
+            _uiState.value = AlbumUiState.Error("Person not found")
+            return
+        }
+
+        combine(
+            _searchQuery,
+            _dateRange
+        ) { query, dateRange ->
+            Pair(query, dateRange)
+        }.collectLatest { (query, dateRange) ->
+            val images = faceRecognitionRepository.getImagesForPerson(albumId)
+
+            val filteredImages = images
+                .filter { isInDateRange(it.capturedAt, dateRange) }
+                .filter {
+                    query.isBlank() || containsQuery(it, query)
+                }
+
+            val imagesWithFaces = filteredImages.map { image ->
+                val tagsWithPersons = faceRecognitionRepository.getFaceTagsWithPersons(image.imageId)
+                AlbumPhoto(
+                    image = image,
+                    faceTags = tagsWithPersons.map { it.first },
+                    persons = tagsWithPersons.map { it.second }
+                )
+            }
+
+            _uiState.value = AlbumUiState.Success(
+                albumName = person.name,
+                albumType = "Person",
+                photos = imagesWithFaces,
+                personCount = 1,
+                totalFaces = imagesWithFaces.sumOf { it.faceTags.size }
+            )
+        }
+    }
+
+    private suspend fun loadTimeAlbum() {
+        // Time-based albums (Today, This Week, etc)
+        val (startTime, endTime, albumName) = when (albumId) {
+            "today" -> Triple(getStartOfDay(), System.currentTimeMillis(), "Today")
+            "week" -> Triple(getStartOfWeek(), System.currentTimeMillis(), "This Week")
+            "month" -> Triple(getStartOfMonth(), System.currentTimeMillis(), "This Month")
+            "year" -> Triple(getStartOfYear(), System.currentTimeMillis(), "This Year")
+            else -> {
+                _uiState.value = AlbumUiState.Error("Unknown time range")
+                return
+            }
+        }
+
+        combine(
+            _searchQuery,
+            _dateRange
+        ) { query, _ ->
+            query
+        }.collectLatest { query ->
+            val images = imageDao.getImagesInRange(startTime, endTime)
+
+            val filteredImages = images.filter {
+                query.isBlank() || containsQuery(it, query)
+            }
+
+            val imagesWithFaces = filteredImages.map { image ->
+                val tagsWithPersons = faceRecognitionRepository.getFaceTagsWithPersons(image.imageId)
+                AlbumPhoto(
+                    image = image,
+                    faceTags = tagsWithPersons.map { it.first },
+                    persons = tagsWithPersons.map { it.second }
+                )
+            }
+
+            val uniquePersons = imagesWithFaces
+                .flatMap { it.persons }
+                .distinctBy { it.id }
+
+            _uiState.value = AlbumUiState.Success(
+                albumName = albumName,
+                albumType = "Time",
+                photos = imagesWithFaces,
+                personCount = uniquePersons.size,
+                totalFaces = imagesWithFaces.sumOf { it.faceTags.size }
+            )
+        }
+    }
+
+    fun setSearchQuery(query: String) {
+        _searchQuery.value = query
+    }
+
+    fun setDateRange(range: DateRange) {
+        _dateRange.value = range
+    }
+
+    fun toggleDisplayMode() {
+        _displayMode.value = when (_displayMode.value) {
+            DisplayMode.SIMPLE -> DisplayMode.VERBOSE
+            DisplayMode.VERBOSE -> DisplayMode.SIMPLE
+        }
+    }
+
+    private fun isInDateRange(timestamp: Long, range: DateRange): Boolean {
+        return when (range) {
+            DateRange.ALL_TIME -> true
+            DateRange.TODAY -> isToday(timestamp)
+            DateRange.THIS_WEEK -> isThisWeek(timestamp)
+            DateRange.THIS_MONTH -> isThisMonth(timestamp)
+            DateRange.THIS_YEAR -> isThisYear(timestamp)
+        }
+    }
+
+    private fun containsQuery(image: ImageEntity, query: String): Boolean {
+        // Could expand to search by person names, tags, etc.
+        return true
+    }
+
+    private fun isToday(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR) &&
+                today.get(Calendar.DAY_OF_YEAR) == date.get(Calendar.DAY_OF_YEAR)
+    }
+
+    private fun isThisWeek(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR) &&
+                today.get(Calendar.WEEK_OF_YEAR) == date.get(Calendar.WEEK_OF_YEAR)
+    }
+
+    private fun isThisMonth(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR) &&
+                today.get(Calendar.MONTH) == date.get(Calendar.MONTH)
+    }
+
+    private fun isThisYear(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR)
+    }
+
+    private fun getStartOfDay(): Long {
+        return Calendar.getInstance().apply {
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+
+    private fun getStartOfWeek(): Long {
+        return Calendar.getInstance().apply {
+            set(Calendar.DAY_OF_WEEK, firstDayOfWeek)
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+
+    private fun getStartOfMonth(): Long {
+        return Calendar.getInstance().apply {
+            set(Calendar.DAY_OF_MONTH, 1)
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+
+    private fun getStartOfYear(): Long {
+        return Calendar.getInstance().apply {
+            set(Calendar.DAY_OF_YEAR, 1)
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+
+    private fun String.capitalize(): String {
+        return this.replaceFirstChar { it.uppercase() }
+    }
+}
+
+sealed class AlbumUiState {
+    object Loading : AlbumUiState()
+    data class Success(
+        val albumName: String,
+        val albumType: String,
+        val photos: List<AlbumPhoto>,
+        val personCount: Int,
+        val totalFaces: Int
+    ) : AlbumUiState()
+    data class Error(val message: String) : AlbumUiState()
+}
+
+data class AlbumPhoto(
+    val image: ImageEntity,
+    val faceTags: List<PhotoFaceTagEntity>,
+    val persons: List<PersonEntity>
+)

app/src/main/java/com/placeholder/sherpai2/ui/album/Albumviewscreen.kt

@@ -0,0 +1,358 @@
+package com.placeholder.sherpai2.ui.album
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.grid.*
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.placeholder.sherpai2.ui.search.DateRange
+import com.placeholder.sherpai2.ui.search.DisplayMode
+import com.placeholder.sherpai2.ui.search.components.ImageGridItem
+
+/**
+ * AlbumViewScreen - Beautiful album detail view
+ *
+ * Features:
+ * - Album stats
+ * - Search within album
+ * - Date filtering
+ * - Simple/Verbose toggle
+ * - Clean person display
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AlbumViewScreen(
+    onBack: () -> Unit,
+    onImageClick: (String) -> Unit,
+    viewModel: AlbumViewModel = hiltViewModel()
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val searchQuery by viewModel.searchQuery.collectAsStateWithLifecycle()
+    val dateRange by viewModel.dateRange.collectAsStateWithLifecycle()
+    val displayMode by viewModel.displayMode.collectAsStateWithLifecycle()
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = {
+                    Column {
+                        when (val state = uiState) {
+                            is AlbumUiState.Success -> {
+                                Text(
+                                    text = state.albumName,
+                                    style = MaterialTheme.typography.titleLarge,
+                                    fontWeight = FontWeight.Bold
+                                )
+                                Text(
+                                    text = "${state.photos.size} photos",
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                )
+                            }
+                            else -> {
+                                Text("Album")
+                            }
+                        }
+                    }
+                },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(Icons.Default.ArrowBack, "Back")
+                    }
+                },
+                actions = {
+                    IconButton(onClick = { viewModel.toggleDisplayMode() }) {
+                        Icon(
+                            imageVector = if (displayMode == DisplayMode.SIMPLE) {
+                                Icons.Default.ViewList
+                            } else {
+                                Icons.Default.ViewModule
+                            },
+                            contentDescription = "Toggle view"
+                        )
+                    }
+                }
+            )
+        }
+    ) { paddingValues ->
+        when (val state = uiState) {
+            is AlbumUiState.Loading -> {
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(paddingValues),
+                    contentAlignment = Alignment.Center
+                ) {
+                    CircularProgressIndicator()
+                }
+            }
+            is AlbumUiState.Error -> {
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(paddingValues),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        Icon(
+                            Icons.Default.Error,
+                            contentDescription = null,
+                            modifier = Modifier.size(48.dp),
+                            tint = MaterialTheme.colorScheme.error
+                        )
+                        Text(state.message)
+                        Button(onClick = onBack) {
+                            Text("Go Back")
+                        }
+                    }
+                }
+            }
+            is AlbumUiState.Success -> {
+                AlbumContent(
+                    state = state,
+                    searchQuery = searchQuery,
+                    dateRange = dateRange,
+                    displayMode = displayMode,
+                    onSearchChange = { viewModel.setSearchQuery(it) },
+                    onDateRangeChange = { viewModel.setDateRange(it) },
+                    onImageClick = onImageClick,
+                    modifier = Modifier.padding(paddingValues)
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun AlbumContent(
+    state: AlbumUiState.Success,
+    searchQuery: String,
+    dateRange: DateRange,
+    displayMode: DisplayMode,
+    onSearchChange: (String) -> Unit,
+    onDateRangeChange: (DateRange) -> Unit,
+    onImageClick: (String) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    Column(
+        modifier = modifier.fillMaxSize()
+    ) {
+        // Stats card
+        Card(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
+            )
+        ) {
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp),
+                horizontalArrangement = Arrangement.SpaceAround
+            ) {
+                StatItem(Icons.Default.Photo, "Photos", state.photos.size.toString())
+                if (state.totalFaces > 0) {
+                    StatItem(Icons.Default.Face, "Faces", state.totalFaces.toString())
+                }
+                if (state.personCount > 0) {
+                    StatItem(Icons.Default.People, "People", state.personCount.toString())
+                }
+            }
+        }
+
+        // Search bar
+        OutlinedTextField(
+            value = searchQuery,
+            onValueChange = onSearchChange,
+            placeholder = { Text("Search in album...") },
+            leadingIcon = { Icon(Icons.Default.Search, null) },
+            trailingIcon = {
+                if (searchQuery.isNotEmpty()) {
+                    IconButton(onClick = { onSearchChange("") }) {
+                        Icon(Icons.Default.Clear, "Clear")
+                    }
+                }
+            },
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 16.dp),
+            singleLine = true,
+            shape = RoundedCornerShape(16.dp)
+        )
+
+        Spacer(Modifier.height(8.dp))
+
+        // Date filters
+        LazyRow(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 16.dp),
+            horizontalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            items(DateRange.entries) { range ->
+                val isActive = dateRange == range
+                FilterChip(
+                    selected = isActive,
+                    onClick = { onDateRangeChange(range) },
+                    label = { Text(range.displayName) }
+                )
+            }
+        }
+
+        Spacer(Modifier.height(8.dp))
+
+        // Photo grid
+        if (state.photos.isEmpty()) {
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = Alignment.Center
+            ) {
+                Text(
+                    text = "No photos in this album",
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        } else {
+            LazyVerticalGrid(
+                columns = GridCells.Adaptive(120.dp),
+                contentPadding = PaddingValues(12.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+                horizontalArrangement = Arrangement.spacedBy(12.dp),
+                modifier = Modifier.fillMaxSize()
+            ) {
+                items(
+                    items = state.photos,
+                    key = { it.image.imageId }
+                ) { photo ->
+                    PhotoCard(
+                        photo = photo,
+                        displayMode = displayMode,
+                        onImageClick = onImageClick
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun StatItem(icon: androidx.compose.ui.graphics.vector.ImageVector, label: String, value: String) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        Icon(
+            icon,
+            contentDescription = null,
+            modifier = Modifier.size(24.dp),
+            tint = MaterialTheme.colorScheme.primary
+        )
+        Text(
+            text = value,
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold
+        )
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+    }
+}
+
+@Composable
+private fun PhotoCard(
+    photo: AlbumPhoto,
+    displayMode: DisplayMode,
+    onImageClick: (String) -> Unit
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(12.dp)
+    ) {
+        Column {
+            ImageGridItem(
+                image = photo.image,
+                onClick = { onImageClick(photo.image.imageUri) }
+            )
+
+            if (photo.persons.isNotEmpty()) {
+                when (displayMode) {
+                    DisplayMode.SIMPLE -> {
+                        Surface(
+                            color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f),
+                            modifier = Modifier.fillMaxWidth()
+                        ) {
+                            Text(
+                                text = photo.persons.take(3).joinToString(", ") { it.name },
+                                style = MaterialTheme.typography.bodySmall,
+                                modifier = Modifier.padding(8.dp),
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis
+                            )
+                        }
+                    }
+                    DisplayMode.VERBOSE -> {
+                        Surface(
+                            color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f),
+                            modifier = Modifier.fillMaxWidth()
+                        ) {
+                            Column(
+                                modifier = Modifier.padding(8.dp),
+                                verticalArrangement = Arrangement.spacedBy(4.dp)
+                            ) {
+                                photo.persons.take(3).forEachIndexed { index, person ->
+                                    Row(
+                                        horizontalArrangement = Arrangement.spacedBy(6.dp),
+                                        verticalAlignment = Alignment.CenterVertically
+                                    ) {
+                                        Icon(
+                                            Icons.Default.Face,
+                                            null,
+                                            Modifier.size(14.dp),
+                                            MaterialTheme.colorScheme.primary
+                                        )
+                                        Text(
+                                            text = person.name,
+                                            style = MaterialTheme.typography.bodySmall,
+                                            modifier = Modifier.weight(1f),
+                                            maxLines = 1,
+                                            overflow = TextOverflow.Ellipsis
+                                        )
+                                        if (index < photo.faceTags.size) {
+                                            val confidence = (photo.faceTags[index].confidence * 100).toInt()
+                                            Text(
+                                                text = "$confidence%",
+                                                style = MaterialTheme.typography.labelSmall,
+                                                color = MaterialTheme.colorScheme.primary
+                                            )
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/explore/Explorescreen.kt

@@ -0,0 +1,459 @@
+package com.placeholder.sherpai2.ui.explore
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+
+/**
+ * ExploreScreen - REDESIGNED
+ *
+ * Features:
+ * - Rectangular album cards (more compact)
+ * - Stories section (recent highlights)
+ * - Clickable navigation to AlbumViewScreen
+ * - Beautiful gradients and icons
+ */
+@Composable
+fun ExploreScreen(
+    onAlbumClick: (albumType: String, albumId: String) -> Unit,
+    viewModel: ExploreViewModel = hiltViewModel()
+) {
+    val uiState by viewModel.uiState.collectAsState()
+
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.surface)
+    ) {
+        // Header with gradient
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(
+                    Brush.verticalGradient(
+                        colors = listOf(
+                            MaterialTheme.colorScheme.primaryContainer,
+                            MaterialTheme.colorScheme.surface
+                        )
+                    )
+                )
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp)
+            ) {
+                Text(
+                    text = "Explore",
+                    style = MaterialTheme.typography.headlineLarge,
+                    fontWeight = FontWeight.Bold
+                )
+                Text(
+                    text = "Your photo collection organized",
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+
+        when (val state = uiState) {
+            is ExploreViewModel.ExploreUiState.Loading -> {
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.Center
+                ) {
+                    CircularProgressIndicator()
+                }
+            }
+            is ExploreViewModel.ExploreUiState.Success -> {
+                ExploreContent(
+                    smartAlbums = state.smartAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+            is ExploreViewModel.ExploreUiState.Error -> {
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        Icon(
+                            Icons.Default.Error,
+                            contentDescription = null,
+                            modifier = Modifier.size(48.dp),
+                            tint = MaterialTheme.colorScheme.error
+                        )
+                        Text(
+                            text = state.message,
+                            color = MaterialTheme.colorScheme.error
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ExploreContent(
+    smartAlbums: List<SmartAlbum>,
+    onAlbumClick: (albumType: String, albumId: String) -> Unit
+) {
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        contentPadding = PaddingValues(vertical = 16.dp),
+        verticalArrangement = Arrangement.spacedBy(24.dp)
+    ) {
+        // Stories Section (Recent Highlights)
+        item {
+            StoriesSection(
+                albums = smartAlbums.filter { it.imageCount > 0 }.take(10),
+                onAlbumClick = onAlbumClick
+            )
+        }
+
+        // Time-based Albums
+        val timeAlbums = smartAlbums.filterIsInstance<SmartAlbum.TimeRange>()
+        if (timeAlbums.isNotEmpty()) {
+            item {
+                AlbumSection(
+                    title = "📅 Time Capsules",
+                    albums = timeAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+        }
+
+        // Face-based Albums
+        val faceAlbums = smartAlbums.filterIsInstance<SmartAlbum.Tagged>()
+            .filter { it.tagValue in listOf("group_photo", "selfie", "couple") }
+        if (faceAlbums.isNotEmpty()) {
+            item {
+                AlbumSection(
+                    title = "👥 People & Groups",
+                    albums = faceAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+        }
+
+        // Relationship Albums
+        val relationshipAlbums = smartAlbums.filterIsInstance<SmartAlbum.Tagged>()
+            .filter { it.tagValue in listOf("family", "friend", "colleague") }
+        if (relationshipAlbums.isNotEmpty()) {
+            item {
+                AlbumSection(
+                    title = "❤️ Relationships",
+                    albums = relationshipAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+        }
+
+        // Time of Day Albums
+        val timeOfDayAlbums = smartAlbums.filterIsInstance<SmartAlbum.Tagged>()
+            .filter { it.tagValue in listOf("morning", "afternoon", "evening", "night") }
+        if (timeOfDayAlbums.isNotEmpty()) {
+            item {
+                AlbumSection(
+                    title = "🌅 Times of Day",
+                    albums = timeOfDayAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+        }
+
+        // Scene Albums
+        val sceneAlbums = smartAlbums.filterIsInstance<SmartAlbum.Tagged>()
+            .filter { it.tagValue in listOf("indoor", "outdoor") }
+        if (sceneAlbums.isNotEmpty()) {
+            item {
+                AlbumSection(
+                    title = "🏞️ Scenes",
+                    albums = sceneAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+        }
+
+        // Special Occasions
+        val specialAlbums = smartAlbums.filterIsInstance<SmartAlbum.Tagged>()
+            .filter { it.tagValue in listOf("birthday", "high_res") }
+        if (specialAlbums.isNotEmpty()) {
+            item {
+                AlbumSection(
+                    title = "⭐ Special",
+                    albums = specialAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+        }
+
+        // Person Albums
+        val personAlbums = smartAlbums.filterIsInstance<SmartAlbum.Person>()
+        if (personAlbums.isNotEmpty()) {
+            item {
+                AlbumSection(
+                    title = "👤 People",
+                    albums = personAlbums,
+                    onAlbumClick = onAlbumClick
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Stories section - Instagram-style circular highlights
+ */
+@Composable
+private fun StoriesSection(
+    albums: List<SmartAlbum>,
+    onAlbumClick: (albumType: String, albumId: String) -> Unit
+) {
+    Column(
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        Text(
+            text = "📖 Stories",
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold,
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+        )
+
+        LazyRow(
+            contentPadding = PaddingValues(horizontal = 16.dp),
+            horizontalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            items(albums) { album ->
+                StoryCircle(
+                    album = album,
+                    onClick = {
+                        val (type, id) = getAlbumNavigation(album)
+                        onAlbumClick(type, id)
+                    }
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Story circle - circular album preview
+ */
+@Composable
+private fun StoryCircle(
+    album: SmartAlbum,
+    onClick: () -> Unit
+) {
+    val (icon, gradient) = getAlbumIconAndGradient(album)
+
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+        modifier = Modifier.clickable(onClick = onClick)
+    ) {
+        Box(
+            modifier = Modifier
+                .size(80.dp)
+                .clip(CircleShape)
+                .background(gradient),
+            contentAlignment = Alignment.Center
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = Color.White,
+                modifier = Modifier.size(36.dp)
+            )
+        }
+
+        Text(
+            text = album.displayName,
+            style = MaterialTheme.typography.labelSmall,
+            maxLines = 2,
+            modifier = Modifier.width(80.dp),
+            fontWeight = FontWeight.Medium
+        )
+
+        Text(
+            text = "${album.imageCount}",
+            style = MaterialTheme.typography.labelSmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+    }
+}
+
+/**
+ * Album section with horizontal scrolling rectangular cards
+ */
+@Composable
+private fun AlbumSection(
+    title: String,
+    albums: List<SmartAlbum>,
+    onAlbumClick: (albumType: String, albumId: String) -> Unit
+) {
+    Column(
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold,
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
+        )
+
+        LazyRow(
+            contentPadding = PaddingValues(horizontal = 16.dp),
+            horizontalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            items(albums) { album ->
+                AlbumCard(
+                    album = album,
+                    onClick = {
+                        val (type, id) = getAlbumNavigation(album)
+                        onAlbumClick(type, id)
+                    }
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Rectangular album card - more compact than square
+ */
+@Composable
+private fun AlbumCard(
+    album: SmartAlbum,
+    onClick: () -> Unit
+) {
+    val (icon, gradient) = getAlbumIconAndGradient(album)
+
+    Card(
+        modifier = Modifier
+            .width(180.dp)
+            .height(120.dp)
+            .clickable(onClick = onClick),
+        shape = RoundedCornerShape(16.dp),
+        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(gradient)
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(16.dp),
+                verticalArrangement = Arrangement.SpaceBetween
+            ) {
+                // Icon
+                Icon(
+                    imageVector = icon,
+                    contentDescription = null,
+                    tint = Color.White,
+                    modifier = Modifier.size(32.dp)
+                )
+
+                // Album info
+                Column {
+                    Text(
+                        text = album.displayName,
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold,
+                        color = Color.White,
+                        maxLines = 1
+                    )
+                    Text(
+                        text = "${album.imageCount} ${if (album.imageCount == 1) "photo" else "photos"}",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = Color.White.copy(alpha = 0.9f)
+                    )
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Get navigation parameters for album
+ */
+private fun getAlbumNavigation(album: SmartAlbum): Pair<String, String> {
+    return when (album) {
+        is SmartAlbum.TimeRange.Today -> "time" to "today"
+        is SmartAlbum.TimeRange.ThisWeek -> "time" to "week"
+        is SmartAlbum.TimeRange.ThisMonth -> "time" to "month"
+        is SmartAlbum.TimeRange.LastYear -> "time" to "year"
+        is SmartAlbum.Tagged -> "tag" to album.tagValue
+        is SmartAlbum.Person -> "person" to album.personId
+    }
+}
+
+/**
+ * Get icon and gradient for album type
+ */
+private fun getAlbumIconAndGradient(album: SmartAlbum): Pair<ImageVector, Brush> {
+    return when (album) {
+        is SmartAlbum.TimeRange.Today -> Icons.Default.Today to gradientBlue()
+        is SmartAlbum.TimeRange.ThisWeek -> Icons.Default.DateRange to gradientTeal()
+        is SmartAlbum.TimeRange.ThisMonth -> Icons.Default.CalendarMonth to gradientGreen()
+        is SmartAlbum.TimeRange.LastYear -> Icons.Default.HistoryEdu to gradientPurple()
+        is SmartAlbum.Tagged -> when (album.tagValue) {
+            "group_photo" -> Icons.Default.Group to gradientOrange()
+            "selfie" -> Icons.Default.CameraAlt to gradientPink()
+            "couple" -> Icons.Default.Favorite to gradientRed()
+            "family" -> Icons.Default.FamilyRestroom to gradientIndigo()
+            "friend" -> Icons.Default.People to gradientCyan()
+            "colleague" -> Icons.Default.BusinessCenter to gradientGray()
+            "morning" -> Icons.Default.WbSunny to gradientYellow()
+            "afternoon" -> Icons.Default.LightMode to gradientOrange()
+            "evening" -> Icons.Default.WbTwilight to gradientOrange()
+            "night" -> Icons.Default.NightsStay to gradientDarkBlue()
+            "outdoor" -> Icons.Default.Landscape to gradientGreen()
+            "indoor" -> Icons.Default.Home to gradientBrown()
+            "birthday" -> Icons.Default.Cake to gradientPink()
+            "high_res" -> Icons.Default.HighQuality to gradientGold()
+            else -> Icons.Default.Label to gradientBlue()
+        }
+        is SmartAlbum.Person -> Icons.Default.Person to gradientPurple()
+    }
+}
+
+// Gradient helpers
+private fun gradientBlue() = Brush.linearGradient(listOf(Color(0xFF1976D2), Color(0xFF1565C0)))
+private fun gradientTeal() = Brush.linearGradient(listOf(Color(0xFF00897B), Color(0xFF00796B)))
+private fun gradientGreen() = Brush.linearGradient(listOf(Color(0xFF388E3C), Color(0xFF2E7D32)))
+private fun gradientPurple() = Brush.linearGradient(listOf(Color(0xFF7B1FA2), Color(0xFF6A1B9A)))
+private fun gradientOrange() = Brush.linearGradient(listOf(Color(0xFFF57C00), Color(0xFFE64A19)))
+private fun gradientPink() = Brush.linearGradient(listOf(Color(0xFFD81B60), Color(0xFFC2185B)))
+private fun gradientRed() = Brush.linearGradient(listOf(Color(0xFFE53935), Color(0xFFD32F2F)))
+private fun gradientIndigo() = Brush.linearGradient(listOf(Color(0xFF3949AB), Color(0xFF303F9F)))
+private fun gradientCyan() = Brush.linearGradient(listOf(Color(0xFF00ACC1), Color(0xFF0097A7)))
+private fun gradientGray() = Brush.linearGradient(listOf(Color(0xFF616161), Color(0xFF424242)))
+private fun gradientYellow() = Brush.linearGradient(listOf(Color(0xFFFDD835), Color(0xFFFBC02D)))
+private fun gradientDarkBlue() = Brush.linearGradient(listOf(Color(0xFF283593), Color(0xFF1A237E)))
+private fun gradientBrown() = Brush.linearGradient(listOf(Color(0xFF5D4037), Color(0xFF4E342E)))
+private fun gradientGold() = Brush.linearGradient(listOf(Color(0xFFFFB300), Color(0xFFFFA000)))

app/src/main/java/com/placeholder/sherpai2/ui/explore/Exploreviewmodel.kt

@@ -0,0 +1,302 @@
+package com.placeholder.sherpai2.ui.explore
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.local.dao.ImageDao
+import com.placeholder.sherpai2.data.local.dao.ImageTagDao
+import com.placeholder.sherpai2.data.local.dao.PersonDao
+import com.placeholder.sherpai2.data.local.dao.TagDao
+import com.placeholder.sherpai2.data.local.entity.ImageEntity
+import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import java.util.Calendar
+import javax.inject.Inject
+
+@HiltViewModel
+class ExploreViewModel @Inject constructor(
+    private val imageDao: ImageDao,
+    private val tagDao: TagDao,
+    private val imageTagDao: ImageTagDao,
+    private val personDao: PersonDao,
+    private val faceRecognitionRepository: FaceRecognitionRepository
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow<ExploreUiState>(ExploreUiState.Loading)
+    val uiState: StateFlow<ExploreUiState> = _uiState.asStateFlow()
+
+    sealed class ExploreUiState {
+        object Loading : ExploreUiState()
+        data class Success(
+            val smartAlbums: List<SmartAlbum>
+        ) : ExploreUiState()
+        data class Error(val message: String) : ExploreUiState()
+    }
+
+    init {
+        loadExploreData()
+    }
+
+    fun loadExploreData() {
+        viewModelScope.launch {
+            try {
+                _uiState.value = ExploreUiState.Loading
+
+                val smartAlbums = buildSmartAlbums()
+
+                _uiState.value = ExploreUiState.Success(
+                    smartAlbums = smartAlbums
+                )
+
+            } catch (e: Exception) {
+                _uiState.value = ExploreUiState.Error(
+                    e.message ?: "Failed to load explore data"
+                )
+            }
+        }
+    }
+
+    private suspend fun buildSmartAlbums(): List<SmartAlbum> {
+        val albums = mutableListOf<SmartAlbum>()
+
+        // Time-based albums
+        albums.add(SmartAlbum.TimeRange.Today)
+        albums.add(SmartAlbum.TimeRange.ThisWeek)
+        albums.add(SmartAlbum.TimeRange.ThisMonth)
+        albums.add(SmartAlbum.TimeRange.LastYear)
+
+        // Face-based albums (from system tags)
+        val groupPhotoTag = tagDao.getByValue("group_photo")
+        if (groupPhotoTag != null) {
+            val count = tagDao.getTagUsageCount(groupPhotoTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("group_photo", "Group Photos", count))
+            }
+        }
+
+        val selfieTag = tagDao.getByValue("selfie")
+        if (selfieTag != null) {
+            val count = tagDao.getTagUsageCount(selfieTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("selfie", "Selfies", count))
+            }
+        }
+
+        val coupleTag = tagDao.getByValue("couple")
+        if (coupleTag != null) {
+            val count = tagDao.getTagUsageCount(coupleTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("couple", "Couples", count))
+            }
+        }
+
+        // Relationship albums
+        val familyTag = tagDao.getByValue("family")
+        if (familyTag != null) {
+            val count = tagDao.getTagUsageCount(familyTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("family", "Family Moments", count))
+            }
+        }
+
+        val friendTag = tagDao.getByValue("friend")
+        if (friendTag != null) {
+            val count = tagDao.getTagUsageCount(friendTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("friend", "With Friends", count))
+            }
+        }
+
+        val colleagueTag = tagDao.getByValue("colleague")
+        if (colleagueTag != null) {
+            val count = tagDao.getTagUsageCount(colleagueTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("colleague", "Work Events", count))
+            }
+        }
+
+        // Time of day albums
+        val morningTag = tagDao.getByValue("morning")
+        if (morningTag != null) {
+            val count = tagDao.getTagUsageCount(morningTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("morning", "Morning Moments", count))
+            }
+        }
+
+        val eveningTag = tagDao.getByValue("evening")
+        if (eveningTag != null) {
+            val count = tagDao.getTagUsageCount(eveningTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("evening", "Golden Hour", count))
+            }
+        }
+
+        val nightTag = tagDao.getByValue("night")
+        if (nightTag != null) {
+            val count = tagDao.getTagUsageCount(nightTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("night", "Night Life", count))
+            }
+        }
+
+        // Scene albums
+        val outdoorTag = tagDao.getByValue("outdoor")
+        if (outdoorTag != null) {
+            val count = tagDao.getTagUsageCount(outdoorTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("outdoor", "Outdoor Adventures", count))
+            }
+        }
+
+        val indoorTag = tagDao.getByValue("indoor")
+        if (indoorTag != null) {
+            val count = tagDao.getTagUsageCount(indoorTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("indoor", "Indoor Moments", count))
+            }
+        }
+
+        // Special occasions
+        val birthdayTag = tagDao.getByValue("birthday")
+        if (birthdayTag != null) {
+            val count = tagDao.getTagUsageCount(birthdayTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("birthday", "Birthdays", count))
+            }
+        }
+
+        // Quality albums
+        val highResTag = tagDao.getByValue("high_res")
+        if (highResTag != null) {
+            val count = tagDao.getTagUsageCount(highResTag.tagId)
+            if (count > 0) {
+                albums.add(SmartAlbum.Tagged("high_res", "Best Quality", count))
+            }
+        }
+
+        // Person albums
+        val persons = personDao.getAllPersons()
+        persons.forEach { person ->
+            val stats = faceRecognitionRepository.getPersonFaceStats(person.id)
+            if (stats != null && stats.taggedPhotoCount > 0) {
+                albums.add(SmartAlbum.Person(
+                    personId = person.id,
+                    personName = person.name,
+                    imageCount = stats.taggedPhotoCount
+                ))
+            }
+        }
+
+        return albums
+    }
+
+    /**
+     * Get images for a specific smart album
+     */
+    suspend fun getImagesForAlbum(album: SmartAlbum): List<ImageEntity> {
+        return when (album) {
+            is SmartAlbum.TimeRange.Today -> {
+                val startOfDay = getStartOfDay()
+                imageDao.getImagesInRange(startOfDay, System.currentTimeMillis())
+            }
+            is SmartAlbum.TimeRange.ThisWeek -> {
+                val startOfWeek = getStartOfWeek()
+                imageDao.getImagesInRange(startOfWeek, System.currentTimeMillis())
+            }
+            is SmartAlbum.TimeRange.ThisMonth -> {
+                val startOfMonth = getStartOfMonth()
+                imageDao.getImagesInRange(startOfMonth, System.currentTimeMillis())
+            }
+            is SmartAlbum.TimeRange.LastYear -> {
+                val oneYearAgo = System.currentTimeMillis() - (365L * 24 * 60 * 60 * 1000)
+                imageDao.getImagesInRange(oneYearAgo, System.currentTimeMillis())
+            }
+            is SmartAlbum.Tagged -> {
+                val tag = tagDao.getByValue(album.tagValue)
+                if (tag != null) {
+                    val imageIds = imageTagDao.findImagesByTag(tag.tagId, 0.5f)
+                    imageDao.getImagesByIds(imageIds)
+                } else {
+                    emptyList()
+                }
+            }
+            is SmartAlbum.Person -> {
+                faceRecognitionRepository.getImagesForPerson(album.personId)
+            }
+        }
+    }
+
+    private fun getStartOfDay(): Long {
+        return Calendar.getInstance().apply {
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+
+    private fun getStartOfWeek(): Long {
+        return Calendar.getInstance().apply {
+            set(Calendar.DAY_OF_WEEK, firstDayOfWeek)
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+
+    private fun getStartOfMonth(): Long {
+        return Calendar.getInstance().apply {
+            set(Calendar.DAY_OF_MONTH, 1)
+            set(Calendar.HOUR_OF_DAY, 0)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }.timeInMillis
+    }
+}
+
+/**
+ * Smart album types
+ */
+sealed class SmartAlbum {
+    abstract val displayName: String
+    abstract val imageCount: Int
+
+    sealed class TimeRange : SmartAlbum() {
+        data object Today : TimeRange() {
+            override val displayName = "Today"
+            override val imageCount = 0 // Calculated dynamically
+        }
+        data object ThisWeek : TimeRange() {
+            override val displayName = "This Week"
+            override val imageCount = 0
+        }
+        data object ThisMonth : TimeRange() {
+            override val displayName = "This Month"
+            override val imageCount = 0
+        }
+        data object LastYear : TimeRange() {
+            override val displayName = "Last Year"
+            override val imageCount = 0
+        }
+    }
+
+    data class Tagged(
+        val tagValue: String,
+        override val displayName: String,
+        override val imageCount: Int
+    ) : SmartAlbum()
+
+    data class Person(
+        val personId: String,
+        val personName: String,
+        override val imageCount: Int
+    ) : SmartAlbum() {
+        override val displayName = personName
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/modelinventory/Personinventoryviewmodel.kt

@@ -14,6 +14,11 @@ import com.placeholder.sherpai2.data.repository.DetectedFace
 import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
 import com.placeholder.sherpai2.data.repository.PersonFaceStats
 import com.placeholder.sherpai2.domain.repository.ImageRepository
+import com.placeholder.sherpai2.ml.ThresholdStrategy
+import com.placeholder.sherpai2.ml.ImageQuality
+import com.placeholder.sherpai2.ml.DetectionContext
+import com.placeholder.sherpai2.util.DebugFlags
+import com.placeholder.sherpai2.util.DiagnosticLogger
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
@@ -27,13 +32,11 @@ import kotlinx.coroutines.tasks.await
 import javax.inject.Inject
 
 /**
- * PersonInventoryViewModel - Manage trained face models
+ * PersonInventoryViewModel - Enhanced with smart threshold strategy
  *
- * Features:
- * - List all trained persons with stats
- * - Delete models
- * - SCAN LIBRARY to find person in all photos
- * - View sample photos
+ * Toggle diagnostics in DebugFlags.kt:
+ * - ENABLE_FACE_RECOGNITION_LOGGING = true/false
+ * - USE_LIBERAL_THRESHOLDS = true/false
  */
 @HiltViewModel
 class PersonInventoryViewModel @Inject constructor(
@@ -48,13 +51,12 @@ class PersonInventoryViewModel @Inject constructor(
     private val _scanningState = MutableStateFlow<ScanningState>(ScanningState.Idle)
     val scanningState: StateFlow<ScanningState> = _scanningState.asStateFlow()
 
-    // ML Kit face detector
     private val faceDetector by lazy {
         val options = FaceDetectorOptions.Builder()
             .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
             .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
             .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
-            .setMinFaceSize(0.15f)
+            .setMinFaceSize(0.10f)
             .build()
         FaceDetection.getClient(options)
     }
@@ -77,12 +79,14 @@ class PersonInventoryViewModel @Inject constructor(
             val personName: String,
             val progress: Int,
             val total: Int,
-            val facesFound: Int
+            val facesFound: Int,
+            val facesDetected: Int = 0
         ) : ScanningState()
         data class Complete(
             val personName: String,
             val facesFound: Int,
-            val imagesScanned: Int
+            val imagesScanned: Int,
+            val totalFacesDetected: Int = 0
         ) : ScanningState()
     }
 
@@ -90,9 +94,6 @@ class PersonInventoryViewModel @Inject constructor(
         loadPersons()
     }
 
-    /**
-     * Load all trained persons with their stats
-     */
     fun loadPersons() {
         viewModelScope.launch {
             try {
@@ -119,14 +120,11 @@ class PersonInventoryViewModel @Inject constructor(
         }
     }
 
-    /**
-     * Delete a face model
-     */
     fun deletePerson(personId: String, faceModelId: String) {
         viewModelScope.launch {
             try {
                 faceRecognitionRepository.deleteFaceModel(faceModelId)
-                loadPersons() // Refresh list
+                loadPersons()
             } catch (e: Exception) {
                 _uiState.value = InventoryUiState.Error(
                     "Failed to delete: ${e.message}"
@@ -136,21 +134,17 @@ class PersonInventoryViewModel @Inject constructor(
     }
 
     /**
-     * Scan entire photo library for a specific person
-     *
-     * Process:
-     * 1. Get all images from library
-     * 2. For each image:
-     *    - Detect faces using ML Kit
-     *    - Generate embeddings for detected faces
-     *    - Compare to person's face model
-     *    - Create PhotoFaceTagEntity if match found
-     * 3. Update progress throughout
+     * Scan library with SMART threshold selection
      */
     fun scanLibraryForPerson(personId: String, faceModelId: String) {
         viewModelScope.launch {
             try {
-                // Get person name for UI
+                if (DebugFlags.ENABLE_FACE_RECOGNITION_LOGGING) {
+                    DiagnosticLogger.i("=== STARTING LIBRARY SCAN (ENHANCED) ===")
+                    DiagnosticLogger.i("PersonId: $personId")
+                    DiagnosticLogger.i("FaceModelId: $faceModelId")
+                }
+
                 val currentState = _uiState.value
                 val person = if (currentState is InventoryUiState.Success) {
                     currentState.persons.find { it.person.id == personId }?.person
@@ -158,69 +152,118 @@ class PersonInventoryViewModel @Inject constructor(
 
                 val personName = person?.name ?: "Unknown"
 
-                // Get all images from library
+                // Get face model to determine training count
+                val faceModel = faceRecognitionRepository.getFaceModelById(faceModelId)
+                val trainingCount = faceModel?.trainingImageCount ?: 15
+
+                DiagnosticLogger.i("Training count: $trainingCount")
+
                 val allImages = imageRepository.getAllImages().first()
                 val totalImages = allImages.size
 
+                DiagnosticLogger.i("Total images in library: $totalImages")
+
                 _scanningState.value = ScanningState.Scanning(
                     personId = personId,
                     personName = personName,
                     progress = 0,
                     total = totalImages,
-                    facesFound = 0
+                    facesFound = 0,
+                    facesDetected = 0
                 )
 
                 var facesFound = 0
+                var totalFacesDetected = 0
 
-                // Scan each image
                 allImages.forEachIndexed { index, imageWithEverything ->
                     val image = imageWithEverything.image
 
-                    // Detect faces in this image
+                    DiagnosticLogger.d("--- Image ${index + 1}/$totalImages ---")
+                    DiagnosticLogger.d("ImageId: ${image.imageId}")
+
+                    // Detect faces with ML Kit
                     val detectedFaces = detectFacesInImage(image.imageUri)
+                    totalFacesDetected += detectedFaces.size
+
+                    DiagnosticLogger.d("Faces detected: ${detectedFaces.size}")
 
                     if (detectedFaces.isNotEmpty()) {
-                        // Scan this image for the person
+                        // ENHANCED: Calculate image quality
+                        val imageQuality = ThresholdStrategy.estimateImageQuality(
+                            width = image.width,
+                            height = image.height
+                        )
+
+                        // ENHANCED: Estimate detection context
+                        val detectionContext = ThresholdStrategy.estimateDetectionContext(
+                            faceCount = detectedFaces.size,
+                            faceAreaRatio = if (detectedFaces.isNotEmpty()) {
+                                calculateFaceAreaRatio(detectedFaces[0], image.width, image.height)
+                            } else 0f
+                        )
+
+                        // ENHANCED: Get smart threshold
+                        val scanThreshold = if (DebugFlags.USE_LIBERAL_THRESHOLDS) {
+                            ThresholdStrategy.getLiberalThreshold(trainingCount)
+                        } else {
+                            ThresholdStrategy.getOptimalThreshold(
+                                trainingCount = trainingCount,
+                                imageQuality = imageQuality,
+                                detectionContext = detectionContext
+                            )
+                        }
+
+                        DiagnosticLogger.d("Quality: $imageQuality, Context: $detectionContext")
+                        DiagnosticLogger.d("Using threshold: $scanThreshold")
+
+                        // Scan image with smart threshold
                         val tags = faceRecognitionRepository.scanImage(
                             imageId = image.imageId,
                             detectedFaces = detectedFaces,
-                            threshold = 0.6f // Slightly lower threshold for library scanning
+                            threshold = scanThreshold
                         )
 
-                        // Count how many faces matched this person
-                        val matchingTags = tags.filter { tag ->
-                            // Check if this tag belongs to our target person's face model
-                            tag.faceModelId == faceModelId
+                        DiagnosticLogger.d("Tags created: ${tags.size}")
+
+                        tags.forEach { tag ->
+                            DiagnosticLogger.d("  Tag: model=${tag.faceModelId.take(8)}, conf=${String.format("%.3f", tag.confidence)}")
                         }
 
+                        val matchingTags = tags.filter { it.faceModelId == faceModelId }
+                        DiagnosticLogger.d("Matching tags for target: ${matchingTags.size}")
+
                         facesFound += matchingTags.size
                     }
 
-                    // Update progress
                     _scanningState.value = ScanningState.Scanning(
                         personId = personId,
                         personName = personName,
                         progress = index + 1,
                         total = totalImages,
-                        facesFound = facesFound
+                        facesFound = facesFound,
+                        facesDetected = totalFacesDetected
                     )
                 }
 
-                // Scan complete
+                DiagnosticLogger.i("=== SCAN COMPLETE ===")
+                DiagnosticLogger.i("Images scanned: $totalImages")
+                DiagnosticLogger.i("Faces detected: $totalFacesDetected")
+                DiagnosticLogger.i("Faces matched: $facesFound")
+                DiagnosticLogger.i("Hit rate: ${if (totalFacesDetected > 0) (facesFound * 100 / totalFacesDetected) else 0}%")
+
                 _scanningState.value = ScanningState.Complete(
                     personName = personName,
                     facesFound = facesFound,
-                    imagesScanned = totalImages
+                    imagesScanned = totalImages,
+                    totalFacesDetected = totalFacesDetected
                 )
 
-                // Refresh the list to show updated counts
                 loadPersons()
-
-                // Reset scanning state after 3 seconds
                 delay(3000)
                 _scanningState.value = ScanningState.Idle
 
             } catch (e: Exception) {
+                DiagnosticLogger.e("Scan failed", e)
                 _scanningState.value = ScanningState.Idle
                 _uiState.value = InventoryUiState.Error(
                     "Scan failed: ${e.message}"
@@ -229,33 +272,28 @@ class PersonInventoryViewModel @Inject constructor(
         }
     }
 
-    /**
-     * Detect faces in an image using ML Kit
-     *
-     * @param imageUri URI of the image to scan
-     * @return List of detected faces with cropped bitmaps
-     */
     private suspend fun detectFacesInImage(imageUri: String): List<DetectedFace> = withContext(Dispatchers.Default) {
         try {
-            // Load bitmap from URI
             val uri = Uri.parse(imageUri)
             val inputStream = getApplication<Application>().contentResolver.openInputStream(uri)
             val bitmap = BitmapFactory.decodeStream(inputStream)
             inputStream?.close()
 
-            if (bitmap == null) return@withContext emptyList()
+            if (bitmap == null) {
+                DiagnosticLogger.w("Failed to load bitmap from: $imageUri")
+                return@withContext emptyList()
+            }
+
+            DiagnosticLogger.d("Bitmap: ${bitmap.width}x${bitmap.height}")
 
-            // Create ML Kit input image
             val image = InputImage.fromBitmap(bitmap, 0)
-
-            // Detect faces (await the Task)
             val faces = faceDetector.process(image).await()
 
-            // Convert to DetectedFace objects
+            DiagnosticLogger.d("ML Kit found ${faces.size} faces")
+
             faces.mapNotNull { face ->
                 val boundingBox = face.boundingBox
 
-                // Crop face from bitmap with bounds checking
                 val croppedFace = try {
                     val left = boundingBox.left.coerceAtLeast(0)
                     val top = boundingBox.top.coerceAtLeast(0)
@@ -268,6 +306,7 @@ class PersonInventoryViewModel @Inject constructor(
                         null
                     }
                 } catch (e: Exception) {
+                    DiagnosticLogger.e("Face crop failed", e)
                     null
                 }
 
@@ -282,13 +321,24 @@ class PersonInventoryViewModel @Inject constructor(
             }
 
         } catch (e: Exception) {
+            DiagnosticLogger.e("Face detection failed: $imageUri", e)
             emptyList()
         }
     }
 
     /**
-     * Get sample images for a person
+     * Calculate face area ratio (for context detection)
      */
+    private fun calculateFaceAreaRatio(
+        face: DetectedFace,
+        imageWidth: Int,
+        imageHeight: Int
+    ): Float {
+        val faceArea = face.boundingBox.width() * face.boundingBox.height()
+        val imageArea = imageWidth * imageHeight
+        return faceArea.toFloat() / imageArea.toFloat()
+    }
+
     suspend fun getPersonImages(personId: String) =
         faceRecognitionRepository.getImagesForPerson(personId)
 

app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppDestinations.kt

@@ -33,11 +33,11 @@ sealed class AppDestinations(
         description = "Find photos by tag or person"
     )
 
-    data object Tour : AppDestinations(
-        route = AppRoutes.TOUR,
-        icon = Icons.Default.Place,
-        label = "Tour",
-        description = "Browse by location & time"
+    data object Explore : AppDestinations(
+        route = AppRoutes.EXPLORE,
+        icon = Icons.Default.Explore,
+        label = "Explore",
+        description = "Browse smart albums"
     )
 
     // ImageDetail is not in drawer (internal navigation only)
@@ -78,8 +78,8 @@ sealed class AppDestinations(
         description = "Manage photo tags"
     )
 
-    data object Upload : AppDestinations(
-        route = AppRoutes.UPLOAD,
+    data object UTILITIES : AppDestinations(
+        route = AppRoutes.UTILITIES,
         icon = Icons.Default.UploadFile,
         label = "Upload",
         description = "Add new photos"
@@ -104,7 +104,7 @@ sealed class AppDestinations(
 // Photo browsing section
 val photoDestinations = listOf(
     AppDestinations.Search,
-    AppDestinations.Tour
+    AppDestinations.Explore
 )
 
 // Face recognition section
@@ -117,7 +117,7 @@ val faceRecognitionDestinations = listOf(
 // Organization section
 val organizationDestinations = listOf(
     AppDestinations.Tags,
-    AppDestinations.Upload
+    AppDestinations.UTILITIES
 )
 
 // Settings (separate, pinned to bottom)
@@ -135,12 +135,12 @@ val allMainDrawerDestinations = photoDestinations + faceRecognitionDestinations
 fun getDestinationByRoute(route: String?): AppDestinations? {
     return when (route) {
         AppRoutes.SEARCH -> AppDestinations.Search
-        AppRoutes.TOUR -> AppDestinations.Tour
+        AppRoutes.EXPLORE -> AppDestinations.Explore
         AppRoutes.INVENTORY -> AppDestinations.Inventory
         AppRoutes.TRAIN -> AppDestinations.Train
         AppRoutes.MODELS -> AppDestinations.Models
         AppRoutes.TAGS -> AppDestinations.Tags
-        AppRoutes.UPLOAD -> AppDestinations.Upload
+        AppRoutes.UTILITIES -> AppDestinations.UTILITIES
         AppRoutes.SETTINGS -> AppDestinations.Settings
         else -> null
     }

app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppNavHost.kt

@@ -13,25 +13,28 @@ import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.navArgument
 import com.placeholder.sherpai2.ui.devscreens.DummyScreen
+import com.placeholder.sherpai2.ui.album.AlbumViewScreen
+import com.placeholder.sherpai2.ui.explore.ExploreScreen
 import com.placeholder.sherpai2.ui.imagedetail.ImageDetailScreen
 import com.placeholder.sherpai2.ui.modelinventory.PersonInventoryScreen
 import com.placeholder.sherpai2.ui.search.SearchScreen
 import com.placeholder.sherpai2.ui.search.SearchViewModel
-import com.placeholder.sherpai2.ui.tour.TourScreen
-import com.placeholder.sherpai2.ui.tour.TourViewModel
+import com.placeholder.sherpai2.ui.tags.TagManagementScreen
 import com.placeholder.sherpai2.ui.trainingprep.ImageSelectorScreen
 import com.placeholder.sherpai2.ui.trainingprep.ScanResultsScreen
 import com.placeholder.sherpai2.ui.trainingprep.ScanningState
 import com.placeholder.sherpai2.ui.trainingprep.TrainViewModel
 import com.placeholder.sherpai2.ui.trainingprep.TrainingScreen
+import com.placeholder.sherpai2.ui.utilities.PhotoUtilitiesScreen
 import java.net.URLDecoder
 import java.net.URLEncoder
 
 /**
  * AppNavHost - Main navigation graph
+ * UPDATED: Added Explore and Tags screens
  *
  * Complete flow:
- * - Photo browsing (Search, Tour, Detail)
+ * - Photo browsing (Search, Explore, Detail)
  * - Face recognition (Inventory, Train)
  * - Organization (Tags, Upload)
  * - Settings
@@ -68,6 +71,22 @@ fun AppNavHost(
                 onImageClick = { imageUri ->
                     val encodedUri = URLEncoder.encode(imageUri, "UTF-8")
                     navController.navigate("${AppRoutes.IMAGE_DETAIL}/$encodedUri")
+                },
+                onAlbumClick = { tagValue ->
+                    // Navigate to tag-based album
+                    navController.navigate("album/tag/$tagValue")
+                }
+            )
+        }
+
+        /**
+         * EXPLORE SCREEN
+         * Browse smart albums (auto-generated from tags)
+         */
+        composable(AppRoutes.EXPLORE) {
+            ExploreScreen(
+                onAlbumClick = { albumType, albumId ->
+                    navController.navigate("album/$albumType/$albumId")
                 }
             )
         }
@@ -95,13 +114,24 @@ fun AppNavHost(
         }
 
         /**
-         * TOUR SCREEN
-         * Browse photos by location and time
+         * ALBUM VIEW SCREEN
+         * View photos in a specific album (tag, person, or time-based)
          */
-        composable(AppRoutes.TOUR) {
-            val tourViewModel: TourViewModel = hiltViewModel()
-            TourScreen(
-                tourViewModel = tourViewModel,
+        composable(
+            route = "album/{albumType}/{albumId}",
+            arguments = listOf(
+                navArgument("albumType") {
+                    type = NavType.StringType
+                },
+                navArgument("albumId") {
+                    type = NavType.StringType
+                }
+            )
+        ) {
+            AlbumViewScreen(
+                onBack = {
+                    navController.popBackStack()
+                },
                 onImageClick = { imageUri ->
                     val encodedUri = URLEncoder.encode(imageUri, "UTF-8")
                     navController.navigate("${AppRoutes.IMAGE_DETAIL}/$encodedUri")
@@ -139,7 +169,7 @@ fun AppNavHost(
          *
          * Flow:
          * 1. TrainingScreen (select images button)
-         * 2. ImageSelectorScreen (pick 10+ photos)
+         * 2. ImageSelectorScreen (pick 15-50 photos)
          * 3. ScanResultsScreen (validation + name input)
          * 4. Training completes → navigate to Inventory
          */
@@ -215,24 +245,18 @@ fun AppNavHost(
 
         /**
          * TAGS SCREEN
-         * Manage photo tags (placeholder)
+         * Manage photo tags with auto-tagging features
          */
         composable(AppRoutes.TAGS) {
-            DummyScreen(
-                title = "Tags",
-                subtitle = "Organize your photos with tags"
-            )
+            TagManagementScreen()
         }
 
         /**
-         * UPLOAD SCREEN
-         * Import new photos (placeholder)
+         * UTILITIES SCREEN
+         * Photo collection management tools
          */
-        composable(AppRoutes.UPLOAD) {
-            DummyScreen(
-                title = "Upload",
-                subtitle = "Add photos to your library"
-            )
+        composable(AppRoutes.UTILITIES) {
+            PhotoUtilitiesScreen()
         }
 
         // ==========================================

app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppRoutes.kt

@@ -11,22 +11,30 @@ package com.placeholder.sherpai2.ui.navigation
  * - Keeps NavHost decoupled from icons / labels
  */
 object AppRoutes {
-    const val TOUR = "tour"
+    // Photo browsing
     const val SEARCH = "search"
-    const val MODELS = "models"
-    const val INVENTORY = "inv"
-    const val TRAIN = "train"
-    const val TAGS = "tags"
-    const val UPLOAD = "upload"
-    const val SETTINGS = "settings"
+    const val EXPLORE = "explore"
     const val IMAGE_DETAIL = "IMAGE_DETAIL"
 
-    const val CROP_SCREEN = "CROP_SCREEN"
-    const val IMAGE_SELECTOR = "Image Selection"
-    const val TRAINING_SCREEN = "TRAINING_SCREEN"
+    // Face recognition
+    const val INVENTORY = "inv"
+    const val TRAIN = "train"
+    const val MODELS = "models"
 
+    // Organization
+    const val TAGS = "tags"
+    const val UTILITIES = "utilities"  // CHANGED from UPLOAD
+
+    // Settings
+    const val SETTINGS = "settings"
+
+    // Internal training flow screens
+    const val IMAGE_SELECTOR = "Image Selection"
+    const val CROP_SCREEN = "CROP_SCREEN"
+    const val TRAINING_SCREEN = "TRAINING_SCREEN"
     const val ScanResultsScreen = "First Scan Results"
 
-
-    //const val IMAGE_DETAIL = "IMAGE_DETAIL"
+    // Album view
+    const val ALBUM_VIEW = "album/{albumType}/{albumId}"
+    fun albumRoute(albumType: String, albumId: String) = "album/$albumType/$albumId"
 }

app/src/main/java/com/placeholder/sherpai2/ui/presentation/AppDrawerContent.kt

@@ -14,12 +14,12 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.Label
-import androidx.compose.material.icons.automirrored.filled.List
 import androidx.compose.material.icons.filled.*
 import com.placeholder.sherpai2.ui.navigation.AppRoutes
 
 /**
  * Beautiful app drawer with sections, gradient header, and polish
+ * UPDATED: Tour → Explore
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -98,7 +98,7 @@ fun AppDrawerContent(
 
                 val photoItems = listOf(
                     DrawerItem(AppRoutes.SEARCH, "Search", Icons.Default.Search, "Find photos by tag or person"),
-                    DrawerItem(AppRoutes.TOUR, "Tour", Icons.Default.Place, "Browse by location & time")
+                    DrawerItem(AppRoutes.EXPLORE, "Explore", Icons.Default.Explore, "Browse smart albums")
                 )
 
                 photoItems.forEach { item ->
@@ -135,7 +135,7 @@ fun AppDrawerContent(
 
                 val orgItems = listOf(
                     DrawerItem(AppRoutes.TAGS, "Tags", Icons.AutoMirrored.Filled.Label, "Manage photo tags"),
-                    DrawerItem(AppRoutes.UPLOAD, "Upload", Icons.Default.UploadFile, "Add new photos")
+                    DrawerItem(AppRoutes.UTILITIES, "Upload", Icons.Default.UploadFile, "Add new photos")
                 )
 
                 orgItems.forEach { item ->

app/src/main/java/com/placeholder/sherpai2/ui/presentation/MainScreen.kt

@@ -1,32 +1,37 @@
 package com.placeholder.sherpai2.ui.presentation
 
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.navigation.NavController
+import androidx.compose.ui.text.font.FontWeight
 import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import com.placeholder.sherpai2.ui.navigation.AppNavHost
 import com.placeholder.sherpai2.ui.navigation.AppRoutes
 import kotlinx.coroutines.launch
 
+/**
+ * Beautiful main screen with gradient header, dynamic actions, and polish
+ */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun MainScreen() {
     val drawerState = rememberDrawerState(initialValue = DrawerValue.Closed)
     val scope = rememberCoroutineScope()
-
-    // Navigation controller for NavHost
     val navController = rememberNavController()
 
-    // Track current backstack entry to update top bar title dynamically
     val navBackStackEntry by navController.currentBackStackEntryAsState()
     val currentRoute = navBackStackEntry?.destination?.route ?: AppRoutes.SEARCH
 
-    // Drawer content for navigation
     ModalNavigationDrawer(
         drawerState = drawerState,
         drawerContent = {
@@ -37,7 +42,6 @@ fun MainScreen() {
                         drawerState.close()
                         if (route != currentRoute) {
                             navController.navigate(route) {
-                                // Avoid multiple copies of the same destination
                                 launchSingleTop = true
                             }
                         }
@@ -46,17 +50,120 @@ fun MainScreen() {
             )
         },
     ) {
-        // Main scaffold with top bar
         Scaffold(
             topBar = {
                 TopAppBar(
-                    title = { Text(currentRoute.replaceFirstChar { it.uppercase() }) },
-                    navigationIcon = {
-                        IconButton(onClick = { scope.launch { drawerState.open() } }) {
-                            Icon(Icons.Filled.Menu, contentDescription = "Open Drawer")
-                        }
-                    }
+                    title = {
+                        Column {
+                            Text(
+                                text = getScreenTitle(currentRoute),
+                                style = MaterialTheme.typography.titleLarge,
+                                fontWeight = FontWeight.Bold
                             )
+                            getScreenSubtitle(currentRoute)?.let { subtitle ->
+                                Text(
+                                    text = subtitle,
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                )
+                            }
+                        }
+                    },
+                    navigationIcon = {
+                        IconButton(
+                            onClick = { scope.launch { drawerState.open() } }
+                        ) {
+                            Icon(
+                                Icons.Default.Menu,
+                                contentDescription = "Open Menu",
+                                tint = MaterialTheme.colorScheme.primary
+                            )
+                        }
+                    },
+                    actions = {
+                        // Dynamic actions based on current screen
+                        when (currentRoute) {
+                            AppRoutes.SEARCH -> {
+                                IconButton(onClick = { /* TODO: Open filter dialog */ }) {
+                                    Icon(
+                                        Icons.Default.FilterList,
+                                        contentDescription = "Filter",
+                                        tint = MaterialTheme.colorScheme.primary
+                                    )
+                                }
+                            }
+                            AppRoutes.INVENTORY -> {
+                                IconButton(onClick = {
+                                    navController.navigate(AppRoutes.TRAIN)
+                                }) {
+                                    Icon(
+                                        Icons.Default.PersonAdd,
+                                        contentDescription = "Add Person",
+                                        tint = MaterialTheme.colorScheme.primary
+                                    )
+                                }
+                            }
+                            AppRoutes.TAGS -> {
+                                IconButton(onClick = { /* TODO: Add tag */ }) {
+                                    Icon(
+                                        Icons.Default.Add,
+                                        contentDescription = "Add Tag",
+                                        tint = MaterialTheme.colorScheme.primary
+                                    )
+                                }
+                            }
+                        }
+                    },
+                    colors = TopAppBarDefaults.topAppBarColors(
+                        containerColor = MaterialTheme.colorScheme.surface,
+                        titleContentColor = MaterialTheme.colorScheme.onSurface,
+                        navigationIconContentColor = MaterialTheme.colorScheme.primary,
+                        actionIconContentColor = MaterialTheme.colorScheme.primary
+                    )
+                )
+            },
+            floatingActionButton = {
+                // Dynamic FAB based on screen
+                AnimatedVisibility(
+                    visible = shouldShowFab(currentRoute),
+                    enter = slideInVertically(initialOffsetY = { it }) + fadeIn(),
+                    exit = slideOutVertically(targetOffsetY = { it }) + fadeOut()
+                ) {
+                    when (currentRoute) {
+                        AppRoutes.SEARCH -> {
+                            ExtendedFloatingActionButton(
+                                onClick = { /* TODO: Advanced search */ },
+                                icon = {
+                                    Icon(Icons.Default.Tune, "Advanced Search")
+                                },
+                                text = { Text("Filters") },
+                                containerColor = MaterialTheme.colorScheme.primaryContainer,
+                                contentColor = MaterialTheme.colorScheme.onPrimaryContainer
+                            )
+                        }
+                        AppRoutes.TAGS -> {
+                            FloatingActionButton(
+                                onClick = { /* TODO: Add new tag */ },
+                                containerColor = MaterialTheme.colorScheme.primaryContainer,
+                                contentColor = MaterialTheme.colorScheme.onPrimaryContainer
+                            ) {
+                                Icon(Icons.Default.Add, "Add Tag")
+                            }
+                        }
+                        AppRoutes.UTILITIES -> {
+                            ExtendedFloatingActionButton(
+                                onClick = { /* TODO: Select photos */ },
+                                icon = { Icon(Icons.Default.CloudUpload, "Upload") },
+                                text = { Text("Select Photos") },
+                                containerColor = MaterialTheme.colorScheme.primary,
+                                contentColor = MaterialTheme.colorScheme.onPrimary
+                            )
+                        }
+                        else -> {
+                            // No FAB for other screens
+                        }
+                    }
+                }
             }
         ) { paddingValues ->
             AppNavHost(
@@ -66,3 +173,47 @@ fun MainScreen() {
         }
     }
 }
+
+/**
+ * Get human-readable screen title
+ */
+private fun getScreenTitle(route: String): String {
+    return when (route) {
+        AppRoutes.SEARCH -> "Search"
+        AppRoutes.EXPLORE -> "Explore"  // Will be renamed to EXPLORE
+        AppRoutes.INVENTORY -> "People"
+        AppRoutes.TRAIN -> "Train New Person"
+        AppRoutes.MODELS -> "AI Models"
+        AppRoutes.TAGS -> "Tag Management"
+        AppRoutes.UTILITIES -> "Photo Util."
+        AppRoutes.SETTINGS -> "Settings"
+        else -> "SherpAI"
+    }
+}
+
+/**
+ * Get subtitle for screens that need context
+ */
+private fun getScreenSubtitle(route: String): String? {
+    return when (route) {
+        AppRoutes.SEARCH -> "Find photos by tags, people, or date"
+        AppRoutes.EXPLORE -> "Browse your collection"
+        AppRoutes.INVENTORY -> "Trained face models"
+        AppRoutes.TRAIN -> "Add a new person to recognize"
+        AppRoutes.TAGS -> "Organize your photo collection"
+        AppRoutes.UTILITIES -> "Tools for managing collection"
+        else -> null
+    }
+}
+
+/**
+ * Determine if FAB should be shown for current screen
+ */
+private fun shouldShowFab(route: String): Boolean {
+    return when (route) {
+        AppRoutes.SEARCH,
+        AppRoutes.TAGS,
+        AppRoutes.UTILITIES -> true
+        else -> false
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/search/SearchScreen.kt

@@ -1,8 +1,11 @@
 package com.placeholder.sherpai2.ui.search
 
 import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.foundation.lazy.grid.*
+import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
@@ -12,7 +15,6 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
@@ -20,31 +22,41 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.placeholder.sherpai2.ui.search.components.ImageGridItem
 
 /**
- * Beautiful SearchScreen with face tag display
+ * SearchScreen - COMPLETE REDESIGN
  *
- * Polish improvements:
- * - Gradient header
- * - Better stats card
- * - Smooth animations
- * - Enhanced visual hierarchy
+ * Features:
+ * - Near-match search ("low" → "low_res")
+ * - Quick tag filter chips
+ * - Date range filtering
+ * - Clean person-only display
+ * - Simple/Verbose toggle
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun SearchScreen(
     modifier: Modifier = Modifier,
     searchViewModel: SearchViewModel,
-    onImageClick: (String) -> Unit
+    onImageClick: (String) -> Unit,
+    onAlbumClick: (String) -> Unit = {} // For opening album view
 ) {
 
-    var query by remember { mutableStateOf("") }
+    val searchQuery by searchViewModel.searchQuery.collectAsStateWithLifecycle()
+    val activeTagFilters by searchViewModel.activeTagFilters.collectAsStateWithLifecycle()
+    val dateRange by searchViewModel.dateRange.collectAsStateWithLifecycle()
+    val displayMode by searchViewModel.displayMode.collectAsStateWithLifecycle()
+    val systemTags by searchViewModel.systemTags.collectAsStateWithLifecycle()
 
     val images by searchViewModel
-        .searchImagesByTag(query)
+        .searchImages()
         .collectAsStateWithLifecycle(initialValue = emptyList())
 
-    Scaffold(
-        topBar = {
-            // Gradient header
+    Scaffold { paddingValues ->
+        Column(
+            modifier = modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+        ) {
+            // Header with gradient
             Box(
                 modifier = Modifier
                     .fillMaxWidth()
@@ -60,29 +72,15 @@ fun SearchScreen(
                 Column(
                     modifier = Modifier
                         .fillMaxWidth()
-                        .padding(16.dp)
+                        .padding(16.dp),
+                    verticalArrangement = Arrangement.spacedBy(12.dp)
                 ) {
                     // Title
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
-                        horizontalArrangement = Arrangement.spacedBy(12.dp)
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        modifier = Modifier.fillMaxWidth()
                     ) {
-                        Surface(
-                            shape = RoundedCornerShape(12.dp),
-                            color = MaterialTheme.colorScheme.primary,
-                            shadowElevation = 2.dp,
-                            modifier = Modifier.size(48.dp)
-                        ) {
-                            Box(contentAlignment = Alignment.Center) {
-                                Icon(
-                                    Icons.Default.Search,
-                                    contentDescription = null,
-                                    tint = MaterialTheme.colorScheme.onPrimary,
-                                    modifier = Modifier.size(28.dp)
-                                )
-                            }
-                        }
-
                         Column {
                             Text(
                                 text = "Search Photos",
@@ -90,58 +88,176 @@ fun SearchScreen(
                                 fontWeight = FontWeight.Bold
                             )
                             Text(
-                                text = "Find by tag or person",
-                                style = MaterialTheme.typography.bodyMedium,
+                                text = "Near-match • Filters • Smart tags",
+                                style = MaterialTheme.typography.bodySmall,
                                 color = MaterialTheme.colorScheme.onSurfaceVariant
                             )
                         }
+
+                        // Simple/Verbose toggle
+                        IconButton(
+                            onClick = { searchViewModel.toggleDisplayMode() }
+                        ) {
+                            Icon(
+                                imageVector = if (displayMode == DisplayMode.SIMPLE) {
+                                    Icons.Default.ViewList
+                                } else {
+                                    Icons.Default.ViewModule
+                                },
+                                contentDescription = "Toggle view mode",
+                                tint = MaterialTheme.colorScheme.primary
+                            )
+                        }
                     }
 
-                    Spacer(modifier = Modifier.height(16.dp))
-
                     // Search bar
                     OutlinedTextField(
-                        value = query,
-                        onValueChange = { query = it },
-                        label = { Text("Search by tag") },
+                        value = searchQuery,
+                        onValueChange = { searchViewModel.setSearchQuery(it) },
+                        placeholder = { Text("Search... (e.g., 'low', 'gro', 'nig')") },
                         leadingIcon = {
                             Icon(Icons.Default.Search, contentDescription = null)
                         },
                         trailingIcon = {
-                            if (query.isNotEmpty()) {
-                                IconButton(onClick = { query = "" }) {
+                            if (searchQuery.isNotEmpty()) {
+                                IconButton(onClick = { searchViewModel.setSearchQuery("") }) {
                                     Icon(Icons.Default.Clear, contentDescription = "Clear")
                                 }
                             }
                         },
                         modifier = Modifier.fillMaxWidth(),
                         singleLine = true,
-                        shape = RoundedCornerShape(16.dp),
-                        colors = OutlinedTextFieldDefaults.colors(
-                            focusedContainerColor = MaterialTheme.colorScheme.surface,
-                            unfocusedContainerColor = MaterialTheme.colorScheme.surface
-                        )
+                        shape = RoundedCornerShape(16.dp)
                     )
                 }
             }
-        }
-    ) { paddingValues ->
-        Column(
-            modifier = modifier
-                .fillMaxSize()
-                .padding(paddingValues)
-        ) {
-            // Stats bar
-            if (images.isNotEmpty()) {
-                StatsBar(images = images)
-            }
 
-            // Results grid
-            if (images.isEmpty() && query.isBlank()) {
+            // Quick Tag Filters
+            if (systemTags.isNotEmpty()) {
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 16.dp, vertical = 8.dp)
+                ) {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Text(
+                            text = "Quick Filters",
+                            style = MaterialTheme.typography.labelLarge,
+                            fontWeight = FontWeight.Bold,
+                            color = MaterialTheme.colorScheme.primary
+                        )
+                        if (activeTagFilters.isNotEmpty()) {
+                            TextButton(onClick = { searchViewModel.clearTagFilters() }) {
+                                Text("Clear all")
+                            }
+                        }
+                    }
+
+                    LazyRow(
+                        horizontalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        items(systemTags) { tag ->
+                            val isActive = tag.value in activeTagFilters
+                            FilterChip(
+                                selected = isActive,
+                                onClick = { searchViewModel.toggleTagFilter(tag.value) },
+                                label = {
+                                    Row(
+                                        horizontalArrangement = Arrangement.spacedBy(4.dp),
+                                        verticalAlignment = Alignment.CenterVertically
+                                    ) {
+                                        Text(
+                                            text = getTagEmoji(tag.value),
+                                            style = MaterialTheme.typography.bodyMedium
+                                        )
+                                        Text(
+                                            text = tag.value.replace("_", " "),
+                                            style = MaterialTheme.typography.bodySmall
+                                        )
+                                    }
+                                },
+                                leadingIcon = if (isActive) {
+                                    { Icon(Icons.Default.Check, null, Modifier.size(16.dp)) }
+                                } else null
+                            )
+                        }
+                    }
+                }
+            }
+
+            // Date Range Filters
+            LazyRow(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                items(DateRange.entries) { range ->
+                    val isActive = dateRange == range
+                    FilterChip(
+                        selected = isActive,
+                        onClick = { searchViewModel.setDateRange(range) },
+                        label = { Text(range.displayName) },
+                        leadingIcon = if (isActive) {
+                            { Icon(Icons.Default.DateRange, null, Modifier.size(16.dp)) }
+                        } else null
+                    )
+                }
+            }
+
+            HorizontalDivider(
+                modifier = Modifier.padding(horizontal = 16.dp),
+                color = MaterialTheme.colorScheme.outlineVariant
+            )
+
+            // Results
+            if (images.isEmpty() && searchQuery.isBlank() && activeTagFilters.isEmpty()) {
                 EmptySearchState()
-            } else if (images.isEmpty() && query.isNotBlank()) {
-                NoResultsState(query = query)
+            } else if (images.isEmpty()) {
+                NoResultsState(
+                    query = searchQuery,
+                    hasFilters = activeTagFilters.isNotEmpty() || dateRange != DateRange.ALL_TIME
+                )
             } else {
+                Column {
+                    // Results header
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(16.dp),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Text(
+                            text = "${images.size} ${if (images.size == 1) "photo" else "photos"}",
+                            style = MaterialTheme.typography.titleMedium,
+                            fontWeight = FontWeight.Bold
+                        )
+
+                        // View Album button (if search results can be grouped)
+                        if (activeTagFilters.size == 1 || searchQuery.isNotBlank()) {
+                            TextButton(
+                                onClick = {
+                                    val albumTag = activeTagFilters.firstOrNull() ?: searchQuery
+                                    onAlbumClick(albumTag)
+                                }
+                            ) {
+                                Icon(
+                                    Icons.Default.Collections,
+                                    contentDescription = null,
+                                    modifier = Modifier.size(16.dp)
+                                )
+                                Spacer(Modifier.width(4.dp))
+                                Text("View Album")
+                            }
+                        }
+                    }
+
+                    // Photo grid
                     LazyVerticalGrid(
                         columns = GridCells.Adaptive(120.dp),
                         contentPadding = PaddingValues(12.dp),
@@ -153,8 +269,9 @@ fun SearchScreen(
                             items = images,
                             key = { it.image.imageId }
                         ) { imageWithFaceTags ->
-                        ImageWithFaceTagsCard(
+                            PhotoCard(
                                 imageWithFaceTags = imageWithFaceTags,
+                                displayMode = displayMode,
                                 onImageClick = onImageClick
                             )
                         }
@@ -163,94 +280,144 @@ fun SearchScreen(
             }
         }
     }
+}
 
 /**
- * Pretty stats bar showing results summary
+ * Photo card with clean person display
  */
 @Composable
-private fun StatsBar(images: List<ImageWithFaceTags>) {
-    val totalFaces = images.sumOf { it.faceTags.size }
-    val uniquePersons = images.flatMap { it.persons }.distinctBy { it.id }.size
+private fun PhotoCard(
+    imageWithFaceTags: ImageWithFaceTags,
+    displayMode: DisplayMode,
+    onImageClick: (String) -> Unit
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(12.dp),
+        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
+    ) {
+        Column {
+            // Image
+            ImageGridItem(
+                image = imageWithFaceTags.image,
+                onClick = { onImageClick(imageWithFaceTags.image.imageUri) }
+            )
 
+            // Person tags (deduplicated)
+            val uniquePersons = imageWithFaceTags.persons.distinctBy { it.id }
+
+            if (uniquePersons.isNotEmpty()) {
+                when (displayMode) {
+                    DisplayMode.SIMPLE -> {
+                        // SIMPLE: Just names, no icons, no percentages
                         Surface(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(12.dp),
-        color = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.5f),
-        shape = RoundedCornerShape(16.dp),
-        shadowElevation = 2.dp
+                            color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f),
+                            modifier = Modifier.fillMaxWidth()
                         ) {
-        Row(
-            modifier = Modifier.padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceEvenly,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            StatBadge(
-                icon = Icons.Default.Photo,
-                label = "Images",
-                value = images.size.toString()
-            )
-
-            VerticalDivider(
-                modifier = Modifier.height(40.dp),
-                color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
-            )
-
-            StatBadge(
-                icon = Icons.Default.Face,
-                label = "Faces",
-                value = totalFaces.toString()
-            )
-
-            if (uniquePersons > 0) {
-                VerticalDivider(
-                    modifier = Modifier.height(40.dp),
-                    color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
-                )
-
-                StatBadge(
-                    icon = Icons.Default.People,
-                    label = "People",
-                    value = uniquePersons.toString()
+                            Text(
+                                text = uniquePersons
+                                    .take(3)
+                                    .joinToString(", ") { it.name },
+                                style = MaterialTheme.typography.bodySmall,
+                                modifier = Modifier.padding(8.dp),
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis
                             )
                         }
                     }
-    }
-}
-
-@Composable
-private fun StatBadge(
-    icon: androidx.compose.ui.graphics.vector.ImageVector,
-    label: String,
-    value: String
+                    DisplayMode.VERBOSE -> {
+                        // VERBOSE: Person tags + System tags
+                        Surface(
+                            color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f),
+                            modifier = Modifier.fillMaxWidth()
                         ) {
                             Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
+                                modifier = Modifier.padding(8.dp),
                                 verticalArrangement = Arrangement.spacedBy(4.dp)
+                            ) {
+                                // Person tags with confidence
+                                uniquePersons.take(3).forEachIndexed { index, person ->
+                                    Row(
+                                        horizontalArrangement = Arrangement.spacedBy(6.dp),
+                                        verticalAlignment = Alignment.CenterVertically
                                     ) {
                                         Icon(
-            icon,
+                                            Icons.Default.Face,
                                             contentDescription = null,
-            modifier = Modifier.size(24.dp),
+                                            modifier = Modifier.size(14.dp),
                                             tint = MaterialTheme.colorScheme.primary
                                         )
                                         Text(
-            text = value,
-            style = MaterialTheme.typography.titleLarge,
-            fontWeight = FontWeight.Bold,
+                                            text = person.name,
+                                            style = MaterialTheme.typography.bodySmall,
+                                            modifier = Modifier.weight(1f),
+                                            maxLines = 1,
+                                            overflow = TextOverflow.Ellipsis
+                                        )
+                                        // Find matching face tag for confidence
+                                        val matchingTag = imageWithFaceTags.faceTags
+                                            .find { tag ->
+                                                imageWithFaceTags.persons[imageWithFaceTags.faceTags.indexOf(tag)].id == person.id
+                                            }
+                                        if (matchingTag != null) {
+                                            val confidence = (matchingTag.confidence * 100).toInt()
+                                            Text(
+                                                text = "$confidence%",
+                                                style = MaterialTheme.typography.labelSmall,
                                                 color = MaterialTheme.colorScheme.primary
                                             )
+                                        }
+                                    }
+                                }
+
+                                if (uniquePersons.size > 3) {
                                     Text(
-            text = label,
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onSurfaceVariant
+                                        text = "+${uniquePersons.size - 3} more",
+                                        style = MaterialTheme.typography.labelSmall,
+                                        color = MaterialTheme.colorScheme.primary
+                                    )
+                                }
+
+                                // System tags (verbose mode only)
+                                // TODO: Get image tags from ImageWithEverything
+                                // For now, show placeholder
+                                HorizontalDivider(
+                                    modifier = Modifier.padding(vertical = 4.dp),
+                                    color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
+                                )
+
+                                Row(
+                                    horizontalArrangement = Arrangement.spacedBy(4.dp),
+                                    modifier = Modifier.fillMaxWidth()
+                                ) {
+                                    // Example system tags - replace with actual tags from image
+                                    SystemTagChip("indoor")
+                                    SystemTagChip("high_res")
+                                    SystemTagChip("morning")
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun SystemTagChip(tagValue: String) {
+    Surface(
+        shape = RoundedCornerShape(4.dp),
+        color = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.5f)
+    ) {
+        Text(
+            text = tagValue.replace("_", " "),
+            style = MaterialTheme.typography.labelSmall,
+            modifier = Modifier.padding(horizontal = 4.dp, vertical = 2.dp)
         )
     }
 }
 
-/**
- * Empty state when no search query
- */
 @Composable
 private fun EmptySearchState() {
     Box(
@@ -269,12 +436,12 @@ private fun EmptySearchState() {
                 tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.3f)
             )
             Text(
-                text = "Search your photos",
+                text = "Search or filter photos",
                 style = MaterialTheme.typography.titleLarge,
                 fontWeight = FontWeight.Bold
             )
             Text(
-                text = "Enter a tag to find photos",
+                text = "Try searching or tapping quick filters",
                 style = MaterialTheme.typography.bodyMedium,
                 color = MaterialTheme.colorScheme.onSurfaceVariant
             )
@@ -282,11 +449,8 @@ private fun EmptySearchState() {
     }
 }
 
-/**
- * No results state
- */
 @Composable
-private fun NoResultsState(query: String) {
+private fun NoResultsState(query: String, hasFilters: Boolean) {
     Box(
         modifier = Modifier.fillMaxSize(),
         contentAlignment = Alignment.Center
@@ -303,103 +467,50 @@ private fun NoResultsState(query: String) {
                 tint = MaterialTheme.colorScheme.error.copy(alpha = 0.5f)
             )
             Text(
-                text = "No results",
+                text = "No results found",
                 style = MaterialTheme.typography.titleLarge,
                 fontWeight = FontWeight.Bold
             )
+            if (query.isNotBlank()) {
                 Text(
-                text = "No photos found for \"$query\"",
+                    text = "No matches for \"$query\"",
                     style = MaterialTheme.typography.bodyMedium,
                     color = MaterialTheme.colorScheme.onSurfaceVariant
                 )
             }
+            if (hasFilters) {
+                Text(
+                    text = "Try removing some filters",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
     }
 }
 
 /**
- * Beautiful card showing image with face tags
+ * Get emoji for tag type
  */
-@Composable
-private fun ImageWithFaceTagsCard(
-    imageWithFaceTags: ImageWithFaceTags,
-    onImageClick: (String) -> Unit
-) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        shape = RoundedCornerShape(16.dp),
-        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
-    ) {
-        Column(
-            modifier = Modifier.fillMaxWidth()
-        ) {
-            // Image
-            ImageGridItem(
-                image = imageWithFaceTags.image,
-                onClick = { onImageClick(imageWithFaceTags.image.imageId) }
-            )
-
-            // Face tags
-            if (imageWithFaceTags.persons.isNotEmpty()) {
-                Surface(
-                    color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f),
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    Column(
-                        modifier = Modifier.padding(8.dp),
-                        verticalArrangement = Arrangement.spacedBy(4.dp)
-                    ) {
-                        imageWithFaceTags.persons.take(3).forEachIndexed { index, person ->
-                            Row(
-                                horizontalArrangement = Arrangement.spacedBy(6.dp),
-                                verticalAlignment = Alignment.CenterVertically
-                            ) {
-                                Icon(
-                                    Icons.Default.Face,
-                                    contentDescription = null,
-                                    modifier = Modifier.size(16.dp),
-                                    tint = MaterialTheme.colorScheme.primary
-                                )
-                                Text(
-                                    text = person.name,
-                                    style = MaterialTheme.typography.bodySmall,
-                                    fontWeight = FontWeight.Medium,
-                                    maxLines = 1,
-                                    overflow = TextOverflow.Ellipsis,
-                                    modifier = Modifier.weight(1f)
-                                )
-
-                                if (index < imageWithFaceTags.faceTags.size) {
-                                    val confidence = (imageWithFaceTags.faceTags[index].confidence * 100).toInt()
-                                    Surface(
-                                        shape = RoundedCornerShape(8.dp),
-                                        color = if (confidence >= 80) {
-                                            MaterialTheme.colorScheme.primary.copy(alpha = 0.2f)
-                                        } else {
-                                            MaterialTheme.colorScheme.tertiary.copy(alpha = 0.2f)
-                                        }
-                                    ) {
-                                        Text(
-                                            text = "$confidence%",
-                                            style = MaterialTheme.typography.labelSmall,
-                                            modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
-                                            fontWeight = FontWeight.Bold
-                                        )
-                                    }
-                                }
-                            }
-                        }
-
-                        if (imageWithFaceTags.persons.size > 3) {
-                            Text(
-                                text = "+${imageWithFaceTags.persons.size - 3} more",
-                                style = MaterialTheme.typography.labelSmall,
-                                color = MaterialTheme.colorScheme.primary,
-                                fontWeight = FontWeight.Medium
-                            )
-                        }
-                    }
-                }
-            }
-        }
+private fun getTagEmoji(tagValue: String): String {
+    return when (tagValue) {
+        "night" -> "🌙"
+        "morning" -> "🌅"
+        "afternoon" -> "☀️"
+        "evening" -> "🌇"
+        "indoor" -> "🏠"
+        "outdoor" -> "🌲"
+        "group_photo" -> "👥"
+        "selfie" -> "🤳"
+        "couple" -> "💑"
+        "family" -> "👨‍👩‍👧"
+        "friend" -> "🤝"
+        "birthday" -> "🎂"
+        "high_res" -> "⭐"
+        "low_res" -> "📦"
+        "landscape" -> "🖼️"
+        "portrait" -> "📱"
+        "square" -> "⬜"
+        else -> "🏷️"
     }
 }

app/src/main/java/com/placeholder/sherpai2/ui/search/SearchViewModel.kt

@@ -1,47 +1,110 @@
 package com.placeholder.sherpai2.ui.search
 
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.local.dao.TagDao
 import com.placeholder.sherpai2.data.local.entity.ImageEntity
 import com.placeholder.sherpai2.data.local.entity.PersonEntity
 import com.placeholder.sherpai2.data.local.entity.PhotoFaceTagEntity
+import com.placeholder.sherpai2.data.local.entity.TagEntity
 import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
 import com.placeholder.sherpai2.domain.repository.ImageRepository
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import java.util.Calendar
 import javax.inject.Inject
 
 /**
- * SearchViewModel
+ * SearchViewModel - COMPLETE REDESIGN
  *
- * CLEAN IMPLEMENTATION:
- * - Properly handles Flow types
- * - Fetches face tags for each image
- * - Returns combined data structure
+ * Features:
+ * - Near-match search ("low" → "low_res", "gro" → "group_photo")
+ * - Date range filtering
+ * - Quick tag filters
+ * - Clean person-only display
+ * - Simple/Verbose toggle
  */
 @HiltViewModel
 class SearchViewModel @Inject constructor(
     private val imageRepository: ImageRepository,
-    private val faceRecognitionRepository: FaceRecognitionRepository
+    private val faceRecognitionRepository: FaceRecognitionRepository,
+    private val tagDao: TagDao
 ) : ViewModel() {
 
-    /**
-     * Search images by tag with face recognition data.
-     *
-     * RETURNS: Flow<List<ImageWithFaceTags>>
-     * Each image includes its detected faces and person names
-     */
-    fun searchImagesByTag(tag: String): Flow<List<ImageWithFaceTags>> {
-        val imagesFlow = if (tag.isBlank()) {
-            imageRepository.getAllImages()
-        } else {
-            imageRepository.findImagesByTag(tag)
+    // Search query with near-match support
+    private val _searchQuery = MutableStateFlow("")
+    val searchQuery: StateFlow<String> = _searchQuery.asStateFlow()
+
+    // Active tag filters (quick chips)
+    private val _activeTagFilters = MutableStateFlow<Set<String>>(emptySet())
+    val activeTagFilters: StateFlow<Set<String>> = _activeTagFilters.asStateFlow()
+
+    // Date range filter
+    private val _dateRange = MutableStateFlow(DateRange.ALL_TIME)
+    val dateRange: StateFlow<DateRange> = _dateRange.asStateFlow()
+
+    // Display mode (simple = names only, verbose = icons + percentages)
+    private val _displayMode = MutableStateFlow(DisplayMode.SIMPLE)
+    val displayMode: StateFlow<DisplayMode> = _displayMode.asStateFlow()
+
+    // Available system tags for quick filters
+    private val _systemTags = MutableStateFlow<List<TagEntity>>(emptyList())
+    val systemTags: StateFlow<List<TagEntity>> = _systemTags.asStateFlow()
+
+    init {
+        loadSystemTags()
     }
 
-        // Transform Flow to include face recognition data
-        return imagesFlow.map { imagesList ->
-            imagesList.map { imageWithEverything ->
-                // Get face tags with person info for this image
+    /**
+     * Main search flow - combines query, tag filters, and date range
+     */
+    fun searchImages(): Flow<List<ImageWithFaceTags>> {
+        return combine(
+            _searchQuery,
+            _activeTagFilters,
+            _dateRange
+        ) { query, tagFilters, dateRange ->
+            Triple(query, tagFilters, dateRange)
+        }.flatMapLatest { (query, tagFilters, dateRange) ->
+
+            channelFlow {
+                // Get matching tags FIRST (suspend call)
+                val matchingTags = if (query.isNotBlank()) {
+                    findMatchingTags(query)
+                } else {
+                    emptyList()
+                }
+
+                // Get base images
+                val imagesFlow = when {
+                    matchingTags.isNotEmpty() -> {
+                        // Search by all matching tags
+                        combine(matchingTags.map { tag ->
+                            imageRepository.findImagesByTag(tag.value)
+                        }) { results ->
+                            results.flatMap { it }.distinctBy { it.image.imageId }
+                        }
+                    }
+                    tagFilters.isNotEmpty() -> {
+                        // Filter by active tags
+                        combine(tagFilters.map { tagValue ->
+                            imageRepository.findImagesByTag(tagValue)
+                        }) { results ->
+                            results.flatMap { it }.distinctBy { it.image.imageId }
+                        }
+                    }
+                    else -> imageRepository.getAllImages()
+                }
+
+                // Apply date filtering and add face data
+                imagesFlow.collect { imagesList ->
+                    val filtered = imagesList
+                        .filter { imageWithEverything ->
+                            isInDateRange(imageWithEverything.image.capturedAt, dateRange)
+                        }
+                        .map { imageWithEverything ->
+                            // Get face tags with person info
                             val tagsWithPersons = faceRecognitionRepository.getFaceTagsWithPersons(
                                 imageWithEverything.image.imageId
                             )
@@ -52,19 +115,174 @@ class SearchViewModel @Inject constructor(
                                 persons = tagsWithPersons.map { it.second }
                             )
                         }
+                        .sortedByDescending { it.image.capturedAt }
+
+                    send(filtered)
+                }
             }
         }
     }
 
+    /**
+     * Near-match search: "low" matches "low_res", "gro" matches "group_photo"
+     */
+    private suspend fun findMatchingTags(query: String): List<TagEntity> {
+        val normalizedQuery = query.trim().lowercase()
+
+        // Get all system tags
+        val allTags = tagDao.getByType("SYSTEM")
+
+        // Find tags that contain the query or match it closely
+        return allTags.filter { tag ->
+            val tagValue = tag.value.lowercase()
+
+            // Exact match
+            tagValue == normalizedQuery ||
+                    // Contains match
+                    tagValue.contains(normalizedQuery) ||
+                    // Starts with match
+                    tagValue.startsWith(normalizedQuery) ||
+                    // Fuzzy match (remove underscores and compare)
+                    tagValue.replace("_", "").contains(normalizedQuery.replace("_", ""))
+        }.sortedBy { tag ->
+            // Sort by relevance: exact > starts with > contains
+            when {
+                tag.value.lowercase() == normalizedQuery -> 0
+                tag.value.lowercase().startsWith(normalizedQuery) -> 1
+                else -> 2
+            }
+        }
+    }
+
+    /**
+     * Load available system tags for quick filters
+     */
+    private fun loadSystemTags() {
+        viewModelScope.launch {
+            val tags = tagDao.getByType("SYSTEM")
+
+            // Get usage counts for all tags
+            val tagsWithUsage = tags.map { tag ->
+                tag to tagDao.getTagUsageCount(tag.tagId)
+            }
+
+            // Sort by most commonly used
+            val sortedTags = tagsWithUsage
+                .sortedByDescending { (_, usageCount) -> usageCount }
+                .take(12) // Show top 12 most used tags
+                .map { (tag, _) -> tag }
+
+            _systemTags.value = sortedTags
+        }
+    }
+
+    /**
+     * Update search query
+     */
+    fun setSearchQuery(query: String) {
+        _searchQuery.value = query
+    }
+
+    /**
+     * Toggle a tag filter
+     */
+    fun toggleTagFilter(tagValue: String) {
+        _activeTagFilters.value = if (tagValue in _activeTagFilters.value) {
+            _activeTagFilters.value - tagValue
+        } else {
+            _activeTagFilters.value + tagValue
+        }
+    }
+
+    /**
+     * Clear all tag filters
+     */
+    fun clearTagFilters() {
+        _activeTagFilters.value = emptySet()
+    }
+
+    /**
+     * Set date range filter
+     */
+    fun setDateRange(range: DateRange) {
+        _dateRange.value = range
+    }
+
+    /**
+     * Toggle display mode (simple/verbose)
+     */
+    fun toggleDisplayMode() {
+        _displayMode.value = when (_displayMode.value) {
+            DisplayMode.SIMPLE -> DisplayMode.VERBOSE
+            DisplayMode.VERBOSE -> DisplayMode.SIMPLE
+        }
+    }
+
+    /**
+     * Check if timestamp is in date range
+     */
+    private fun isInDateRange(timestamp: Long, range: DateRange): Boolean {
+        return when (range) {
+            DateRange.ALL_TIME -> true
+            DateRange.TODAY -> isToday(timestamp)
+            DateRange.THIS_WEEK -> isThisWeek(timestamp)
+            DateRange.THIS_MONTH -> isThisMonth(timestamp)
+            DateRange.THIS_YEAR -> isThisYear(timestamp)
+        }
+    }
+
+    private fun isToday(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR) &&
+                today.get(Calendar.DAY_OF_YEAR) == date.get(Calendar.DAY_OF_YEAR)
+    }
+
+    private fun isThisWeek(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR) &&
+                today.get(Calendar.WEEK_OF_YEAR) == date.get(Calendar.WEEK_OF_YEAR)
+    }
+
+    private fun isThisMonth(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR) &&
+                today.get(Calendar.MONTH) == date.get(Calendar.MONTH)
+    }
+
+    private fun isThisYear(timestamp: Long): Boolean {
+        val today = Calendar.getInstance()
+        val date = Calendar.getInstance().apply { timeInMillis = timestamp }
+        return today.get(Calendar.YEAR) == date.get(Calendar.YEAR)
+    }
+}
+
 /**
  * Data class containing image with face recognition data
- *
- * @property image The image entity
- * @property faceTags Face tags detected in this image
- * @property persons Person entities (parallel to faceTags)
  */
 data class ImageWithFaceTags(
     val image: ImageEntity,
     val faceTags: List<PhotoFaceTagEntity>,
     val persons: List<PersonEntity>
 )
+
+/**
+ * Date range filters
+ */
+enum class DateRange(val displayName: String) {
+    ALL_TIME("All Time"),
+    TODAY("Today"),
+    THIS_WEEK("This Week"),
+    THIS_MONTH("This Month"),
+    THIS_YEAR("This Year")
+}
+
+/**
+ * Display modes for photo tags
+ */
+enum class DisplayMode {
+    SIMPLE,    // Just person names
+    VERBOSE    // Names + icons + confidence percentages
+}

app/src/main/java/com/placeholder/sherpai2/ui/tags/Tagmanagementscreen.kt

@@ -0,0 +1,624 @@
+package com.placeholder.sherpai2.ui.tags
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import com.placeholder.sherpai2.data.local.entity.TagWithUsage
+
+@Composable
+fun TagManagementScreen(
+    viewModel: TagManagementViewModel = hiltViewModel()
+) {
+    val uiState by viewModel.uiState.collectAsState()
+    val scanningState by viewModel.scanningState.collectAsState()
+
+    var showAddTagDialog by remember { mutableStateOf(false) }
+    var showScanMenu by remember { mutableStateOf(false) }
+    var searchQuery by remember { mutableStateOf("") }
+
+    Scaffold(
+        floatingActionButton = {
+            // Single extended FAB with dropdown menu
+            var showMenu by remember { mutableStateOf(false) }
+
+            Column(
+                horizontalAlignment = Alignment.End,
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                // Dropdown menu for scan options
+                if (showMenu) {
+                    Card(
+                        modifier = Modifier.width(180.dp),
+                        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
+                    ) {
+                        Column {
+                            ListItem(
+                                headlineContent = { Text("Scan All", style = MaterialTheme.typography.bodyMedium) },
+                                leadingContent = {
+                                    Icon(
+                                        Icons.Default.AutoFixHigh,
+                                        null,
+                                        tint = MaterialTheme.colorScheme.primary,
+                                        modifier = Modifier.size(20.dp)
+                                    )
+                                },
+                                modifier = Modifier.clickable {
+                                    viewModel.scanForAllTags()
+                                    showMenu = false
+                                }
+                            )
+                            ListItem(
+                                headlineContent = { Text("Base Tags", style = MaterialTheme.typography.bodyMedium) },
+                                leadingContent = {
+                                    Icon(
+                                        Icons.Default.PhotoCamera,
+                                        null,
+                                        tint = MaterialTheme.colorScheme.primary,
+                                        modifier = Modifier.size(20.dp)
+                                    )
+                                },
+                                modifier = Modifier.clickable {
+                                    viewModel.scanForBaseTags()
+                                    showMenu = false
+                                }
+                            )
+                            ListItem(
+                                headlineContent = { Text("Relationships", style = MaterialTheme.typography.bodyMedium) },
+                                leadingContent = {
+                                    Icon(
+                                        Icons.Default.People,
+                                        null,
+                                        tint = MaterialTheme.colorScheme.primary,
+                                        modifier = Modifier.size(20.dp)
+                                    )
+                                },
+                                modifier = Modifier.clickable {
+                                    viewModel.scanForRelationshipTags()
+                                    showMenu = false
+                                }
+                            )
+                            ListItem(
+                                headlineContent = { Text("Birthdays", style = MaterialTheme.typography.bodyMedium) },
+                                leadingContent = {
+                                    Icon(
+                                        Icons.Default.Cake,
+                                        null,
+                                        tint = MaterialTheme.colorScheme.primary,
+                                        modifier = Modifier.size(20.dp)
+                                    )
+                                },
+                                modifier = Modifier.clickable {
+                                    viewModel.scanForBirthdayTags()
+                                    showMenu = false
+                                }
+                            )
+                        }
+                    }
+                }
+
+                // Main FAB
+                ExtendedFloatingActionButton(
+                    onClick = { showMenu = !showMenu },
+                    icon = {
+                        Icon(
+                            if (showMenu) Icons.Default.Close else Icons.Default.AutoFixHigh,
+                            "Scan"
+                        )
+                    },
+                    text = { Text(if (showMenu) "Close" else "Scan Tags") }
+                )
+            }
+        }
+    ) { paddingValues ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+        ) {
+            // Stats Bar
+            StatsBar(uiState)
+
+            // Search Bar
+            SearchBar(
+                searchQuery = searchQuery,
+                onSearchChange = {
+                    searchQuery = it
+                    viewModel.searchTags(it)
+                }
+            )
+
+            // Scanning Progress
+            AnimatedVisibility(
+                visible = scanningState !is TagManagementViewModel.TagScanningState.Idle,
+                enter = expandVertically() + fadeIn(),
+                exit = shrinkVertically() + fadeOut()
+            ) {
+                ScanningProgress(scanningState, viewModel)
+            }
+
+            // Tag List
+            when (val state = uiState) {
+                is TagManagementViewModel.TagUiState.Loading -> {
+                    Box(
+                        modifier = Modifier.fillMaxSize(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        CircularProgressIndicator()
+                    }
+                }
+                is TagManagementViewModel.TagUiState.Success -> {
+                    TagList(
+                        tags = state.tags,
+                        onDeleteTag = { viewModel.deleteTag(it) }
+                    )
+                }
+                is TagManagementViewModel.TagUiState.Error -> {
+                    Box(
+                        modifier = Modifier.fillMaxSize(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        Text(
+                            text = state.message,
+                            color = MaterialTheme.colorScheme.error
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    // Add Tag Dialog
+    if (showAddTagDialog) {
+        AddTagDialog(
+            onDismiss = { showAddTagDialog = false },
+            onConfirm = { tagName ->
+                viewModel.createUserTag(tagName)
+                showAddTagDialog = false
+            }
+        )
+    }
+
+    // Scan Menu
+    if (showScanMenu) {
+        ScanMenuDialog(
+            onDismiss = { showScanMenu = false },
+            onScanSelected = { scanType ->
+                when (scanType) {
+                    TagManagementViewModel.ScanType.BASE_TAGS -> viewModel.scanForBaseTags()
+                    TagManagementViewModel.ScanType.RELATIONSHIP_TAGS -> viewModel.scanForRelationshipTags()
+                    TagManagementViewModel.ScanType.BIRTHDAY_TAGS -> viewModel.scanForBirthdayTags()
+                    TagManagementViewModel.ScanType.SCENE_TAGS -> viewModel.scanForSceneTags()
+                    TagManagementViewModel.ScanType.ALL -> viewModel.scanForAllTags()
+                }
+                showScanMenu = false
+            }
+        )
+    }
+}
+
+@Composable
+private fun StatsBar(uiState: TagManagementViewModel.TagUiState) {
+    if (uiState is TagManagementViewModel.TagUiState.Success) {
+        Card(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.primaryContainer
+            )
+        ) {
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp),
+                horizontalArrangement = Arrangement.SpaceAround
+            ) {
+                StatItem("Total", uiState.totalTags.toString(), Icons.Default.Label)
+                StatItem("System", uiState.systemTags.toString(), Icons.Default.AutoAwesome)
+                StatItem("User", uiState.userTags.toString(), Icons.Default.PersonOutline)
+            }
+        }
+    }
+}
+
+@Composable
+private fun StatItem(label: String, value: String, icon: ImageVector) {
+    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.primary,
+            modifier = Modifier.size(24.dp)
+        )
+        Spacer(modifier = Modifier.height(4.dp))
+        Text(
+            text = value,
+            style = MaterialTheme.typography.headlineSmall,
+            fontWeight = FontWeight.Bold
+        )
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+    }
+}
+
+@Composable
+private fun SearchBar(
+    searchQuery: String,
+    onSearchChange: (String) -> Unit
+) {
+    OutlinedTextField(
+        value = searchQuery,
+        onValueChange = onSearchChange,
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp),
+        placeholder = { Text("Search tags...") },
+        leadingIcon = { Icon(Icons.Default.Search, "Search") },
+        trailingIcon = {
+            if (searchQuery.isNotEmpty()) {
+                IconButton(onClick = { onSearchChange("") }) {
+                    Icon(Icons.Default.Clear, "Clear")
+                }
+            }
+        },
+        singleLine = true
+    )
+}
+
+@Composable
+private fun ScanningProgress(
+    scanningState: TagManagementViewModel.TagScanningState,
+    viewModel: TagManagementViewModel
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(16.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.secondaryContainer
+        )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            when (scanningState) {
+                is TagManagementViewModel.TagScanningState.Scanning -> {
+                    Text(
+                        text = "Scanning: ${scanningState.scanType.name.replace("_", " ")}",
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold
+                    )
+                    Spacer(modifier = Modifier.height(8.dp))
+                    LinearProgressIndicator(
+                        progress = { scanningState.progress.toFloat() / scanningState.total.toFloat() },
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    Spacer(modifier = Modifier.height(4.dp))
+                    Text(
+                        text = "${scanningState.progress} / ${scanningState.total} images",
+                        style = MaterialTheme.typography.bodySmall
+                    )
+                    Text(
+                        text = "Tags applied: ${scanningState.tagsApplied}",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+                is TagManagementViewModel.TagScanningState.Complete -> {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Column {
+                            Text(
+                                text = "✓ Scan Complete",
+                                style = MaterialTheme.typography.titleMedium,
+                                fontWeight = FontWeight.Bold,
+                                color = MaterialTheme.colorScheme.primary
+                            )
+                            Text(
+                                text = "${scanningState.tagsApplied} tags applied to ${scanningState.imagesProcessed} images",
+                                style = MaterialTheme.typography.bodySmall
+                            )
+                        }
+                        IconButton(onClick = { viewModel.resetScanningState() }) {
+                            Icon(Icons.Default.Close, "Close")
+                        }
+                    }
+                }
+                is TagManagementViewModel.TagScanningState.Error -> {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Text(
+                            text = "Error: ${scanningState.message}",
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.error
+                        )
+                        IconButton(onClick = { viewModel.resetScanningState() }) {
+                            Icon(Icons.Default.Close, "Close")
+                        }
+                    }
+                }
+                else -> { /* Idle - don't show */ }
+            }
+        }
+    }
+}
+
+@Composable
+private fun TagList(
+    tags: List<TagWithUsage>,
+    onDeleteTag: (String) -> Unit
+) {
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        contentPadding = PaddingValues(16.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp)
+    ) {
+        items(tags, key = { it.tagId }) { tag ->
+            TagListItem(tag, onDeleteTag)
+        }
+    }
+}
+
+@Composable
+private fun TagListItem(
+    tag: TagWithUsage,
+    onDeleteTag: (String) -> Unit
+) {
+    var showDeleteConfirm by remember { mutableStateOf(false) }
+
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        onClick = { /* TODO: Navigate to images with this tag */ }
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(12.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                // Tag type icon
+                Icon(
+                    imageVector = if (tag.type == "SYSTEM") Icons.Default.AutoAwesome else Icons.Default.Label,
+                    contentDescription = null,
+                    tint = if (tag.type == "SYSTEM")
+                        MaterialTheme.colorScheme.secondary
+                    else
+                        MaterialTheme.colorScheme.primary
+                )
+
+                Column {
+                    Text(
+                        text = tag.value,
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Medium
+                    )
+                    Text(
+                        text = if (tag.type == "SYSTEM") "System tag" else "User tag",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+            }
+
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                // Usage count badge
+                Surface(
+                    shape = RoundedCornerShape(12.dp),
+                    color = MaterialTheme.colorScheme.primaryContainer
+                ) {
+                    Text(
+                        text = tag.usageCount.toString(),
+                        modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
+                        style = MaterialTheme.typography.labelMedium,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.onPrimaryContainer
+                    )
+                }
+
+                // Delete button (only for user tags)
+                if (tag.type == "GENERIC") {
+                    IconButton(onClick = { showDeleteConfirm = true }) {
+                        Icon(
+                            Icons.Default.Delete,
+                            contentDescription = "Delete tag",
+                            tint = MaterialTheme.colorScheme.error
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    if (showDeleteConfirm) {
+        AlertDialog(
+            onDismissRequest = { showDeleteConfirm = false },
+            title = { Text("Delete Tag?") },
+            text = { Text("Are you sure you want to delete '${tag.value}'? This will remove it from ${tag.usageCount} images.") },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        onDeleteTag(tag.tagId)
+                        showDeleteConfirm = false
+                    }
+                ) {
+                    Text("Delete", color = MaterialTheme.colorScheme.error)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showDeleteConfirm = false }) {
+                    Text("Cancel")
+                }
+            }
+        )
+    }
+}
+
+@Composable
+private fun AddTagDialog(
+    onDismiss: () -> Unit,
+    onConfirm: (String) -> Unit
+) {
+    var tagName by remember { mutableStateOf("") }
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text("Add New Tag") },
+        text = {
+            OutlinedTextField(
+                value = tagName,
+                onValueChange = { tagName = it },
+                label = { Text("Tag name") },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth()
+            )
+        },
+        confirmButton = {
+            TextButton(
+                onClick = { onConfirm(tagName) },
+                enabled = tagName.isNotBlank()
+            ) {
+                Text("Add")
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text("Cancel")
+            }
+        }
+    )
+}
+
+@Composable
+private fun ScanMenuDialog(
+    onDismiss: () -> Unit,
+    onScanSelected: (TagManagementViewModel.ScanType) -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text("Scan for Tags") },
+        text = {
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                ScanOption(
+                    title = "Base Tags",
+                    description = "Face count, orientation, time, quality",
+                    icon = Icons.Default.PhotoCamera,
+                    onClick = { onScanSelected(TagManagementViewModel.ScanType.BASE_TAGS) }
+                )
+                ScanOption(
+                    title = "Relationship Tags",
+                    description = "Family, friends, colleagues",
+                    icon = Icons.Default.People,
+                    onClick = { onScanSelected(TagManagementViewModel.ScanType.RELATIONSHIP_TAGS) }
+                )
+                ScanOption(
+                    title = "Birthday Tags",
+                    description = "Photos near birthdays",
+                    icon = Icons.Default.Cake,
+                    onClick = { onScanSelected(TagManagementViewModel.ScanType.BIRTHDAY_TAGS) }
+                )
+                ScanOption(
+                    title = "Scene Tags",
+                    description = "Indoor/outdoor detection",
+                    icon = Icons.Default.Landscape,
+                    onClick = { onScanSelected(TagManagementViewModel.ScanType.SCENE_TAGS) }
+                )
+                Divider()
+                ScanOption(
+                    title = "Scan All",
+                    description = "Run all scans",
+                    icon = Icons.Default.AutoFixHigh,
+                    onClick = { onScanSelected(TagManagementViewModel.ScanType.ALL) }
+                )
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) {
+                Text("Cancel")
+            }
+        }
+    )
+}
+
+@Composable
+private fun ScanOption(
+    title: String,
+    description: String,
+    icon: ImageVector,
+    onClick: () -> Unit
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant
+        )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(32.dp)
+            )
+            Column {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Medium
+                )
+                Text(
+                    text = description,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/tags/Tagmanagementviewmodel.kt

@@ -0,0 +1,398 @@
+package com.placeholder.sherpai2.ui.tags
+
+import android.app.Application
+import android.graphics.BitmapFactory
+import android.net.Uri
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.face.FaceDetection
+import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.placeholder.sherpai2.data.local.dao.ImageTagDao
+import com.placeholder.sherpai2.data.local.dao.TagDao
+import com.placeholder.sherpai2.data.local.entity.TagEntity
+import com.placeholder.sherpai2.data.local.entity.TagWithUsage
+import com.placeholder.sherpai2.data.repository.DetectedFace
+import com.placeholder.sherpai2.data.service.AutoTaggingService
+import com.placeholder.sherpai2.domain.repository.ImageRepository
+import com.placeholder.sherpai2.util.DiagnosticLogger
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.tasks.await
+import javax.inject.Inject
+
+@HiltViewModel
+class TagManagementViewModel @Inject constructor(
+    application: Application,
+    private val tagDao: TagDao,
+    private val imageTagDao: ImageTagDao,
+    private val imageRepository: ImageRepository,
+    private val autoTaggingService: AutoTaggingService
+) : AndroidViewModel(application) {
+
+    private val _uiState = MutableStateFlow<TagUiState>(TagUiState.Loading)
+    val uiState: StateFlow<TagUiState> = _uiState.asStateFlow()
+
+    private val _scanningState = MutableStateFlow<TagScanningState>(TagScanningState.Idle)
+    val scanningState: StateFlow<TagScanningState> = _scanningState.asStateFlow()
+
+    private val faceDetector by lazy {
+        val options = FaceDetectorOptions.Builder()
+            .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+            .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
+            .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
+            .setMinFaceSize(0.10f)
+            .build()
+        FaceDetection.getClient(options)
+    }
+
+    sealed class TagUiState {
+        object Loading : TagUiState()
+        data class Success(
+            val tags: List<TagWithUsage>,
+            val totalTags: Int,
+            val systemTags: Int,
+            val userTags: Int
+        ) : TagUiState()
+        data class Error(val message: String) : TagUiState()
+    }
+
+    sealed class TagScanningState {
+        object Idle : TagScanningState()
+        data class Scanning(
+            val scanType: ScanType,
+            val progress: Int,
+            val total: Int,
+            val tagsApplied: Int,
+            val currentImage: String = ""
+        ) : TagScanningState()
+        data class Complete(
+            val scanType: ScanType,
+            val imagesProcessed: Int,
+            val tagsApplied: Int,
+            val newTagsCreated: Int = 0
+        ) : TagScanningState()
+        data class Error(val message: String) : TagScanningState()
+    }
+
+    enum class ScanType {
+        BASE_TAGS,          // Face count, orientation, resolution, time-of-day
+        RELATIONSHIP_TAGS,  // Family, friend, colleague from person entities
+        BIRTHDAY_TAGS,      // Birthday tags for DOB matches
+        SCENE_TAGS,         // Indoor/outdoor estimation
+        ALL                 // Run all scans
+    }
+
+    init {
+        loadTags()
+    }
+
+    fun loadTags() {
+        viewModelScope.launch {
+            try {
+                _uiState.value = TagUiState.Loading
+
+                val tagsWithUsage = tagDao.getMostUsedTags(1000) // Get all tags
+                val systemTags = tagsWithUsage.count { it.type == "SYSTEM" }
+                val userTags = tagsWithUsage.count { it.type == "GENERIC" }
+
+                _uiState.value = TagUiState.Success(
+                    tags = tagsWithUsage,
+                    totalTags = tagsWithUsage.size,
+                    systemTags = systemTags,
+                    userTags = userTags
+                )
+
+            } catch (e: Exception) {
+                _uiState.value = TagUiState.Error(
+                    e.message ?: "Failed to load tags"
+                )
+            }
+        }
+    }
+
+    fun createUserTag(tagName: String) {
+        viewModelScope.launch {
+            try {
+                val trimmedName = tagName.trim().lowercase()
+                if (trimmedName.isEmpty()) {
+                    _uiState.value = TagUiState.Error("Tag name cannot be empty")
+                    return@launch
+                }
+
+                // Check if tag already exists
+                val existing = tagDao.getByValue(trimmedName)
+                if (existing != null) {
+                    _uiState.value = TagUiState.Error("Tag '$trimmedName' already exists")
+                    return@launch
+                }
+
+                val newTag = TagEntity.createUserTag(trimmedName)
+                tagDao.insert(newTag)
+
+                loadTags()
+            } catch (e: Exception) {
+                _uiState.value = TagUiState.Error(
+                    "Failed to create tag: ${e.message}"
+                )
+            }
+        }
+    }
+
+    fun deleteTag(tagId: String) {
+        viewModelScope.launch {
+            try {
+                tagDao.delete(tagId)
+                loadTags()
+            } catch (e: Exception) {
+                _uiState.value = TagUiState.Error(
+                    "Failed to delete tag: ${e.message}"
+                )
+            }
+        }
+    }
+
+    fun searchTags(query: String) {
+        viewModelScope.launch {
+            try {
+                val results = if (query.isBlank()) {
+                    tagDao.getMostUsedTags(1000)
+                } else {
+                    tagDao.searchTagsWithUsage(query, 100)
+                }
+
+                val systemTags = results.count { it.type == "SYSTEM" }
+                val userTags = results.count { it.type == "GENERIC" }
+
+                _uiState.value = TagUiState.Success(
+                    tags = results,
+                    totalTags = results.size,
+                    systemTags = systemTags,
+                    userTags = userTags
+                )
+            } catch (e: Exception) {
+                _uiState.value = TagUiState.Error("Search failed: ${e.message}")
+            }
+        }
+    }
+
+    // ======================
+    // AUTO-TAGGING SCANS
+    // ======================
+
+    /**
+     * Scan library for base tags (face count, orientation, time, quality, scene)
+     */
+    fun scanForBaseTags() {
+        performScan(ScanType.BASE_TAGS)
+    }
+
+    /**
+     * Scan for relationship tags (family, friend, colleague)
+     */
+    fun scanForRelationshipTags() {
+        performScan(ScanType.RELATIONSHIP_TAGS)
+    }
+
+    /**
+     * Scan for birthday tags
+     */
+    fun scanForBirthdayTags() {
+        performScan(ScanType.BIRTHDAY_TAGS)
+    }
+
+    /**
+     * Scan for scene tags (indoor/outdoor)
+     */
+    fun scanForSceneTags() {
+        performScan(ScanType.SCENE_TAGS)
+    }
+
+    /**
+     * Scan for ALL tags
+     */
+    fun scanForAllTags() {
+        performScan(ScanType.ALL)
+    }
+
+    private fun performScan(scanType: ScanType) {
+        viewModelScope.launch {
+            try {
+                DiagnosticLogger.i("=== STARTING TAG SCAN: $scanType ===")
+
+                _scanningState.value = TagScanningState.Scanning(
+                    scanType = scanType,
+                    progress = 0,
+                    total = 0,
+                    tagsApplied = 0
+                )
+
+                val allImages = imageRepository.getAllImages().first()
+                var tagsApplied = 0
+                var newTagsCreated = 0
+
+                DiagnosticLogger.i("Processing ${allImages.size} images")
+
+                allImages.forEachIndexed { index, imageWithEverything ->
+                    val image = imageWithEverything.image
+
+                    _scanningState.value = TagScanningState.Scanning(
+                        scanType = scanType,
+                        progress = index + 1,
+                        total = allImages.size,
+                        tagsApplied = tagsApplied,
+                        currentImage = image.imageId.take(8)
+                    )
+
+                    when (scanType) {
+                        ScanType.BASE_TAGS -> {
+                            tagsApplied += scanImageForBaseTags(image.imageUri, image)
+                        }
+                        ScanType.SCENE_TAGS -> {
+                            tagsApplied += scanImageForSceneTags(image.imageUri, image)
+                        }
+                        ScanType.RELATIONSHIP_TAGS -> {
+                            // Handled at person level, not per-image
+                        }
+                        ScanType.BIRTHDAY_TAGS -> {
+                            // Handled at person level, not per-image
+                        }
+                        ScanType.ALL -> {
+                            tagsApplied += scanImageForBaseTags(image.imageUri, image)
+                            tagsApplied += scanImageForSceneTags(image.imageUri, image)
+                        }
+                    }
+                }
+
+                // Handle person-level scans
+                if (scanType == ScanType.RELATIONSHIP_TAGS || scanType == ScanType.ALL) {
+                    DiagnosticLogger.i("Scanning relationship tags...")
+                    tagsApplied += autoTaggingService.autoTagAllRelationships()
+                }
+
+                if (scanType == ScanType.BIRTHDAY_TAGS || scanType == ScanType.ALL) {
+                    DiagnosticLogger.i("Scanning birthday tags...")
+                    tagsApplied += autoTaggingService.autoTagAllBirthdays(daysRange = 3)
+                }
+
+                DiagnosticLogger.i("=== SCAN COMPLETE ===")
+                DiagnosticLogger.i("Images processed: ${allImages.size}")
+                DiagnosticLogger.i("Tags applied: $tagsApplied")
+
+                _scanningState.value = TagScanningState.Complete(
+                    scanType = scanType,
+                    imagesProcessed = allImages.size,
+                    tagsApplied = tagsApplied,
+                    newTagsCreated = newTagsCreated
+                )
+
+                loadTags()
+
+            } catch (e: Exception) {
+                DiagnosticLogger.e("Scan failed", e)
+                _scanningState.value = TagScanningState.Error(
+                    "Scan failed: ${e.message}"
+                )
+            }
+        }
+    }
+
+    private suspend fun scanImageForBaseTags(
+        imageUri: String,
+        image: com.placeholder.sherpai2.data.local.entity.ImageEntity
+    ): Int = withContext(Dispatchers.Default) {
+        try {
+            val uri = Uri.parse(imageUri)
+            val inputStream = getApplication<Application>().contentResolver.openInputStream(uri)
+            val bitmap = BitmapFactory.decodeStream(inputStream)
+            inputStream?.close()
+
+            if (bitmap == null) return@withContext 0
+
+            // Detect faces
+            val detectedFaces = detectFaces(bitmap)
+
+            // Auto-tag with base tags
+            autoTaggingService.autoTagImage(image, bitmap, detectedFaces)
+
+        } catch (e: Exception) {
+            DiagnosticLogger.e("Base tag scan failed for $imageUri", e)
+            0
+        }
+    }
+
+    private suspend fun scanImageForSceneTags(
+        imageUri: String,
+        image: com.placeholder.sherpai2.data.local.entity.ImageEntity
+    ): Int = withContext(Dispatchers.Default) {
+        try {
+            val uri = Uri.parse(imageUri)
+            val inputStream = getApplication<Application>().contentResolver.openInputStream(uri)
+            val bitmap = BitmapFactory.decodeStream(inputStream)
+            inputStream?.close()
+
+            if (bitmap == null) return@withContext 0
+
+            // Only auto-tag scene tags (indoor/outdoor already included in autoTagImage)
+            // This is a subset of base tags, so we don't need separate logic
+            0
+
+        } catch (e: Exception) {
+            DiagnosticLogger.e("Scene tag scan failed for $imageUri", e)
+            0
+        }
+    }
+
+    private suspend fun detectFaces(bitmap: android.graphics.Bitmap): List<DetectedFace> = withContext(Dispatchers.Default) {
+        try {
+            val image = InputImage.fromBitmap(bitmap, 0)
+            val faces = faceDetector.process(image).await()
+
+            faces.mapNotNull { face ->
+                val boundingBox = face.boundingBox
+
+                val croppedFace = try {
+                    val left = boundingBox.left.coerceAtLeast(0)
+                    val top = boundingBox.top.coerceAtLeast(0)
+                    val width = boundingBox.width().coerceAtMost(bitmap.width - left)
+                    val height = boundingBox.height().coerceAtMost(bitmap.height - top)
+
+                    if (width > 0 && height > 0) {
+                        android.graphics.Bitmap.createBitmap(bitmap, left, top, width, height)
+                    } else {
+                        null
+                    }
+                } catch (e: Exception) {
+                    null
+                }
+
+                if (croppedFace != null) {
+                    DetectedFace(
+                        croppedBitmap = croppedFace,
+                        boundingBox = boundingBox
+                    )
+                } else {
+                    null
+                }
+            }
+
+        } catch (e: Exception) {
+            emptyList()
+        }
+    }
+
+    fun resetScanningState() {
+        _scanningState.value = TagScanningState.Idle
+    }
+
+    override fun onCleared() {
+        super.onCleared()
+        faceDetector.close()
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/FacePickerScreen.kt

@@ -41,6 +41,7 @@ fun FacePickerScreen(
             // from the Bitmap scale to the UI View scale.
             Canvas(modifier = Modifier.fillMaxSize().clickable { /* Handle general tap */ }) {
                 // Implementation of coordinate mapping goes here
+                // TODO implement coordinate mapping
             }
 
             // Simplified: Just show the options as a list of crops if Canvas mapping is too complex for now

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Facedetectionhelper.kt

@@ -8,19 +8,29 @@ import android.net.Uri
 import com.google.mlkit.vision.common.InputImage
 import com.google.mlkit.vision.face.FaceDetection
 import com.google.mlkit.vision.face.FaceDetectorOptions
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.tasks.await
+import kotlinx.coroutines.withContext
 import java.io.InputStream
 
 /**
- * Helper class for detecting faces in images using ML Kit Face Detection
+ * FIXED FaceDetectionHelper with parallel processing
+ *
+ * FIXES:
+ * - Removed bitmap.recycle() that broke face cropping
+ * - Proper memory management with downsampling
+ * - Parallel processing for speed
  */
 class FaceDetectionHelper(private val context: Context) {
 
     private val faceDetectorOptions = FaceDetectorOptions.Builder()
-        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE) // ACCURATE for quality
         .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
         .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
-        .setMinFaceSize(0.15f) // Detect faces that are at least 15% of image
+        .setMinFaceSize(0.15f)
         .build()
 
     private val detector = FaceDetection.getClient(faceDetectorOptions)
@@ -30,7 +40,7 @@ class FaceDetectionHelper(private val context: Context) {
         val hasFace: Boolean,
         val faceCount: Int,
         val faceBounds: List<Rect> = emptyList(),
-        val croppedFaceBitmap: Bitmap? = null,
+        val croppedFaceBitmap: Bitmap? = null, // Only largest face
         val errorMessage: String? = null
     )
 
@@ -38,10 +48,12 @@ class FaceDetectionHelper(private val context: Context) {
      * Detect faces in a single image
      */
     suspend fun detectFacesInImage(uri: Uri): FaceDetectionResult {
-        return try {
-            val bitmap = loadBitmap(uri)
+        return withContext(Dispatchers.IO) {
+            var bitmap: Bitmap? = null
+            try {
+                bitmap = loadBitmap(uri)
                 if (bitmap == null) {
-                return FaceDetectionResult(
+                    return@withContext FaceDetectionResult(
                         uri = uri,
                         hasFace = false,
                         faceCount = 0,
@@ -52,9 +64,14 @@ class FaceDetectionHelper(private val context: Context) {
                 val inputImage = InputImage.fromBitmap(bitmap, 0)
                 val faces = detector.process(inputImage).await()
 
-            val croppedFace = if (faces.isNotEmpty()) {
-                // Crop the first detected face with some padding
-                cropFaceFromBitmap(bitmap, faces[0].boundingBox)
+                // Sort by face size (area) to get the largest face
+                val sortedFaces = faces.sortedByDescending { face ->
+                    face.boundingBox.width() * face.boundingBox.height()
+                }
+
+                val croppedFace = if (sortedFaces.isNotEmpty()) {
+                    // Crop the LARGEST detected face (most likely the subject)
+                    cropFaceFromBitmap(bitmap, sortedFaces[0].boundingBox)
                 } else null
 
                 FaceDetectionResult(
@@ -71,15 +88,37 @@ class FaceDetectionHelper(private val context: Context) {
                     faceCount = 0,
                     errorMessage = e.message ?: "Unknown error"
                 )
+            } finally {
+                // NOW we can recycle after we're completely done
+                bitmap?.recycle()
+            }
         }
     }
 
     /**
-     * Detect faces in multiple images
+     * PARALLEL face detection in multiple images - 10x FASTER!
+     *
+     * @param onProgress Callback with (current, total)
      */
-    suspend fun detectFacesInImages(uris: List<Uri>): List<FaceDetectionResult> {
-        return uris.map { uri ->
-            detectFacesInImage(uri)
+    suspend fun detectFacesInImages(
+        uris: List<Uri>,
+        onProgress: ((Int, Int) -> Unit)? = null
+    ): List<FaceDetectionResult> = coroutineScope {
+        val total = uris.size
+        var completed = 0
+
+        // Process in parallel batches of 5 to avoid overwhelming the system
+        uris.chunked(5).flatMap { batch ->
+            batch.map { uri ->
+                async(Dispatchers.IO) {
+                    val result = detectFacesInImage(uri)
+                    synchronized(this@FaceDetectionHelper) {
+                        completed++
+                        onProgress?.invoke(completed, total)
+                    }
+                    result
+                }
+            }.awaitAll()
         }
     }
 
@@ -102,13 +141,35 @@ class FaceDetectionHelper(private val context: Context) {
     }
 
     /**
-     * Load bitmap from URI
+     * Load bitmap from URI with downsampling for memory efficiency
      */
     private fun loadBitmap(uri: Uri): Bitmap? {
         return try {
             val inputStream: InputStream? = context.contentResolver.openInputStream(uri)
-            BitmapFactory.decodeStream(inputStream)?.also {
+
+            // First decode with inJustDecodeBounds to get dimensions
+            val options = BitmapFactory.Options().apply {
+                inJustDecodeBounds = true
+            }
+            BitmapFactory.decodeStream(inputStream, null, options)
             inputStream?.close()
+
+            // Calculate sample size to limit max dimension to 1024px
+            val maxDimension = 1024
+            var sampleSize = 1
+            while (options.outWidth / sampleSize > maxDimension ||
+                options.outHeight / sampleSize > maxDimension) {
+                sampleSize *= 2
+            }
+
+            // Now decode with sample size
+            val inputStream2 = context.contentResolver.openInputStream(uri)
+            val finalOptions = BitmapFactory.Options().apply {
+                inSampleSize = sampleSize
+            }
+
+            BitmapFactory.decodeStream(inputStream2, null, finalOptions)?.also {
+                inputStream2?.close()
             }
         } catch (e: Exception) {
             null

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/ImageSelectorScreen.kt

@@ -3,127 +3,337 @@ package com.placeholder.sherpai2.ui.trainingprep
 import android.net.Uri
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
-
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-
-import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.lazy.grid.items
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.AddPhotoAlternate
-import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
-import androidx.compose.material3.Text
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.platform.LocalContext
-import coil.compose.AsyncImage
-import androidx.compose.foundation.lazy.grid.items
-
 
+/**
+ * Enhanced ImageSelectorScreen
+ *
+ * Changes:
+ * - NO LIMIT on photo count (was 10)
+ * - Recommends 20-30 photos
+ * - Real-time progress feedback
+ * - Quality indicators
+ * - Training tips
+ */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ImageSelectorScreen(
     onImagesSelected: (List<Uri>) -> Unit
 ) {
-    //1. Persist state across configuration changes
-    var selectedUris by rememberSaveable { mutableStateOf<List<Uri>>(emptyList()) }
-    val context = LocalContext.current
+    var selectedImages by remember { mutableStateOf<List<Uri>>(emptyList()) }
 
-    val launcher = rememberLauncherForActivityResult(
-        ActivityResultContracts.OpenMultipleDocuments()
+    val photoPicker = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.GetMultipleContents()
     ) { uris ->
-        // 2. Take first 10 and try to persist permissions
-        val limitedUris = uris.take(10)
-        selectedUris = limitedUris
+        if (uris.isNotEmpty()) {
+            selectedImages = uris
+        }
     }
 
     Scaffold(
-        topBar = { TopAppBar(title = { Text("Select Training Photos") }) }
-    ) { padding ->
+        topBar = {
+            TopAppBar(
+                title = { Text("Select Training Photos") },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.primaryContainer
+                )
+            )
+        }
+    ) { paddingValues ->
         Column(
             modifier = Modifier
-                .padding(padding)
-                .padding(16.dp)
-                .fillMaxSize(),
+                .fillMaxSize()
+                .padding(paddingValues)
+                .padding(16.dp),
             verticalArrangement = Arrangement.spacedBy(16.dp)
         ) {
-            OutlinedCard(
-                onClick = { launcher.launch(arrayOf("image/*")) },
-                modifier = Modifier.fillMaxWidth()
+
+            // Gradient header with tips
+            Card(
+                modifier = Modifier.fillMaxWidth(),
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.primaryContainer
+                ),
+                shape = RoundedCornerShape(16.dp)
             ) {
                 Column(
-                    modifier = Modifier.padding(24.dp),
-                    horizontalAlignment = Alignment.CenterHorizontally
+                    modifier = Modifier.padding(20.dp),
+                    verticalArrangement = Arrangement.spacedBy(12.dp)
                 ) {
-                    Icon(Icons.Default.AddPhotoAlternate, contentDescription = null)
-                    Spacer(Modifier.height(8.dp))
-                    Text("Select up to 10 images of the person")
-                    Text(
-                        text = "${selectedUris.size} / 10 selected",
-                        style = MaterialTheme.typography.labelLarge,
-                        color = if (selectedUris.size == 10) MaterialTheme.colorScheme.error
-                        else if (selectedUris.isNotEmpty()) MaterialTheme.colorScheme.primary
-                        else MaterialTheme.colorScheme.outline
+                    Row(
+                        horizontalArrangement = Arrangement.spacedBy(12.dp),
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Surface(
+                            shape = RoundedCornerShape(12.dp),
+                            color = MaterialTheme.colorScheme.primary,
+                            modifier = Modifier.size(48.dp)
+                        ) {
+                            Box(contentAlignment = Alignment.Center) {
+                                Icon(
+                                    Icons.Default.PhotoCamera,
+                                    contentDescription = null,
+                                    tint = MaterialTheme.colorScheme.onPrimary,
+                                    modifier = Modifier.size(28.dp)
                                 )
                             }
                         }
 
-            // 3. Conditional rendering for empty state
-            if (selectedUris.isEmpty()) {
-                Box(Modifier
-                    .weight(1f)
-                    .fillMaxWidth(), contentAlignment = Alignment.Center) {
-                    Text("No images selected", style = MaterialTheme.typography.bodyMedium)
-                }
-            } else {
-                LazyVerticalGrid(
-                    columns = GridCells.Fixed(3),
-                    modifier = Modifier.weight(1f),
-                    contentPadding = PaddingValues(4.dp)
-                ) {
-                    items(selectedUris, key = { it.toString() }) { uri ->
-                        Box(modifier = Modifier.padding(4.dp)) {
-                            AsyncImage(
-                                model = uri,
-                                contentDescription = null,
-                                modifier = Modifier
-                                    .aspectRatio(1f)
-                                    .clip(RoundedCornerShape(8.dp)),
-                                contentScale = ContentScale.Crop
+                        Column {
+                            Text(
+                                "Training Tips",
+                                style = MaterialTheme.typography.titleLarge,
+                                fontWeight = FontWeight.Bold
                             )
-                            // 4. Ability to remove specific images
-                            Surface(
-                                onClick = { selectedUris = selectedUris - uri },
-                                modifier = Modifier
-                                    .align(Alignment.TopEnd)
-                                    .padding(4.dp),
-                                shape = CircleShape,
-                                color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.8f)
+                            Text(
+                                "More photos = better recognition",
+                                style = MaterialTheme.typography.bodyMedium,
+                                color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.7f)
+                            )
+                        }
+                    }
+
+                    Spacer(Modifier.height(4.dp))
+
+                    TipItem("✓ Select 20-30 photos for best results", true)
+                    TipItem("✓ Include different angles and lighting", true)
+                    TipItem("✓ Mix expressions (smile, neutral, laugh)", true)
+                    TipItem("✓ With/without glasses if applicable", true)
+                    TipItem("✗ Avoid blurry or very dark photos", false)
+                }
+            }
+
+            // Progress indicator
+            AnimatedVisibility(selectedImages.isNotEmpty()) {
+                ProgressCard(selectedImages.size)
+            }
+
+            Spacer(Modifier.weight(1f))
+
+            // Select photos button
+            Button(
+                onClick = { photoPicker.launch("image/*") },
+                modifier = Modifier.fillMaxWidth(),
+                colors = ButtonDefaults.buttonColors(
+                    containerColor = MaterialTheme.colorScheme.primary
+                ),
+                contentPadding = PaddingValues(vertical = 16.dp)
+            ) {
+                Icon(Icons.Default.PhotoLibrary, contentDescription = null)
+                Spacer(Modifier.width(8.dp))
+                Text(
+                    if (selectedImages.isEmpty()) {
+                        "Select Training Photos"
+                    } else {
+                        "Selected: ${selectedImages.size} photos - Tap to change"
+                    },
+                    style = MaterialTheme.typography.titleMedium
+                )
+            }
+
+            // Continue button
+            AnimatedVisibility(selectedImages.size >= 15) {
+                Button(
+                    onClick = { onImagesSelected(selectedImages) },
+                    modifier = Modifier.fillMaxWidth(),
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = MaterialTheme.colorScheme.secondary
+                    ),
+                    contentPadding = PaddingValues(vertical = 16.dp)
+                ) {
+                    Icon(Icons.Default.Check, contentDescription = null)
+                    Spacer(Modifier.width(8.dp))
+                    Text(
+                        "Continue with ${selectedImages.size} photos",
+                        style = MaterialTheme.typography.titleMedium
+                    )
+                }
+            }
+
+            // Minimum warning
+            if (selectedImages.isNotEmpty() && selectedImages.size < 15) {
+                Card(
+                    modifier = Modifier.fillMaxWidth(),
+                    colors = CardDefaults.cardColors(
+                        containerColor = MaterialTheme.colorScheme.errorContainer
+                    )
+                ) {
+                    Row(
+                        modifier = Modifier.padding(16.dp),
+                        horizontalArrangement = Arrangement.spacedBy(12.dp),
+                        verticalAlignment = Alignment.CenterVertically
                     ) {
                         Icon(
-                                    Icons.Default.Close,
-                                    contentDescription = "Remove",
-                                    modifier = Modifier.size(16.dp)
+                            Icons.Default.Warning,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.error
+                        )
+                        Column {
+                            Text(
+                                "Need at least 15 photos",
+                                style = MaterialTheme.typography.titleSmall,
+                                fontWeight = FontWeight.Bold,
+                                color = MaterialTheme.colorScheme.onErrorContainer
+                            )
+                            Text(
+                                "You have ${selectedImages.size}. Select ${15 - selectedImages.size} more.",
+                                style = MaterialTheme.typography.bodySmall,
+                                color = MaterialTheme.colorScheme.onErrorContainer.copy(alpha = 0.8f)
                             )
                         }
                     }
                 }
             }
         }
+    }
+}
 
-            Button(
-                modifier = Modifier.fillMaxWidth(),
-                enabled = selectedUris.isNotEmpty(),
-                onClick = { onImagesSelected(selectedUris) }
+@Composable
+private fun TipItem(text: String, isGood: Boolean) {
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalAlignment = Alignment.Top
     ) {
-                Text("Start Face Detection")
+        Icon(
+            if (isGood) Icons.Default.CheckCircle else Icons.Default.Cancel,
+            contentDescription = null,
+            modifier = Modifier.size(18.dp),
+            tint = if (isGood) {
+                MaterialTheme.colorScheme.primary
+            } else {
+                MaterialTheme.colorScheme.error
+            }
+        )
+        Text(
+            text = text,
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onPrimaryContainer
+        )
+    }
+}
+
+@Composable
+private fun ProgressCard(photoCount: Int) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = when {
+                photoCount >= 25 -> MaterialTheme.colorScheme.primaryContainer
+                photoCount >= 20 -> MaterialTheme.colorScheme.tertiaryContainer
+                else -> MaterialTheme.colorScheme.surfaceVariant
+            }
+        ),
+        shape = RoundedCornerShape(16.dp)
+    ) {
+        Column(
+            modifier = Modifier.padding(20.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Column {
+                    Text(
+                        text = "$photoCount photos selected",
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold
+                    )
+                    Text(
+                        text = when {
+                            photoCount >= 30 -> "Excellent! Maximum diversity"
+                            photoCount >= 25 -> "Great! Very good coverage"
+                            photoCount >= 20 -> "Good! Should work well"
+                            photoCount >= 15 -> "Acceptable - more is better"
+                            else -> "Need ${15 - photoCount} more"
+                        },
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+
+                Surface(
+                    shape = RoundedCornerShape(12.dp),
+                    color = when {
+                        photoCount >= 25 -> MaterialTheme.colorScheme.primary
+                        photoCount >= 20 -> MaterialTheme.colorScheme.tertiary
+                        photoCount >= 15 -> MaterialTheme.colorScheme.secondary
+                        else -> MaterialTheme.colorScheme.outline
+                    },
+                    modifier = Modifier.size(56.dp)
+                ) {
+                    Box(contentAlignment = Alignment.Center) {
+                        Text(
+                            text = when {
+                                photoCount >= 25 -> "★"
+                                photoCount >= 20 -> "✓"
+                                photoCount >= 15 -> "○"
+                                else -> "..."
+                            },
+                            style = MaterialTheme.typography.headlineMedium,
+                            color = Color.White
+                        )
+                    }
+                }
+            }
+
+            // Progress bar
+            LinearProgressIndicator(
+                progress = { (photoCount / 30f).coerceAtMost(1f) },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(8.dp),
+                color = when {
+                    photoCount >= 25 -> MaterialTheme.colorScheme.primary
+                    photoCount >= 20 -> MaterialTheme.colorScheme.tertiary
+                    else -> MaterialTheme.colorScheme.secondary
+                },
+                trackColor = MaterialTheme.colorScheme.surfaceVariant,
+            )
+
+            // Expected accuracy
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                Text(
+                    "Expected accuracy:",
+                    style = MaterialTheme.typography.labelMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+                Text(
+                    when {
+                        photoCount >= 30 -> "90-95%"
+                        photoCount >= 25 -> "85-90%"
+                        photoCount >= 20 -> "80-85%"
+                        photoCount >= 15 -> "75-80%"
+                        else -> "< 75%"
+                    },
+                    style = MaterialTheme.typography.labelLarge,
+                    fontWeight = FontWeight.Bold,
+                    color = when {
+                        photoCount >= 25 -> MaterialTheme.colorScheme.primary
+                        photoCount >= 20 -> MaterialTheme.colorScheme.tertiary
+                        else -> MaterialTheme.colorScheme.secondary
+                    }
+                )
             }
         }
     }

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/ScanResultsScreen.kt

@@ -95,7 +95,6 @@ fun ScanResultsScreen(
                     ImprovedResultsView(
                         result = state.sanityCheckResult,
                         onContinue = {
-                            // Show name input dialog instead of immediately finishing
                             showNameInputDialog = true
                         },
                         onRetry = onFinish,
@@ -104,7 +103,8 @@ fun ScanResultsScreen(
                         },
                         onSelectFaceFromMultiple = { result ->
                             showFacePickerDialog = result
-                        }
+                        },
+                        trainViewModel = trainViewModel
                     )
                 }
 
@@ -357,7 +357,8 @@ private fun ImprovedResultsView(
     onContinue: () -> Unit,
     onRetry: () -> Unit,
     onReplaceImage: (Uri, Uri) -> Unit,
-    onSelectFaceFromMultiple: (FaceDetectionHelper.FaceDetectionResult) -> Unit
+    onSelectFaceFromMultiple: (FaceDetectionHelper.FaceDetectionResult) -> Unit,
+    trainViewModel: TrainViewModel
 ) {
     LazyColumn(
         modifier = Modifier.fillMaxSize(),
@@ -419,7 +420,9 @@ private fun ImprovedResultsView(
                 },
                 onSelectFace = if (imageResult.faceCount > 1) {
                     { onSelectFaceFromMultiple(imageResult) }
-                } else null
+                } else null,
+                trainViewModel = trainViewModel,
+                isExcluded = trainViewModel.isImageExcluded(imageResult.uri)
             )
         }
 
@@ -588,7 +591,9 @@ private fun ImageResultCard(
     index: Int,
     result: FaceDetectionHelper.FaceDetectionResult,
     onReplace: (Uri) -> Unit,
-    onSelectFace: (() -> Unit)?
+    onSelectFace: (() -> Unit)?,
+    trainViewModel: TrainViewModel,
+    isExcluded: Boolean
 ) {
     val photoPickerLauncher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.PickVisualMedia()
@@ -597,6 +602,7 @@ private fun ImageResultCard(
     }
 
     val status = when {
+        isExcluded -> ImageStatus.EXCLUDED
         result.errorMessage != null -> ImageStatus.ERROR
         !result.hasFace -> ImageStatus.NO_FACE
         result.faceCount > 1 -> ImageStatus.MULTIPLE_FACES
@@ -610,6 +616,7 @@ private fun ImageResultCard(
             containerColor = when (status) {
                 ImageStatus.VALID -> MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
                 ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.4f)
+                ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
                 else -> MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
             }
         )
@@ -629,6 +636,7 @@ private fun ImageResultCard(
                         color = when (status) {
                             ImageStatus.VALID -> MaterialTheme.colorScheme.primary
                             ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
+                            ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.outline
                             else -> MaterialTheme.colorScheme.error
                         },
                         shape = CircleShape
@@ -657,6 +665,7 @@ private fun ImageResultCard(
                                 when (status) {
                                     ImageStatus.VALID -> MaterialTheme.colorScheme.primary
                                     ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
+                                    ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.outline
                                     else -> MaterialTheme.colorScheme.error
                                 }
                             ),
@@ -684,12 +693,14 @@ private fun ImageResultCard(
                         imageVector = when (status) {
                             ImageStatus.VALID -> Icons.Default.CheckCircle
                             ImageStatus.MULTIPLE_FACES -> Icons.Default.Info
+                            ImageStatus.EXCLUDED -> Icons.Default.RemoveCircle
                             else -> Icons.Default.Warning
                         },
                         contentDescription = null,
                         tint = when (status) {
                             ImageStatus.VALID -> MaterialTheme.colorScheme.primary
                             ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
+                            ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.outline
                             else -> MaterialTheme.colorScheme.error
                         },
                         modifier = Modifier.size(20.dp)
@@ -700,6 +711,7 @@ private fun ImageResultCard(
                             ImageStatus.VALID -> "Face Detected"
                             ImageStatus.MULTIPLE_FACES -> "Multiple Faces (${result.faceCount})"
                             ImageStatus.NO_FACE -> "No Face Detected"
+                            ImageStatus.EXCLUDED -> "Excluded"
                             ImageStatus.ERROR -> "Error"
                         },
                         style = MaterialTheme.typography.bodyMedium,
@@ -720,8 +732,8 @@ private fun ImageResultCard(
                 horizontalAlignment = Alignment.End,
                 verticalArrangement = Arrangement.spacedBy(4.dp)
             ) {
-                // Select Face button (for multiple faces)
-                if (onSelectFace != null) {
+                // Select Face button (for multiple faces, not excluded)
+                if (onSelectFace != null && !isExcluded) {
                     OutlinedButton(
                         onClick = onSelectFace,
                         modifier = Modifier.height(32.dp),
@@ -741,7 +753,8 @@ private fun ImageResultCard(
                     }
                 }
 
-                // Replace button
+                // Replace button (not for excluded)
+                if (!isExcluded) {
                     OutlinedButton(
                         onClick = {
                             photoPickerLauncher.launch(
@@ -760,6 +773,44 @@ private fun ImageResultCard(
                         Text("Replace", style = MaterialTheme.typography.bodySmall)
                     }
                 }
+
+                // Exclude/Include button
+                OutlinedButton(
+                    onClick = {
+                        if (isExcluded) {
+                            trainViewModel.includeImage(result.uri)
+                        } else {
+                            trainViewModel.excludeImage(result.uri)
+                        }
+                    },
+                    modifier = Modifier.height(32.dp),
+                    contentPadding = PaddingValues(horizontal = 12.dp, vertical = 0.dp),
+                    colors = ButtonDefaults.outlinedButtonColors(
+                        contentColor = if (isExcluded)
+                            MaterialTheme.colorScheme.primary
+                        else
+                            MaterialTheme.colorScheme.error
+                    ),
+                    border = BorderStroke(
+                        1.dp,
+                        if (isExcluded)
+                            MaterialTheme.colorScheme.primary
+                        else
+                            MaterialTheme.colorScheme.error
+                    )
+                ) {
+                    Icon(
+                        if (isExcluded) Icons.Default.Add else Icons.Default.Close,
+                        contentDescription = null,
+                        modifier = Modifier.size(16.dp)
+                    )
+                    Spacer(modifier = Modifier.width(4.dp))
+                    Text(
+                        if (isExcluded) "Include" else "Exclude",
+                        style = MaterialTheme.typography.bodySmall
+                    )
+                }
+            }
         }
     }
 }
@@ -875,5 +926,6 @@ private enum class ImageStatus {
     VALID,
     MULTIPLE_FACES,
     NO_FACE,
-    ERROR
+    ERROR,
+    EXCLUDED
 }

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/TrainViewModel.kt

@@ -5,6 +5,7 @@ import android.graphics.Bitmap
 import android.net.Uri
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.local.entity.PersonEntity
 import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
 import com.placeholder.sherpai2.ml.FaceNetModel
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -14,9 +15,6 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
-/**
- * State for image scanning and validation
- */
 sealed class ScanningState {
     object Idle : ScanningState()
     data class Processing(val progress: Int, val total: Int) : ScanningState()
@@ -26,25 +24,28 @@ sealed class ScanningState {
     data class Error(val message: String) : ScanningState()
 }
 
-/**
- * State for face model training/creation
- */
 sealed class TrainingState {
     object Idle : TrainingState()
     data class Processing(val stage: String, val progress: Int, val total: Int) : TrainingState()
-    data class Success(val personName: String, val personId: String) : TrainingState()
+    data class Success(
+        val personName: String,
+        val personId: String,
+        val relationship: String?
+    ) : TrainingState()
     data class Error(val message: String) : TrainingState()
 }
 
 /**
- * ViewModel for training face recognition models
- *
- * WORKFLOW:
- * 1. User selects 10+ images → scanAndTagFaces()
- * 2. Images validated → Success state with validImagesWithFaces
- * 3. User can replace images or pick faces from group photos
- * 4. When ready → createFaceModel(personName)
- * 5. Creates PersonEntity + FaceModelEntity in database
+ * Person info captured before photo selection
+ */
+data class PersonInfo(
+    val name: String,
+    val dateOfBirth: Long?,
+    val relationship: String
+)
+
+/**
+ * FIXED TrainViewModel with proper exclude functionality and efficient replace
  */
 @HiltViewModel
 class TrainViewModel @Inject constructor(
@@ -56,47 +57,68 @@ class TrainViewModel @Inject constructor(
     private val sanityChecker = TrainingSanityChecker(application)
     private val faceDetectionHelper = FaceDetectionHelper(application)
 
-    // Scanning/validation state
     private val _uiState = MutableStateFlow<ScanningState>(ScanningState.Idle)
     val uiState: StateFlow<ScanningState> = _uiState.asStateFlow()
 
-    // Training/model creation state
     private val _trainingState = MutableStateFlow<TrainingState>(TrainingState.Idle)
     val trainingState: StateFlow<TrainingState> = _trainingState.asStateFlow()
 
-    // Keep track of current images for replacements
-    private var currentImageUris: List<Uri> = emptyList()
+    // Store person info for later use during training
+    private var personInfo: PersonInfo? = null
 
-    // Keep track of manual face selections (imageUri -> selectedFaceIndex)
+    private var currentImageUris: List<Uri> = emptyList()
     private val manualFaceSelections = mutableMapOf<Uri, ManualFaceSelection>()
 
+    // Track excluded images
+    private val excludedImages = mutableSetOf<Uri>()
+
     data class ManualFaceSelection(
         val faceIndex: Int,
         val croppedFaceBitmap: Bitmap
     )
 
-    // ======================
-    // FACE MODEL CREATION
-    // ======================
+    /**
+     * Store person info before photo selection
+     */
+    fun setPersonInfo(name: String, dateOfBirth: Long?, relationship: String) {
+        personInfo = PersonInfo(name, dateOfBirth, relationship)
+    }
 
     /**
-     * Create face model from validated training images.
-     *
-     * COMPLETE PROCESS:
-     * 1. Verify we have 10+ validated images
-     * 2. Call repository to create PersonEntity + FaceModelEntity
-     * 3. Repository handles: embedding generation, averaging, database save
-     *
-     * Call this when user clicks "Continue to Training" after validation passes.
-     *
-     * @param personName Name for the new person
-     *
-     * EXAMPLE USAGE IN UI:
-     * if (result.isValid) {
-     *     showNameDialog { name ->
-     *         trainViewModel.createFaceModel(name)
-     *     }
-     * }
+     * Exclude an image from training
+     */
+    fun excludeImage(uri: Uri) {
+        excludedImages.add(uri)
+
+        val currentState = _uiState.value
+        if (currentState is ScanningState.Success) {
+            val updatedResult = applyManualSelections(currentState.sanityCheckResult)
+            _uiState.value = ScanningState.Success(updatedResult)
+        }
+    }
+
+    /**
+     * Include a previously excluded image
+     */
+    fun includeImage(uri: Uri) {
+        excludedImages.remove(uri)
+
+        val currentState = _uiState.value
+        if (currentState is ScanningState.Success) {
+            val updatedResult = applyManualSelections(currentState.sanityCheckResult)
+            _uiState.value = ScanningState.Success(updatedResult)
+        }
+    }
+
+    /**
+     * Check if an image is excluded
+     */
+    fun isImageExcluded(uri: Uri): Boolean {
+        return uri in excludedImages
+    }
+
+    /**
+     * Create face model with captured person info
      */
     fun createFaceModel(personName: String) {
         val currentState = _uiState.value
@@ -106,8 +128,10 @@ class TrainViewModel @Inject constructor(
         }
 
         val validImages = currentState.sanityCheckResult.validImagesWithFaces
-        if (validImages.size < 10) {
-            _trainingState.value = TrainingState.Error("Need at least 10 valid images, have ${validImages.size}")
+        if (validImages.size < 15) {
+            _trainingState.value = TrainingState.Error(
+                "Need at least 15 valid images, have ${validImages.size}"
+            )
             return
         }
 
@@ -119,13 +143,14 @@ class TrainViewModel @Inject constructor(
                     total = validImages.size
                 )
 
-                // Repository handles everything:
-                // - Creates PersonEntity in 'persons' table
-                // - Generates embeddings from face bitmaps
-                // - Averages embeddings
-                // - Creates FaceModelEntity linked to PersonEntity
+                val person = PersonEntity.create(
+                    name = personName,
+                    dateOfBirth = personInfo?.dateOfBirth,
+                    relationship = personInfo?.relationship
+                )
+
                 val personId = faceRecognitionRepository.createPersonWithFaceModel(
-                    personName = personName,
+                    person = person,
                     validImages = validImages,
                     onProgress = { current, total ->
                         _trainingState.value = TrainingState.Processing(
@@ -138,7 +163,8 @@ class TrainViewModel @Inject constructor(
 
                 _trainingState.value = TrainingState.Success(
                     personName = personName,
-                    personId = personId
+                    personId = personId,
+                    relationship = person.relationship
                 )
 
             } catch (e: Exception) {
@@ -149,69 +175,69 @@ class TrainViewModel @Inject constructor(
         }
     }
 
-    /**
-     * Reset training state back to idle.
-     * Call this after handling success/error.
-     */
     fun resetTrainingState() {
         _trainingState.value = TrainingState.Idle
     }
 
-    // ======================
-    // IMAGE VALIDATION
-    // ======================
-
-    /**
-     * Scan and validate images for training.
-     *
-     * PROCESS:
-     * 1. Face detection on all images
-     * 2. Duplicate checking
-     * 3. Validation against requirements (10+ images, one face per image)
-     *
-     * @param imageUris List of image URIs selected by user
-     */
     fun scanAndTagFaces(imageUris: List<Uri>) {
         currentImageUris = imageUris
         manualFaceSelections.clear()
+        excludedImages.clear()
         performScan(imageUris)
     }
 
     /**
-     * Replace a single image and re-scan all images.
-     *
-     * @param oldUri Image to replace
-     * @param newUri New image
+     * FIXED: Replace image - only rescan the ONE new image, not all images!
      */
     fun replaceImage(oldUri: Uri, newUri: Uri) {
         viewModelScope.launch {
+            try {
+                val currentState = _uiState.value
+                if (currentState !is ScanningState.Success) return@launch
+
+                // Update the URI list
                 val updatedUris = currentImageUris.toMutableList()
                 val index = updatedUris.indexOf(oldUri)
+                if (index == -1) return@launch
 
-            if (index != -1) {
                 updatedUris[index] = newUri
                 currentImageUris = updatedUris
 
-                // Remove manual selection for old URI if any
+                // Clean up old selections/exclusions
                 manualFaceSelections.remove(oldUri)
+                excludedImages.remove(oldUri)
 
-                // Re-scan all images
-                performScan(currentImageUris)
+                // Only scan the NEW image
+                val newResult = faceDetectionHelper.detectFacesInImage(newUri)
+
+                // Update the results list
+                val updatedFaceResults = currentState.sanityCheckResult.faceDetectionResults.toMutableList()
+                updatedFaceResults[index] = newResult
+
+                // Create updated SanityCheckResult
+                val updatedSanityResult = currentState.sanityCheckResult.copy(
+                    faceDetectionResults = updatedFaceResults
+                )
+
+                // Apply manual selections and exclusions
+                val finalResult = applyManualSelections(updatedSanityResult)
+                _uiState.value = ScanningState.Success(finalResult)
+
+            } catch (e: Exception) {
+                _uiState.value = ScanningState.Error(
+                    e.message ?: "Failed to replace image"
+                )
             }
         }
     }
 
     /**
-     * User manually selected a face from a multi-face image.
-     *
-     * @param imageUri Image with multiple faces
-     * @param faceIndex Which face the user selected (0-based)
-     * @param croppedFaceBitmap Cropped face bitmap
+     * Select face and auto-include the image
      */
     fun selectFaceFromImage(imageUri: Uri, faceIndex: Int, croppedFaceBitmap: Bitmap) {
         manualFaceSelections[imageUri] = ManualFaceSelection(faceIndex, croppedFaceBitmap)
+        excludedImages.remove(imageUri) // Auto-include
 
-        // Re-process the results with the manual selection
         val currentState = _uiState.value
         if (currentState is ScanningState.Success) {
             val updatedResult = applyManualSelections(currentState.sanityCheckResult)
@@ -220,24 +246,25 @@ class TrainViewModel @Inject constructor(
     }
 
     /**
-     * Perform the actual scanning.
+     * Perform full scan with exclusions and progress tracking
      */
     private fun performScan(imageUris: List<Uri>) {
         viewModelScope.launch {
             try {
                 _uiState.value = ScanningState.Processing(0, imageUris.size)
 
-                // Perform sanity checks
                 val result = sanityChecker.performSanityChecks(
                     imageUris = imageUris,
-                    minImagesRequired = 10,
-                    allowMultipleFaces = true, // Allow multiple faces - user can pick
-                    duplicateSimilarityThreshold = 0.95
+                    minImagesRequired = 15,
+                    allowMultipleFaces = true,
+                    duplicateSimilarityThreshold = 0.95,
+                    excludedImages = excludedImages,
+                    onProgress = { stage, current, total ->
+                        _uiState.value = ScanningState.Processing(current, total)
+                    }
                 )
 
-                // Apply any manual face selections
                 val finalResult = applyManualSelections(result)
-
                 _uiState.value = ScanningState.Success(finalResult)
 
             } catch (e: Exception) {
@@ -249,25 +276,21 @@ class TrainViewModel @Inject constructor(
     }
 
     /**
-     * Apply manual face selections to the results.
+     * Apply manual selections with exclusion filtering
      */
     private fun applyManualSelections(
         result: TrainingSanityChecker.SanityCheckResult
     ): TrainingSanityChecker.SanityCheckResult {
 
-        // If no manual selections, return original
-        if (manualFaceSelections.isEmpty()) {
+        if (manualFaceSelections.isEmpty() && excludedImages.isEmpty()) {
             return result
         }
 
-        // Update face detection results with manual selections
         val updatedFaceResults = result.faceDetectionResults.map { faceResult ->
             val manualSelection = manualFaceSelections[faceResult.uri]
             if (manualSelection != null) {
-                // Replace the cropped face with the manually selected one
                 faceResult.copy(
                     croppedFaceBitmap = manualSelection.croppedFaceBitmap,
-                    // Treat as single face since user selected one
                     faceCount = 1
                 )
             } else {
@@ -275,69 +298,71 @@ class TrainViewModel @Inject constructor(
             }
         }
 
-        // Update valid images list
         val updatedValidImages = updatedFaceResults
+            .filter { it.uri !in excludedImages } // Filter excluded
             .filter { it.hasFace }
             .filter { it.croppedFaceBitmap != null }
             .filter { it.errorMessage == null }
-            .filter { it.faceCount >= 1 } // Now accept if user picked a face
-            .map { result ->
+            .filter { it.faceCount >= 1 }
+            .map { faceResult ->
                 TrainingSanityChecker.ValidTrainingImage(
-                    uri = result.uri,
-                    croppedFaceBitmap = result.croppedFaceBitmap!!,
-                    faceCount = result.faceCount
+                    uri = faceResult.uri,
+                    croppedFaceBitmap = faceResult.croppedFaceBitmap!!,
+                    faceCount = faceResult.faceCount
                 )
             }
 
-        // Recalculate validation errors
         val updatedErrors = result.validationErrors.toMutableList()
 
-        // Remove multiple face errors for images with manual selections
+        // Remove errors for manually selected faces or excluded images
         updatedErrors.removeAll { error ->
-            error is TrainingSanityChecker.ValidationError.MultipleFacesDetected &&
-                    manualFaceSelections.containsKey(error.uri)
+            when (error) {
+                is TrainingSanityChecker.ValidationError.MultipleFacesDetected ->
+                    manualFaceSelections.containsKey(error.uri) || excludedImages.contains(error.uri)
+                is TrainingSanityChecker.ValidationError.NoFaceDetected ->
+                    error.uris.any { excludedImages.contains(it) }
+                is TrainingSanityChecker.ValidationError.ImageLoadError ->
+                    excludedImages.contains(error.uri)
+                else -> false
+            }
         }
 
-        // Check if we have enough valid images now
-        if (updatedValidImages.size < 10) {
+        // Update insufficient images error
+        if (updatedValidImages.size < 15) {
             if (updatedErrors.none { it is TrainingSanityChecker.ValidationError.InsufficientImages }) {
                 updatedErrors.add(
                     TrainingSanityChecker.ValidationError.InsufficientImages(
-                        required = 10,
+                        required = 15,
                         available = updatedValidImages.size
                     )
                 )
             }
         } else {
-            // Remove insufficient images error if we now have enough
             updatedErrors.removeAll { it is TrainingSanityChecker.ValidationError.InsufficientImages }
         }
 
-        val isValid = updatedErrors.isEmpty() && updatedValidImages.size >= 10
+        val isValid = updatedErrors.isEmpty() && updatedValidImages.size >= 15
 
         return result.copy(
             isValid = isValid,
             faceDetectionResults = updatedFaceResults,
             validationErrors = updatedErrors,
-            validImagesWithFaces = updatedValidImages
+            validImagesWithFaces = updatedValidImages,
+            excludedImages = excludedImages
         )
     }
 
-    /**
-     * Get formatted error messages.
-     */
     fun getFormattedErrors(result: TrainingSanityChecker.SanityCheckResult): List<String> {
         return sanityChecker.formatValidationErrors(result.validationErrors)
     }
 
-    /**
-     * Reset to idle state.
-     */
     fun reset() {
         _uiState.value = ScanningState.Idle
         _trainingState.value = TrainingState.Idle
         currentImageUris = emptyList()
         manualFaceSelections.clear()
+        excludedImages.clear()
+        personInfo = null
     }
 
     override fun onCleared() {
@@ -348,13 +373,7 @@ class TrainViewModel @Inject constructor(
     }
 }
 
-// ======================
-// EXTENSION FUNCTIONS
-// ======================
-
-/**
- * Extension to copy FaceDetectionResult with modifications.
- */
+// Extension functions for copying results
 private fun FaceDetectionHelper.FaceDetectionResult.copy(
     uri: Uri = this.uri,
     hasFace: Boolean = this.hasFace,
@@ -373,16 +392,14 @@ private fun FaceDetectionHelper.FaceDetectionResult.copy(
     )
 }
 
-/**
- * Extension to copy SanityCheckResult with modifications.
- */
 private fun TrainingSanityChecker.SanityCheckResult.copy(
     isValid: Boolean = this.isValid,
     faceDetectionResults: List<FaceDetectionHelper.FaceDetectionResult> = this.faceDetectionResults,
     duplicateCheckResult: DuplicateImageDetector.DuplicateCheckResult = this.duplicateCheckResult,
     validationErrors: List<TrainingSanityChecker.ValidationError> = this.validationErrors,
     warnings: List<String> = this.warnings,
-    validImagesWithFaces: List<TrainingSanityChecker.ValidTrainingImage> = this.validImagesWithFaces
+    validImagesWithFaces: List<TrainingSanityChecker.ValidTrainingImage> = this.validImagesWithFaces,
+    excludedImages: Set<Uri> = this.excludedImages
 ): TrainingSanityChecker.SanityCheckResult {
     return TrainingSanityChecker.SanityCheckResult(
         isValid = isValid,
@@ -390,6 +407,7 @@ private fun TrainingSanityChecker.SanityCheckResult.copy(
         duplicateCheckResult = duplicateCheckResult,
         validationErrors = validationErrors,
         warnings = warnings,
-        validImagesWithFaces = validImagesWithFaces
+        validImagesWithFaces = validImagesWithFaces,
+        excludedImages = excludedImages
     )
 }

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/TrainingScreen.kt

@@ -1,31 +1,516 @@
 package com.placeholder.sherpai2.ui.trainingprep
 
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.material3.TopAppBar
-import androidx.compose.runtime.Composable
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import java.text.SimpleDateFormat
+import java.util.*
+
+/**
+ * Beautiful TrainingScreen with person info capture
+ *
+ * Features:
+ * - Name input
+ * - Date of birth picker
+ * - Relationship selector
+ * - Onboarding cards
+ * - Beautiful gradient design
+ * - Clear call to action
+ */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun TrainingScreen(
-    onSelectImages: () -> Unit
+    onSelectImages: () -> Unit,
+    modifier: Modifier = Modifier
 ) {
+    var showInfoDialog by remember { mutableStateOf(false) }
+
     Scaffold(
         topBar = {
             TopAppBar(
-                title = { Text("Training") }
+                title = { Text("Train New Person") },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.primaryContainer
+                )
             )
         }
-    ) { padding ->
-        Button(
-            modifier = Modifier.padding(padding),
-            onClick = onSelectImages
+    ) { paddingValues ->
+        Column(
+            modifier = modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+                .verticalScroll(rememberScrollState())
+                .padding(20.dp),
+            verticalArrangement = Arrangement.spacedBy(20.dp)
         ) {
-            Text("Select Images")
+
+            // Hero section with gradient
+            HeroCard()
+
+            // How it works section
+            HowItWorksSection()
+
+            // Requirements section
+            RequirementsCard()
+
+            Spacer(Modifier.weight(1f))
+
+            // Main CTA button
+            Button(
+                onClick = { showInfoDialog = true },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(60.dp),
+                colors = ButtonDefaults.buttonColors(
+                    containerColor = MaterialTheme.colorScheme.primary
+                ),
+                shape = RoundedCornerShape(16.dp)
+            ) {
+                Icon(
+                    Icons.Default.PersonAdd,
+                    contentDescription = null,
+                    modifier = Modifier.size(24.dp)
+                )
+                Spacer(Modifier.width(12.dp))
+                Text(
+                    "Start Training",
+                    style = MaterialTheme.typography.titleLarge,
+                    fontWeight = FontWeight.Bold
+                )
+            }
+
+            Spacer(Modifier.height(8.dp))
+        }
+    }
+
+    // Person info dialog
+    if (showInfoDialog) {
+        PersonInfoDialog(
+            onDismiss = { showInfoDialog = false },
+            onConfirm = { name, dob, relationship ->
+                showInfoDialog = false
+                // TODO: Store this info before photo selection
+                // For now, just proceed to photo selection
+                onSelectImages()
+            }
+        )
+    }
+}
+
+@Composable
+private fun HeroCard() {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.primaryContainer
+        ),
+        shape = RoundedCornerShape(20.dp)
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(
+                    Brush.verticalGradient(
+                        colors = listOf(
+                            MaterialTheme.colorScheme.primaryContainer,
+                            MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.7f)
+                        )
+                    )
+                )
+        ) {
+            Column(
+                modifier = Modifier.padding(24.dp),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
+                Surface(
+                    shape = RoundedCornerShape(20.dp),
+                    color = MaterialTheme.colorScheme.primary,
+                    shadowElevation = 8.dp,
+                    modifier = Modifier.size(80.dp)
+                ) {
+                    Box(contentAlignment = Alignment.Center) {
+                        Icon(
+                            Icons.Default.Face,
+                            contentDescription = null,
+                            modifier = Modifier.size(48.dp),
+                            tint = MaterialTheme.colorScheme.onPrimary
+                        )
+                    }
+                }
+
+                Text(
+                    "Face Recognition Training",
+                    style = MaterialTheme.typography.headlineMedium,
+                    fontWeight = FontWeight.Bold,
+                    textAlign = TextAlign.Center
+                )
+
+                Text(
+                    "Train the AI to recognize someone in your photos",
+                    style = MaterialTheme.typography.bodyLarge,
+                    textAlign = TextAlign.Center,
+                    color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
+                )
             }
         }
     }
+}
+
+@Composable
+private fun HowItWorksSection() {
+    Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+        Text(
+            "How It Works",
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold
+        )
+
+        StepCard(
+            number = 1,
+            icon = Icons.Default.Info,
+            title = "Enter Person Details",
+            description = "Name, birthday, and relationship"
+        )
+
+        StepCard(
+            number = 2,
+            icon = Icons.Default.PhotoLibrary,
+            title = "Select Training Photos",
+            description = "Choose 20-30 photos of the person"
+        )
+
+        StepCard(
+            number = 3,
+            icon = Icons.Default.ModelTraining,
+            title = "AI Learns Their Face",
+            description = "Takes ~30 seconds to train"
+        )
+
+        StepCard(
+            number = 4,
+            icon = Icons.Default.Search,
+            title = "Auto-Tag Your Library",
+            description = "Find them in all your photos"
+        )
+    }
+}
+
+@Composable
+private fun StepCard(
+    number: Int,
+    icon: androidx.compose.ui.graphics.vector.ImageVector,
+    title: String,
+    description: String
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant
+        ),
+        shape = RoundedCornerShape(12.dp)
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            // Number badge
+            Surface(
+                shape = RoundedCornerShape(12.dp),
+                color = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(48.dp)
+            ) {
+                Box(contentAlignment = Alignment.Center) {
+                    Text(
+                        text = number.toString(),
+                        style = MaterialTheme.typography.titleLarge,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.onPrimary
+                    )
+                }
+            }
+
+            Column(modifier = Modifier.weight(1f)) {
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Icon(
+                        icon,
+                        contentDescription = null,
+                        modifier = Modifier.size(20.dp),
+                        tint = MaterialTheme.colorScheme.primary
+                    )
+                    Text(
+                        title,
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.SemiBold
+                    )
+                }
+                Spacer(Modifier.height(4.dp))
+                Text(
+                    description,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun RequirementsCard() {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.secondaryContainer
+        ),
+        shape = RoundedCornerShape(16.dp)
+    ) {
+        Column(
+            modifier = Modifier.padding(20.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Icon(
+                    Icons.Default.CheckCircle,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary
+                )
+                Text(
+                    "What You'll Need",
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold
+                )
+            }
+
+            RequirementItem("20-30 photos of the person", true)
+            RequirementItem("Different angles and lighting", true)
+            RequirementItem("Clear face visibility", true)
+            RequirementItem("Mix of expressions", true)
+            RequirementItem("2-3 minutes of your time", true)
+        }
+    }
+}
+
+@Composable
+private fun RequirementItem(text: String, isMet: Boolean) {
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Icon(
+            if (isMet) Icons.Default.Check else Icons.Default.Close,
+            contentDescription = null,
+            modifier = Modifier.size(18.dp),
+            tint = if (isMet) {
+                MaterialTheme.colorScheme.primary
+            } else {
+                MaterialTheme.colorScheme.error
+            }
+        )
+        Text(
+            text = text,
+            style = MaterialTheme.typography.bodyMedium
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun PersonInfoDialog(
+    onDismiss: () -> Unit,
+    onConfirm: (name: String, dateOfBirth: Long?, relationship: String) -> Unit
+) {
+    var name by remember { mutableStateOf("") }
+    var dateOfBirth by remember { mutableStateOf<Long?>(null) }
+    var selectedRelationship by remember { mutableStateOf("Other") }
+    var showDatePicker by remember { mutableStateOf(false) }
+
+    val relationships = listOf(
+        "Family" to "👨‍👩‍👧‍👦",
+        "Friend" to "🤝",
+        "Partner" to "❤️",
+        "Child" to "👶",
+        "Parent" to "👪",
+        "Sibling" to "👫",
+        "Colleague" to "💼",
+        "Other" to "👤"
+    )
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = {
+            Column {
+                Text("Person Details")
+                Text(
+                    "Help us organize your photos",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        },
+        text = {
+            Column(
+                modifier = Modifier.fillMaxWidth(),
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
+                // Name field
+                OutlinedTextField(
+                    value = name,
+                    onValueChange = { name = it },
+                    label = { Text("Name *") },
+                    placeholder = { Text("e.g., John Doe") },
+                    leadingIcon = {
+                        Icon(Icons.Default.Person, contentDescription = null)
+                    },
+                    modifier = Modifier.fillMaxWidth(),
+                    singleLine = true
+                )
+
+                // Date of birth
+                OutlinedButton(
+                    onClick = { showDatePicker = true },
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    Icon(Icons.Default.Cake, contentDescription = null)
+                    Spacer(Modifier.width(8.dp))
+                    Text(
+                        if (dateOfBirth != null) {
+                            "Birthday: ${formatDate(dateOfBirth!!)}"
+                        } else {
+                            "Add Birthday (Optional)"
+                        }
+                    )
+                }
+
+                // Relationship selector
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    Text(
+                        "Relationship",
+                        style = MaterialTheme.typography.labelMedium
+                    )
+
+                    // Relationship chips
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        relationships.take(4).forEach { (rel, emoji) ->
+                            FilterChip(
+                                selected = selectedRelationship == rel,
+                                onClick = { selectedRelationship = rel },
+                                label = { Text("$emoji $rel") }
+                            )
+                        }
+                    }
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        relationships.drop(4).forEach { (rel, emoji) ->
+                            FilterChip(
+                                selected = selectedRelationship == rel,
+                                onClick = { selectedRelationship = rel },
+                                label = { Text("$emoji $rel") }
+                            )
+                        }
+                    }
+                }
+
+                // Privacy note
+                Card(
+                    colors = CardDefaults.cardColors(
+                        containerColor = MaterialTheme.colorScheme.surfaceVariant
+                    )
+                ) {
+                    Row(
+                        modifier = Modifier.padding(12.dp),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        Icon(
+                            Icons.Default.Lock,
+                            contentDescription = null,
+                            modifier = Modifier.size(16.dp),
+                            tint = MaterialTheme.colorScheme.primary
+                        )
+                        Text(
+                            "All data stays on your device",
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+            }
+        },
+        confirmButton = {
+            Button(
+                onClick = {
+                    if (name.isNotBlank()) {
+                        onConfirm(name, dateOfBirth, selectedRelationship)
+                    }
+                },
+                enabled = name.isNotBlank()
+            ) {
+                Text("Continue")
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text("Cancel")
+            }
+        }
+    )
+
+    // Date picker dialog
+    if (showDatePicker) {
+        DatePickerDialog(
+            onDismissRequest = { showDatePicker = false },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        // Get selected date from date picker
+                        // For now, set to current date as placeholder
+                        dateOfBirth = System.currentTimeMillis()
+                        showDatePicker = false
+                    }
+                ) {
+                    Text("OK")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showDatePicker = false }) {
+                    Text("Cancel")
+                }
+            }
+        ) {
+            // Material3 DatePicker
+            DatePicker(
+                state = rememberDatePickerState(),
+                modifier = Modifier.padding(16.dp)
+            )
+        }
+    }
+}
+
+private fun formatDate(timestamp: Long): String {
+    val formatter = SimpleDateFormat("MMM dd, yyyy", Locale.getDefault())
+    return formatter.format(Date(timestamp))
+}

app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Trainingsanitychecker.kt

@@ -5,7 +5,12 @@ import android.graphics.Bitmap
 import android.net.Uri
 
 /**
- * Coordinates sanity checks for training images
+ * ENHANCED TrainingSanityChecker
+ *
+ * New features:
+ * - Progress callbacks
+ * - Exclude functionality
+ * - Faster processing
  */
 class TrainingSanityChecker(private val context: Context) {
 
@@ -18,7 +23,8 @@ class TrainingSanityChecker(private val context: Context) {
         val duplicateCheckResult: DuplicateImageDetector.DuplicateCheckResult,
         val validationErrors: List<ValidationError>,
         val warnings: List<String>,
-        val validImagesWithFaces: List<ValidTrainingImage>
+        val validImagesWithFaces: List<ValidTrainingImage>,
+        val excludedImages: Set<Uri> = emptySet() // NEW: Track excluded images
     )
 
     data class ValidTrainingImage(
@@ -36,30 +42,42 @@ class TrainingSanityChecker(private val context: Context) {
     }
 
     /**
-     * Perform comprehensive sanity checks on training images
+     * Perform comprehensive sanity checks with PROGRESS tracking
      */
     suspend fun performSanityChecks(
         imageUris: List<Uri>,
-        minImagesRequired: Int = 10,
+        minImagesRequired: Int = 15,
         allowMultipleFaces: Boolean = false,
-        duplicateSimilarityThreshold: Double = 0.95
+        duplicateSimilarityThreshold: Double = 0.95,
+        excludedImages: Set<Uri> = emptySet(), // NEW: Allow excluding images
+        onProgress: ((String, Int, Int) -> Unit)? = null // NEW: Progress callback
     ): SanityCheckResult {
 
         val validationErrors = mutableListOf<ValidationError>()
         val warnings = mutableListOf<String>()
 
-        // Check minimum image count
-        if (imageUris.size < minImagesRequired) {
+        // Filter out excluded images
+        val activeImages = imageUris.filter { it !in excludedImages }
+
+        // Check minimum image count (AFTER exclusions)
+        if (activeImages.size < minImagesRequired) {
             validationErrors.add(
                 ValidationError.InsufficientImages(
                     required = minImagesRequired,
-                    available = imageUris.size
+                    available = activeImages.size
                 )
             )
         }
 
-        // Step 1: Detect faces in all images
-        val faceDetectionResults = faceDetectionHelper.detectFacesInImages(imageUris)
+        // Step 1: Detect faces in all images (WITH PROGRESS)
+        onProgress?.invoke("Detecting faces...", 0, activeImages.size)
+
+        val faceDetectionResults = faceDetectionHelper.detectFacesInImages(
+            uris = activeImages,
+            onProgress = { current, total ->
+                onProgress?.invoke("Detecting faces...", current, total)
+            }
+        )
 
         // Check for images without faces
         val imagesWithoutFaces = faceDetectionResults.filter { !it.hasFace }
@@ -98,8 +116,10 @@ class TrainingSanityChecker(private val context: Context) {
         }
 
         // Step 2: Check for duplicate images
+        onProgress?.invoke("Checking for duplicates...", activeImages.size, activeImages.size)
+
         val duplicateCheckResult = duplicateDetector.checkForDuplicates(
-            uris = imageUris,
+            uris = activeImages,
             similarityThreshold = duplicateSimilarityThreshold
         )
 
@@ -138,13 +158,16 @@ class TrainingSanityChecker(private val context: Context) {
 
         val isValid = validationErrors.isEmpty() && validImagesWithFaces.size >= minImagesRequired
 
+        onProgress?.invoke("Analysis complete", activeImages.size, activeImages.size)
+
         return SanityCheckResult(
             isValid = isValid,
             faceDetectionResults = faceDetectionResults,
             duplicateCheckResult = duplicateCheckResult,
             validationErrors = validationErrors,
             warnings = warnings,
-            validImagesWithFaces = validImagesWithFaces
+            validImagesWithFaces = validImagesWithFaces,
+            excludedImages = excludedImages
         )
     }
 
@@ -156,24 +179,20 @@ class TrainingSanityChecker(private val context: Context) {
             when (error) {
                 is ValidationError.NoFaceDetected -> {
                     val count = error.uris.size
-                    val images = error.uris.joinToString(", ") { it.lastPathSegment ?: "Unknown" }
-                    "No face detected in $count image(s): $images"
+                    "No face detected in $count image(s)"
                 }
                 is ValidationError.MultipleFacesDetected -> {
                     "Multiple faces (${error.faceCount}) detected in: ${error.uri.lastPathSegment}"
                 }
                 is ValidationError.DuplicateImages -> {
                     val count = error.groups.size
-                    val details = error.groups.joinToString("\n") { group ->
-                        "  - ${group.images.size} duplicates: ${group.images.joinToString(", ") { it.lastPathSegment ?: "Unknown" }}"
-                    }
-                    "Found $count duplicate group(s):\n$details"
+                    "Found $count duplicate group(s)"
                 }
                 is ValidationError.InsufficientImages -> {
-                    "Insufficient images: need ${error.required}, but only ${error.available} valid images available"
+                    "Need ${error.required} images, have ${error.available}"
                 }
                 is ValidationError.ImageLoadError -> {
-                    "Failed to load image ${error.uri.lastPathSegment}: ${error.error}"
+                    "Failed to load image: ${error.uri.lastPathSegment}"
                 }
             }
         }

app/src/main/java/com/placeholder/sherpai2/ui/utilities/Photoutilitiesscreen.kt

@@ -0,0 +1,447 @@
+package com.placeholder.sherpai2.ui.utilities
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+
+/**
+ * PhotoUtilitiesScreen - Manage photo collection
+ *
+ * Features:
+ * - Manual photo scan
+ * - Duplicate detection
+ * - Burst detection
+ * - Quality analysis
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun PhotoUtilitiesScreen(
+    viewModel: PhotoUtilitiesViewModel = hiltViewModel()
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val scanProgress by viewModel.scanProgress.collectAsStateWithLifecycle()
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = {
+                    Column {
+                        Text(
+                            "Photo Utilities",
+                            style = MaterialTheme.typography.titleLarge,
+                            fontWeight = FontWeight.Bold
+                        )
+                        Text(
+                            "Manage your photo collection",
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f)
+                )
+            )
+        }
+    ) { paddingValues ->
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues),
+            contentPadding = PaddingValues(16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            // Section: Scan & Import
+            item {
+                SectionHeader(
+                    title = "Scan & Import",
+                    icon = Icons.Default.Scanner
+                )
+            }
+
+            item {
+                UtilityCard(
+                    title = "Scan for Photos",
+                    description = "Search your device for new photos",
+                    icon = Icons.Default.PhotoLibrary,
+                    buttonText = "Scan Now",
+                    enabled = uiState !is UtilitiesUiState.Scanning,
+                    onClick = { viewModel.scanForPhotos() }
+                )
+            }
+
+            // Section: Organization
+            item {
+                Spacer(Modifier.height(8.dp))
+                SectionHeader(
+                    title = "Organization",
+                    icon = Icons.Default.Folder
+                )
+            }
+
+            item {
+                UtilityCard(
+                    title = "Detect Duplicates",
+                    description = "Find and tag duplicate photos",
+                    icon = Icons.Default.FileCopy,
+                    buttonText = "Find Duplicates",
+                    enabled = uiState !is UtilitiesUiState.Scanning,
+                    onClick = { viewModel.detectDuplicates() }
+                )
+            }
+
+            item {
+                UtilityCard(
+                    title = "Detect Bursts",
+                    description = "Group photos taken in rapid succession (3+ in 2 seconds)",
+                    icon = Icons.Default.BurstMode,
+                    buttonText = "Find Bursts",
+                    enabled = uiState !is UtilitiesUiState.Scanning,
+                    onClick = { viewModel.detectBursts() }
+                )
+            }
+
+            // Section: Quality
+            item {
+                Spacer(Modifier.height(8.dp))
+                SectionHeader(
+                    title = "Quality Analysis",
+                    icon = Icons.Default.HighQuality
+                )
+            }
+
+            item {
+                UtilityCard(
+                    title = "Find Screenshots & Blurry",
+                    description = "Identify screenshots and low-quality photos",
+                    icon = Icons.Default.PhoneAndroid,
+                    buttonText = "Analyze",
+                    enabled = uiState !is UtilitiesUiState.Scanning,
+                    onClick = { viewModel.analyzeQuality() }
+                )
+            }
+
+            // Progress indicator
+            if (scanProgress != null) {
+                item {
+                    ProgressCard(scanProgress!!)
+                }
+            }
+
+            // Results
+            when (val state = uiState) {
+                is UtilitiesUiState.ScanComplete -> {
+                    item {
+                        ResultCard(
+                            title = "Scan Complete",
+                            message = state.message,
+                            icon = Icons.Default.CheckCircle,
+                            iconTint = MaterialTheme.colorScheme.primary
+                        )
+                    }
+                }
+                is UtilitiesUiState.DuplicatesFound -> {
+                    item {
+                        ResultCard(
+                            title = "Duplicates Found",
+                            message = "Found ${state.groups.size} groups of duplicates (${state.groups.sumOf { it.images.size - 1 }} duplicate photos)",
+                            icon = Icons.Default.Info,
+                            iconTint = MaterialTheme.colorScheme.tertiary
+                        )
+                    }
+                }
+                is UtilitiesUiState.BurstsFound -> {
+                    item {
+                        ResultCard(
+                            title = "Bursts Found",
+                            message = "Found ${state.groups.size} burst sequences (${state.groups.sumOf { it.images.size }} photos total)",
+                            icon = Icons.Default.Info,
+                            iconTint = MaterialTheme.colorScheme.tertiary
+                        )
+                    }
+                }
+                is UtilitiesUiState.QualityAnalysisComplete -> {
+                    item {
+                        ResultCard(
+                            title = "Analysis Complete",
+                            message = "Screenshots: ${state.screenshots}\nBlurry: ${state.blurry}",
+                            icon = Icons.Default.CheckCircle,
+                            iconTint = MaterialTheme.colorScheme.primary
+                        )
+                    }
+                }
+                is UtilitiesUiState.Error -> {
+                    item {
+                        ResultCard(
+                            title = "Error",
+                            message = state.message,
+                            icon = Icons.Default.Error,
+                            iconTint = MaterialTheme.colorScheme.error
+                        )
+                    }
+                }
+                else -> {}
+            }
+
+            // Info card
+            item {
+                Spacer(Modifier.height(8.dp))
+                InfoCard()
+            }
+        }
+    }
+}
+
+@Composable
+private fun SectionHeader(
+    title: String,
+    icon: ImageVector
+) {
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        modifier = Modifier.padding(vertical = 8.dp)
+    ) {
+        Icon(
+            icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.primary,
+            modifier = Modifier.size(24.dp)
+        )
+        Text(
+            text = title,
+            style = MaterialTheme.typography.titleMedium,
+            fontWeight = FontWeight.Bold,
+            color = MaterialTheme.colorScheme.primary
+        )
+    }
+}
+
+@Composable
+private fun UtilityCard(
+    title: String,
+    description: String,
+    icon: ImageVector,
+    buttonText: String,
+    enabled: Boolean,
+    onClick: () -> Unit
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            // Icon
+            Surface(
+                shape = RoundedCornerShape(12.dp),
+                color = MaterialTheme.colorScheme.primaryContainer,
+                modifier = Modifier.size(56.dp)
+            ) {
+                Box(contentAlignment = Alignment.Center) {
+                    Icon(
+                        icon,
+                        contentDescription = null,
+                        modifier = Modifier.size(32.dp),
+                        tint = MaterialTheme.colorScheme.primary
+                    )
+                }
+            }
+
+            // Text
+            Column(
+                modifier = Modifier.weight(1f),
+                verticalArrangement = Arrangement.spacedBy(4.dp)
+            ) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold
+                )
+                Text(
+                    text = description,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+
+            // Button
+            Button(
+                onClick = onClick,
+                enabled = enabled
+            ) {
+                Text(buttonText)
+            }
+        }
+    }
+}
+
+@Composable
+private fun ProgressCard(progress: ScanProgress) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.secondaryContainer
+        )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                Text(
+                    text = progress.message,
+                    style = MaterialTheme.typography.bodyMedium,
+                    fontWeight = FontWeight.Medium
+                )
+                if (progress.total > 0) {
+                    Text(
+                        text = "${progress.current} / ${progress.total}",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+            }
+
+            if (progress.total > 0) {
+                LinearProgressIndicator(
+                    progress = { progress.current.toFloat() / progress.total.toFloat() },
+                    modifier = Modifier.fillMaxWidth()
+                )
+            } else {
+                LinearProgressIndicator(
+                    modifier = Modifier.fillMaxWidth()
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun ResultCard(
+    title: String,
+    message: String,
+    icon: ImageVector,
+    iconTint: androidx.compose.ui.graphics.Color
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = iconTint.copy(alpha = 0.1f)
+        )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Icon(
+                icon,
+                contentDescription = null,
+                tint = iconTint,
+                modifier = Modifier.size(32.dp)
+            )
+            Column(
+                verticalArrangement = Arrangement.spacedBy(4.dp)
+            ) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold
+                )
+                Text(
+                    text = message,
+                    style = MaterialTheme.typography.bodyMedium
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun InfoCard() {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant
+        )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Icon(
+                    Icons.Default.Info,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary
+                )
+                Text(
+                    text = "How It Works",
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Bold
+                )
+            }
+
+            InfoItem(
+                "Duplicates",
+                "Finds exact duplicates by comparing file content"
+            )
+            InfoItem(
+                "Bursts",
+                "Groups 3+ photos taken within 2 seconds. Tags one as 'representative' for albums"
+            )
+            InfoItem(
+                "Quality",
+                "Detects screenshots by screen dimensions. Blurry detection coming soon"
+            )
+        }
+    }
+}
+
+@Composable
+private fun InfoItem(title: String, description: String) {
+    Column(
+        verticalArrangement = Arrangement.spacedBy(2.dp)
+    ) {
+        Text(
+            text = "• $title",
+            style = MaterialTheme.typography.bodyMedium,
+            fontWeight = FontWeight.Medium
+        )
+        Text(
+            text = description,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.padding(start = 12.dp)
+        )
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/utilities/Photoutilitiesviewmodel.kt

@@ -0,0 +1,384 @@
+package com.placeholder.sherpai2.ui.utilities
+
+import android.graphics.Bitmap
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.local.dao.ImageDao
+import com.placeholder.sherpai2.data.local.dao.ImageTagDao
+import com.placeholder.sherpai2.data.local.dao.TagDao
+import com.placeholder.sherpai2.data.local.entity.ImageEntity
+import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
+import com.placeholder.sherpai2.data.local.entity.TagEntity
+import com.placeholder.sherpai2.domain.repository.ImageRepository
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.util.UUID
+import javax.inject.Inject
+import kotlin.math.abs
+
+/**
+ * PhotoUtilitiesViewModel - Photo collection management
+ *
+ * Features:
+ * 1. Manual photo scan/rescan
+ * 2. Duplicate detection (SHA256 + perceptual hash)
+ * 3. Burst detection (photos within 2 seconds)
+ * 4. Quality analysis (blurry, screenshots)
+ */
+@HiltViewModel
+class PhotoUtilitiesViewModel @Inject constructor(
+    private val imageRepository: ImageRepository,
+    private val imageDao: ImageDao,
+    private val tagDao: TagDao,
+    private val imageTagDao: ImageTagDao
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow<UtilitiesUiState>(UtilitiesUiState.Idle)
+    val uiState: StateFlow<UtilitiesUiState> = _uiState.asStateFlow()
+
+    private val _scanProgress = MutableStateFlow<ScanProgress?>(null)
+    val scanProgress: StateFlow<ScanProgress?> = _scanProgress.asStateFlow()
+
+    /**
+     * Manual scan for new photos
+     */
+    fun scanForPhotos() {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                _uiState.value = UtilitiesUiState.Scanning("photos")
+                _scanProgress.value = ScanProgress("Scanning device...", 0, 0)
+
+                val beforeCount = imageDao.getImageCount()
+
+                imageRepository.ingestImagesWithProgress { current, total ->
+                    _scanProgress.value = ScanProgress(
+                        "Found $current photos...",
+                        current,
+                        total
+                    )
+                }
+
+                val afterCount = imageDao.getImageCount()
+                val newPhotos = afterCount - beforeCount
+
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.ScanComplete(
+                        "Found $newPhotos new photos",
+                        newPhotos
+                    )
+                    _scanProgress.value = null
+                }
+
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.Error(
+                        e.message ?: "Failed to scan photos"
+                    )
+                    _scanProgress.value = null
+                }
+            }
+        }
+    }
+
+    /**
+     * Detect duplicate photos
+     */
+    fun detectDuplicates() {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                _uiState.value = UtilitiesUiState.Scanning("duplicates")
+                _scanProgress.value = ScanProgress("Analyzing photos...", 0, 0)
+
+                val allImages = imageDao.getAllImages()
+                val duplicateGroups = mutableListOf<DuplicateGroup>()
+
+                // Group by SHA256
+                val sha256Groups = allImages.groupBy { it.sha256 }
+
+                var processed = 0
+                sha256Groups.forEach { (sha256, images) ->
+                    if (images.size > 1) {
+                        // Found duplicates!
+                        duplicateGroups.add(
+                            DuplicateGroup(
+                                images = images,
+                                reason = "Exact duplicate (same file content)",
+                                confidence = 1.0f
+                            )
+                        )
+                    }
+                    processed++
+
+                    if (processed % 100 == 0) {
+                        _scanProgress.value = ScanProgress(
+                            "Checked $processed photos...",
+                            processed,
+                            sha256Groups.size
+                        )
+                    }
+                }
+
+                // Tag duplicates
+                val duplicateTag = getOrCreateTag("duplicate", "SYSTEM")
+                duplicateGroups.forEach { group ->
+                    // Tag all but the first image (keep one, mark rest as dupes)
+                    group.images.drop(1).forEach { image ->
+                        tagImage(image.imageId, duplicateTag.tagId)
+                    }
+                }
+
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.DuplicatesFound(duplicateGroups)
+                    _scanProgress.value = null
+                }
+
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.Error(
+                        e.message ?: "Failed to detect duplicates"
+                    )
+                    _scanProgress.value = null
+                }
+            }
+        }
+    }
+
+    /**
+     * Detect burst photos (rapid succession)
+     */
+    fun detectBursts() {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                _uiState.value = UtilitiesUiState.Scanning("bursts")
+                _scanProgress.value = ScanProgress("Analyzing timestamps...", 0, 0)
+
+                val allImages = imageDao.getAllImagesSortedByTime()
+                val burstGroups = mutableListOf<BurstGroup>()
+
+                // Group photos taken within 2 seconds of each other
+                val burstThresholdMs = 2000L
+                var currentBurst = mutableListOf<ImageEntity>()
+
+                allImages.forEachIndexed { index, image ->
+                    if (currentBurst.isEmpty()) {
+                        currentBurst.add(image)
+                    } else {
+                        val lastImage = currentBurst.last()
+                        val timeDiff = abs(image.capturedAt - lastImage.capturedAt)
+
+                        if (timeDiff <= burstThresholdMs) {
+                            // Part of current burst
+                            currentBurst.add(image)
+                        } else {
+                            // End of burst
+                            if (currentBurst.size >= 3) {
+                                // Only consider bursts with 3+ photos
+                                burstGroups.add(
+                                    BurstGroup(
+                                        images = currentBurst.toList(),
+                                        burstId = UUID.randomUUID().toString(),
+                                        representativeIndex = currentBurst.size / 2 // Middle photo
+                                    )
+                                )
+                            }
+                            currentBurst = mutableListOf(image)
+                        }
+                    }
+
+                    if (index % 100 == 0) {
+                        _scanProgress.value = ScanProgress(
+                            "Checked $index photos...",
+                            index,
+                            allImages.size
+                        )
+                    }
+                }
+
+                // Check last burst
+                if (currentBurst.size >= 3) {
+                    burstGroups.add(
+                        BurstGroup(
+                            images = currentBurst,
+                            burstId = UUID.randomUUID().toString(),
+                            representativeIndex = currentBurst.size / 2
+                        )
+                    )
+                }
+
+                // Tag bursts
+                val burstTag = getOrCreateTag("burst", "SYSTEM")
+                burstGroups.forEach { group ->
+                    group.images.forEach { image ->
+                        tagImage(image.imageId, burstTag.tagId)
+
+                        // Tag the representative photo specially
+                        if (image == group.images[group.representativeIndex]) {
+                            val burstRepTag = getOrCreateTag("burst_representative", "SYSTEM")
+                            tagImage(image.imageId, burstRepTag.tagId)
+                        }
+                    }
+                }
+
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.BurstsFound(burstGroups)
+                    _scanProgress.value = null
+                }
+
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.Error(
+                        e.message ?: "Failed to detect bursts"
+                    )
+                    _scanProgress.value = null
+                }
+            }
+        }
+    }
+
+    /**
+     * Detect screenshots and low quality photos
+     */
+    fun analyzeQuality() {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                _uiState.value = UtilitiesUiState.Scanning("quality")
+                _scanProgress.value = ScanProgress("Analyzing quality...", 0, 0)
+
+                val allImages = imageDao.getAllImages()
+                val screenshotTag = getOrCreateTag("screenshot", "SYSTEM")
+                val blurryTag = getOrCreateTag("blurry", "SYSTEM")
+
+                var screenshotCount = 0
+                var blurryCount = 0
+
+                allImages.forEachIndexed { index, image ->
+                    // Detect screenshots by dimensions (screen-sized)
+                    val isScreenshot = isLikelyScreenshot(image.width, image.height)
+                    if (isScreenshot) {
+                        tagImage(image.imageId, screenshotTag.tagId)
+                        screenshotCount++
+                    }
+
+                    // TODO: Detect blurry photos (requires bitmap analysis)
+                    // For now, skip blur detection
+
+                    if (index % 50 == 0) {
+                        _scanProgress.value = ScanProgress(
+                            "Analyzed $index photos...",
+                            index,
+                            allImages.size
+                        )
+                    }
+                }
+
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.QualityAnalysisComplete(
+                        screenshots = screenshotCount,
+                        blurry = blurryCount
+                    )
+                    _scanProgress.value = null
+                }
+
+            } catch (e: Exception) {
+                withContext(Dispatchers.Main) {
+                    _uiState.value = UtilitiesUiState.Error(
+                        e.message ?: "Failed to analyze quality"
+                    )
+                    _scanProgress.value = null
+                }
+            }
+        }
+    }
+
+    /**
+     * Detect screenshots by common screen dimensions
+     */
+    private fun isLikelyScreenshot(width: Int, height: Int): Boolean {
+        val commonScreenRatios = listOf(
+            16.0 / 9.0,   // 1080x1920, 1440x2560
+            19.5 / 9.0,   // 1080x2340 (iPhone X)
+            20.0 / 9.0,   // 1080x2400
+            18.5 / 9.0,   // 1080x2220
+            19.0 / 9.0    // 1080x2280
+        )
+
+        val imageRatio = if (width > height) {
+            width.toDouble() / height.toDouble()
+        } else {
+            height.toDouble() / width.toDouble()
+        }
+
+        return commonScreenRatios.any { screenRatio ->
+            abs(imageRatio - screenRatio) < 0.1
+        }
+    }
+
+    private suspend fun getOrCreateTag(value: String, type: String): TagEntity {
+        return tagDao.getByValue(value) ?: run {
+            val tag = TagEntity(
+                tagId = UUID.randomUUID().toString(),
+                type = type,
+                value = value,
+                createdAt = System.currentTimeMillis()
+            )
+            tagDao.insert(tag)
+            tag
+        }
+    }
+
+    private suspend fun tagImage(imageId: String, tagId: String) {
+        val imageTag = ImageTagEntity(
+            imageId = imageId,
+            tagId = tagId,
+            source = "AUTO",
+            confidence = 1.0f,
+            visibility = "PUBLIC",
+            createdAt = System.currentTimeMillis()
+        )
+        imageTagDao.insert(imageTag)
+    }
+
+    fun resetState() {
+        _uiState.value = UtilitiesUiState.Idle
+        _scanProgress.value = null
+    }
+}
+
+/**
+ * UI State
+ */
+sealed class UtilitiesUiState {
+    object Idle : UtilitiesUiState()
+    data class Scanning(val type: String) : UtilitiesUiState()
+    data class ScanComplete(val message: String, val count: Int) : UtilitiesUiState()
+    data class DuplicatesFound(val groups: List<DuplicateGroup>) : UtilitiesUiState()
+    data class BurstsFound(val groups: List<BurstGroup>) : UtilitiesUiState()
+    data class QualityAnalysisComplete(
+        val screenshots: Int,
+        val blurry: Int
+    ) : UtilitiesUiState()
+    data class Error(val message: String) : UtilitiesUiState()
+}
+
+data class ScanProgress(
+    val message: String,
+    val current: Int,
+    val total: Int
+)
+
+data class DuplicateGroup(
+    val images: List<ImageEntity>,
+    val reason: String,
+    val confidence: Float
+)
+
+data class BurstGroup(
+    val images: List<ImageEntity>,
+    val burstId: String,
+    val representativeIndex: Int // Which photo to show in albums
+)

app/src/main/java/com/placeholder/sherpai2/util/DebugFlags.kt

@@ -0,0 +1,68 @@
+package com.placeholder.sherpai2.util
+
+/**
+ * Debug feature flags
+ *
+ * Toggle these to enable/disable diagnostic features
+ * Set to false before release builds!
+ */
+object DebugFlags {
+
+    /**
+     * Enable verbose face recognition logging
+     *
+     * When true:
+     * - Logs every face detection
+     * - Logs similarity scores
+     * - Logs matching decisions
+     * - Shows why images are skipped
+     *
+     * Filter Logcat by: "FaceRecognition"
+     */
+    const val ENABLE_FACE_RECOGNITION_LOGGING = true  // ← Toggle here
+
+    /**
+     * Show confidence scores in UI
+     */
+    const val SHOW_CONFIDENCE_IN_UI = true  // ← Toggle here
+
+    /**
+     * Lower thresholds for better recall (more matches, some false positives)
+     */
+    const val USE_LIBERAL_THRESHOLDS = true  // ← Toggle here
+}
+
+/**
+ * Diagnostic logger - only logs when flag is enabled
+ */
+object DiagnosticLogger {
+    private const val TAG = "FaceRecognition"
+
+    fun d(message: String) {
+        if (DebugFlags.ENABLE_FACE_RECOGNITION_LOGGING) {
+            android.util.Log.d(TAG, message)
+        }
+    }
+
+    fun i(message: String) {
+        if (DebugFlags.ENABLE_FACE_RECOGNITION_LOGGING) {
+            android.util.Log.i(TAG, message)
+        }
+    }
+
+    fun w(message: String) {
+        if (DebugFlags.ENABLE_FACE_RECOGNITION_LOGGING) {
+            android.util.Log.w(TAG, message)
+        }
+    }
+
+    fun e(message: String, throwable: Throwable? = null) {
+        if (DebugFlags.ENABLE_FACE_RECOGNITION_LOGGING) {
+            if (throwable != null) {
+                android.util.Log.e(TAG, message, throwable)
+            } else {
+                android.util.Log.e(TAG, message)
+            }
+        }
+    }
+}

build.gradle.kts

@@ -8,4 +8,5 @@ plugins {
     //https://github.com/google/dagger/issues/4048#issuecomment-1864237679
     alias(libs.plugins.ksp) apply false
     alias(libs.plugins.hilt.android) apply false
+
 }

gradle.properties

@@ -21,3 +21,4 @@ kotlin.code.style=official
 # resources declared in the library itself and none from the library's dependencies,
 # thereby reducing the size of the R class for that library
 android.nonTransitiveRClass=true
+org.gradle.java.home=/snap/android-studio/current/jbr