Oh yes - Thats how we do

No default params for KSP complainer fuck

UI sweeps

.idea/deviceManager.xml

@@ -5,25 +5,9 @@
       <list>
         <ColumnSorterState>
           <option name="column" value="Name" />
-          <option name="order" value="DESCENDING" />
+          <option name="order" value="ASCENDING" />
         </ColumnSorterState>
       </list>
     </option>
-    <option name="groupByAttributes">
-      <list>
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-        <option value="Type" />
-      </list>
-    </option>
   </component>
 </project>

app/build.gradle.kts

@@ -85,16 +85,4 @@ dependencies {
 
     // Gson for storing FloatArrays in Room
     implementation(libs.gson)
-
-    // Zoomable
-    implementation(libs.zoomable)
-    implementation(libs.vico.compose)
-    implementation(libs.vico.compose.m3)
-    implementation(libs.vico.core)
-
-    // Workers
-    implementation(libs.androidx.work.runtime.ktx)
-    implementation(libs.androidx.hilt.work)
-        
-
 }

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

@@ -8,42 +8,26 @@ 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.*
+import androidx.compose.foundation.layout.Box
-import androidx.compose.material3.*
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Text
 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.domain.usecase.PopulateFaceDetectionCacheUseCase
 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 - TWO-PHASE STARTUP
- *
- * Phase 1: Image ingestion (fast - just loads URIs)
- * Phase 2: Face detection cache (slower - scans for faces)
- *
- * App is usable immediately, both run in background.
- */
 @AndroidEntryPoint
 class MainActivity : ComponentActivity() {
 
     @Inject
     lateinit var imageRepository: ImageRepository
 
-    @Inject
-    lateinit var populateFaceCache: PopulateFaceDetectionCacheUseCase
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
@@ -62,8 +46,8 @@ class MainActivity : ComponentActivity() {
                     )
                 }
 
-                var ingestionState by remember { mutableStateOf<IngestionState>(IngestionState.NotStarted) }
+                var isIngesting by remember { mutableStateOf(false) }
-                var cacheState by remember { mutableStateOf<CacheState>(CacheState.NotStarted) }
+                var imagesIngested by remember { mutableStateOf(false) }
 
                 val permissionLauncher = rememberLauncherForActivityResult(
                     ActivityResultContracts.RequestPermission()
@@ -71,126 +55,35 @@ class MainActivity : ComponentActivity() {
                     hasPermission = granted
                 }
 
-                // Phase 1: Image ingestion
+                // Logic: Handle the flow of Permission -> Ingestion
                 LaunchedEffect(hasPermission) {
-                    if (hasPermission && ingestionState is IngestionState.NotStarted) {
+                    if (hasPermission) {
-                        ingestionState = IngestionState.InProgress(0, 0)
+                        if (!imagesIngested && !isIngesting) {
-
+                            isIngesting = true
-                        lifecycleScope.launch(Dispatchers.IO) {
+                            imageRepository.ingestImages()
-                            try {
+                            imagesIngested = true
-                                val existingCount = imageRepository.getImageCount()
+                            isIngesting = false
-
-                                if (existingCount > 0) {
-                                    withContext(Dispatchers.Main) {
-                                        ingestionState = IngestionState.Complete(existingCount)
                         }
                     } else {
-                                    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)
                     }
                 }
 
-                // Phase 2: Face detection cache population
+                // UI State Mapping
-                LaunchedEffect(ingestionState) {
-                    if (ingestionState is IngestionState.Complete && cacheState is CacheState.NotStarted) {
-                        lifecycleScope.launch(Dispatchers.IO) {
-                            try {
-                                // Check if cache needs population
-                                val stats = populateFaceCache.getCacheStats()
-
-                                if (stats.needsScanning == 0) {
-                                    withContext(Dispatchers.Main) {
-                                        cacheState = CacheState.Complete(stats.imagesWithFaces, stats.imagesWithoutFaces)
-                                    }
-                                } else {
-                                    withContext(Dispatchers.Main) {
-                                        cacheState = CacheState.InProgress(0, stats.needsScanning)
-                                    }
-
-                                    populateFaceCache.execute { current, total, _ ->
-                                        cacheState = CacheState.InProgress(current, total)
-                                    }
-
-                                    val finalStats = populateFaceCache.getCacheStats()
-                                    withContext(Dispatchers.Main) {
-                                        cacheState = CacheState.Complete(
-                                            finalStats.imagesWithFaces,
-                                            finalStats.imagesWithoutFaces
-                                        )
-                                    }
-                                }
-                            } catch (e: Exception) {
-                                withContext(Dispatchers.Main) {
-                                    cacheState = CacheState.Error(e.message ?: "Failed to scan faces")
-                                }
-                            }
-                        }
-                    }
-                }
-
-                // UI
-                Box(modifier = Modifier.fillMaxSize()) {
-                    when {
-                        hasPermission -> {
-                            // Main screen always visible
-                            MainScreen()
-
-                            // Progress overlays at bottom with navigation bar clearance
-                            Column(
-                                modifier = Modifier
-                                    .fillMaxSize()
-                                    .padding(horizontal = 16.dp)
-                                    .padding(bottom = 120.dp), // More space for nav bar + gestures
-                                verticalArrangement = Arrangement.Bottom
-                            ) {
-                                if (ingestionState is IngestionState.InProgress) {
-                                    IngestionProgressCard(ingestionState as IngestionState.InProgress)
-                                    Spacer(Modifier.height(8.dp))
-                                }
-
-                                if (cacheState is CacheState.InProgress) {
-                                    FaceCacheProgressCard(cacheState as CacheState.InProgress)
-                                }
-                            }
-                        }
-                        else -> {
                 Box(
                     modifier = Modifier.fillMaxSize(),
                     contentAlignment = Alignment.Center
                 ) {
-                                Column(
+                    when {
-                                    horizontalAlignment = Alignment.CenterHorizontally,
+                        hasPermission && imagesIngested -> {
-                                    verticalArrangement = Arrangement.spacedBy(16.dp)
+                            MainScreen()
-                                ) {
-                                    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")
-                                    }
                         }
+                        hasPermission && isIngesting -> {
+                            // Show a loader so you know it's working!
+                            CircularProgressIndicator()
                         }
+                        else -> {
+                            Text("Please grant storage permission to continue.")
                         }
                     }
                 }
@@ -198,123 +91,3 @@ class MainActivity : ComponentActivity() {
         }
     }
 }
-
-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()
-}
-
-sealed class CacheState {
-    object NotStarted : CacheState()
-    data class InProgress(val current: Int, val total: Int) : CacheState()
-    data class Complete(val withFaces: Int, val withoutFaces: Int) : CacheState()
-    data class Error(val message: String) : CacheState()
-}
-
-@Composable
-fun IngestionProgressCard(state: IngestionState.InProgress) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        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 use the app while photos load",
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-    }
-}
-
-@Composable
-fun FaceCacheProgressCard(state: CacheState.InProgress) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.secondaryContainer
-        ),
-        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 = "Scanning for faces...",
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
-                )
-
-                if (state.total > 0) {
-                    Text(
-                        text = "${state.current} / ${state.total}",
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.secondary
-                    )
-                }
-            }
-
-            if (state.total > 0) {
-                LinearProgressIndicator(
-                    progress = { state.current.toFloat() / state.total.toFloat() },
-                    modifier = Modifier.fillMaxWidth(),
-                )
-            } else {
-                LinearProgressIndicator(modifier = Modifier.fillMaxWidth())
-            }
-
-            Text(
-                text = "Face filters will work once scanning completes",
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-    }
-}

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

@@ -1,24 +1,7 @@
 package com.placeholder.sherpai2
 
 import android.app.Application
-import androidx.hilt.work.HiltWorkerFactory
-import androidx.work.Configuration
 import dagger.hilt.android.HiltAndroidApp
-import javax.inject.Inject
 
-/**
- * SherpAIApplication - ENHANCED with WorkManager support
- *
- * Now supports background cache population via Hilt Workers
- */
 @HiltAndroidApp
-class SherpAIApplication : Application(), Configuration.Provider {
+class SherpAIApplication : Application()
-
-    @Inject
-    lateinit var workerFactory: HiltWorkerFactory
-
-    override val workManagerConfiguration: Configuration
-        get() = Configuration.Builder()
-            .setWorkerFactory(workerFactory)
-            .build()
-}

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

@@ -2,49 +2,39 @@ package com.placeholder.sherpai2.data.local
 
 import androidx.room.Database
 import androidx.room.RoomDatabase
-import androidx.sqlite.db.SupportSQLiteDatabase
-import androidx.room.migration.Migration
 import com.placeholder.sherpai2.data.local.dao.*
 import com.placeholder.sherpai2.data.local.entity.*
 
 /**
  * AppDatabase - Complete database for SherpAI2
  *
- * VERSION 8 - PHASE 2: Multi-centroid face models + age tagging
+ * ENTITIES:
- * - Added PersonEntity.isChild, siblingIds, familyGroupId
+ * - YOUR EXISTING: Image, Tag, Event, junction tables
- * - Changed FaceModelEntity.embedding → centroidsJson (multi-centroid)
+ * - NEW: PersonEntity (people in your app)
- * - Added PersonAgeTagEntity table for searchable age tags
+ * - NEW: FaceModelEntity (face embeddings, links to PersonEntity)
- *
+ * - NEW: PhotoFaceTagEntity (face detections, links to ImageEntity + FaceModelEntity)
- * MIGRATION STRATEGY:
- * - Development: fallbackToDestructiveMigration (fresh install)
- * - Production: Add MIGRATION_7_8 before release
  */
 @Database(
     entities = [
-        // ===== CORE ENTITIES =====
+        // ===== YOUR EXISTING ENTITIES =====
         ImageEntity::class,
         TagEntity::class,
         EventEntity::class,
         ImageTagEntity::class,
         ImageEventEntity::class,
 
-        // ===== FACE RECOGNITION =====
+        // ===== NEW ENTITIES =====
-        PersonEntity::class,
+        PersonEntity::class,         // NEW: People
-        FaceModelEntity::class,
+        FaceModelEntity::class,      // NEW: Face embeddings
-        PhotoFaceTagEntity::class,
+        PhotoFaceTagEntity::class    // NEW: Face tags
-        PersonAgeTagEntity::class,        // NEW: Age tagging
-
-        // ===== COLLECTIONS =====
-        CollectionEntity::class,
-        CollectionImageEntity::class,
-        CollectionFilterEntity::class
     ],
-    version = 8,  // INCREMENTED for Phase 2
+    version = 5,
     exportSchema = false
 )
+// No TypeConverters needed - embeddings stored as strings
 abstract class AppDatabase : RoomDatabase() {
 
-    // ===== CORE DAOs =====
+    // ===== YOUR EXISTING DAOs =====
     abstract fun imageDao(): ImageDao
     abstract fun tagDao(): TagDao
     abstract fun eventDao(): EventDao
@@ -52,115 +42,8 @@ abstract class AppDatabase : RoomDatabase() {
     abstract fun imageEventDao(): ImageEventDao
     abstract fun imageAggregateDao(): ImageAggregateDao
 
-    // ===== FACE RECOGNITION DAOs =====
+    // ===== NEW DAOs =====
-    abstract fun personDao(): PersonDao
+    abstract fun personDao(): PersonDao              // NEW: Manage people
-    abstract fun faceModelDao(): FaceModelDao
+    abstract fun faceModelDao(): FaceModelDao        // NEW: Manage face embeddings
-    abstract fun photoFaceTagDao(): PhotoFaceTagDao
+    abstract fun photoFaceTagDao(): PhotoFaceTagDao  // NEW: Manage face tags
-    abstract fun personAgeTagDao(): PersonAgeTagDao  // NEW
-
-    // ===== COLLECTIONS DAO =====
-    abstract fun collectionDao(): CollectionDao
 }
-
-/**
- * MIGRATION 7 → 8 (Phase 2)
- *
- * Changes:
- * 1. Add isChild, siblingIds, familyGroupId to persons table
- * 2. Rename embedding → centroidsJson in face_models table
- * 3. Create person_age_tags table
- */
-val MIGRATION_7_8 = object : Migration(7, 8) {
-    override fun migrate(database: SupportSQLiteDatabase) {
-
-        // ===== STEP 1: Update persons table =====
-        database.execSQL("ALTER TABLE persons ADD COLUMN isChild INTEGER NOT NULL DEFAULT 0")
-        database.execSQL("ALTER TABLE persons ADD COLUMN siblingIds TEXT DEFAULT NULL")
-        database.execSQL("ALTER TABLE persons ADD COLUMN familyGroupId TEXT DEFAULT NULL")
-
-        // Create index on familyGroupId for sibling queries
-        database.execSQL("CREATE INDEX IF NOT EXISTS index_persons_familyGroupId ON persons(familyGroupId)")
-
-        // ===== STEP 2: Update face_models table =====
-        // Rename embedding column to centroidsJson
-        // SQLite doesn't support RENAME COLUMN directly, so we need to:
-        // 1. Create new table with new schema
-        // 2. Copy data (converting single embedding to centroid JSON)
-        // 3. Drop old table
-        // 4. Rename new table
-
-        // Create new table
-        database.execSQL("""
-            CREATE TABLE IF NOT EXISTS face_models_new (
-                id TEXT PRIMARY KEY NOT NULL,
-                personId TEXT NOT NULL,
-                centroidsJson TEXT NOT NULL,
-                trainingImageCount INTEGER NOT NULL,
-                averageConfidence REAL NOT NULL,
-                createdAt INTEGER NOT NULL,
-                updatedAt INTEGER NOT NULL,
-                lastUsed INTEGER,
-                isActive INTEGER NOT NULL,
-                FOREIGN KEY(personId) REFERENCES persons(id) ON DELETE CASCADE
-            )
-        """)
-
-        // Copy data, converting embedding to centroidsJson format
-        // This converts single embedding to a list with one centroid
-        database.execSQL("""
-            INSERT INTO face_models_new 
-            SELECT 
-                id,
-                personId,
-                '[{"embedding":' || REPLACE(REPLACE(embedding, ',', ','), ',', ',') || ',"effectiveTimestamp":' || createdAt || ',"ageAtCapture":null,"photoCount":' || trainingImageCount || ',"timeRangeMonths":12,"avgConfidence":' || averageConfidence || '}]' as centroidsJson,
-                trainingImageCount,
-                averageConfidence,
-                createdAt,
-                updatedAt,
-                lastUsed,
-                isActive
-            FROM face_models
-        """)
-
-        // Drop old table
-        database.execSQL("DROP TABLE face_models")
-
-        // Rename new table
-        database.execSQL("ALTER TABLE face_models_new RENAME TO face_models")
-
-        // Recreate index
-        database.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS index_face_models_personId ON face_models(personId)")
-
-        // ===== STEP 3: Create person_age_tags table =====
-        database.execSQL("""
-            CREATE TABLE IF NOT EXISTS person_age_tags (
-                id TEXT PRIMARY KEY NOT NULL,
-                personId TEXT NOT NULL,
-                imageId TEXT NOT NULL,
-                ageAtCapture INTEGER NOT NULL,
-                tagValue TEXT NOT NULL,
-                confidence REAL NOT NULL,
-                createdAt INTEGER NOT NULL,
-                FOREIGN KEY(personId) REFERENCES persons(id) ON DELETE CASCADE,
-                FOREIGN KEY(imageId) REFERENCES images(imageId) ON DELETE CASCADE
-            )
-        """)
-
-        // Create indices for fast lookups
-        database.execSQL("CREATE INDEX IF NOT EXISTS index_person_age_tags_personId ON person_age_tags(personId)")
-        database.execSQL("CREATE INDEX IF NOT EXISTS index_person_age_tags_imageId ON person_age_tags(imageId)")
-        database.execSQL("CREATE INDEX IF NOT EXISTS index_person_age_tags_ageAtCapture ON person_age_tags(ageAtCapture)")
-        database.execSQL("CREATE INDEX IF NOT EXISTS index_person_age_tags_tagValue ON person_age_tags(tagValue)")
-    }
-}
-
-/**
- * PRODUCTION MIGRATION NOTES:
- *
- * Before shipping to users, update DatabaseModule to use migration:
- *
- * Room.databaseBuilder(context, AppDatabase::class.java, "sherpai.db")
- *     .addMigrations(MIGRATION_7_8)  // Add this
- *     // .fallbackToDestructiveMigration()  // Remove this
- *     .build()
- */

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

@@ -1,216 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.*
-import com.placeholder.sherpai2.data.local.entity.*
-import com.placeholder.sherpai2.data.local.model.CollectionWithDetails
-import kotlinx.coroutines.flow.Flow
-
-/**
- * CollectionDao - Manage user collections
- */
-@Dao
-interface CollectionDao {
-
-    // ==========================================
-    // BASIC OPERATIONS
-    // ==========================================
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insert(collection: CollectionEntity): Long
-
-    @Update
-    suspend fun update(collection: CollectionEntity)
-
-    @Delete
-    suspend fun delete(collection: CollectionEntity)
-
-    @Query("DELETE FROM collections WHERE collectionId = :collectionId")
-    suspend fun deleteById(collectionId: String)
-
-    @Query("SELECT * FROM collections WHERE collectionId = :collectionId")
-    suspend fun getById(collectionId: String): CollectionEntity?
-
-    @Query("SELECT * FROM collections WHERE collectionId = :collectionId")
-    fun getByIdFlow(collectionId: String): Flow<CollectionEntity?>
-
-    // ==========================================
-    // LIST QUERIES
-    // ==========================================
-
-    /**
-     * Get all collections ordered by pinned, then by creation date
-     */
-    @Query("""
-        SELECT * FROM collections
-        ORDER BY isPinned DESC, createdAt DESC
-    """)
-    fun getAllCollections(): Flow<List<CollectionEntity>>
-
-    @Query("""
-        SELECT * FROM collections
-        WHERE type = :type
-        ORDER BY isPinned DESC, createdAt DESC
-    """)
-    fun getCollectionsByType(type: String): Flow<List<CollectionEntity>>
-
-    @Query("SELECT * FROM collections WHERE type = 'FAVORITE' LIMIT 1")
-    suspend fun getFavoriteCollection(): CollectionEntity?
-
-    // ==========================================
-    // COLLECTION WITH DETAILS
-    // ==========================================
-
-    /**
-     * Get collection with actual photo count
-     */
-    @Transaction
-    @Query("""
-        SELECT 
-            c.*,
-            (SELECT COUNT(*) 
-             FROM collection_images ci
-             WHERE ci.collectionId = c.collectionId) as actualPhotoCount
-        FROM collections c
-        WHERE c.collectionId = :collectionId
-    """)
-    fun getCollectionWithDetails(collectionId: String): Flow<CollectionWithDetails?>
-
-    // ==========================================
-    // IMAGE MANAGEMENT
-    // ==========================================
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun addImage(collectionImage: CollectionImageEntity)
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun addImages(collectionImages: List<CollectionImageEntity>)
-
-    @Query("""
-        DELETE FROM collection_images
-        WHERE collectionId = :collectionId AND imageId = :imageId
-    """)
-    suspend fun removeImage(collectionId: String, imageId: String)
-
-    @Query("DELETE FROM collection_images WHERE collectionId = :collectionId")
-    suspend fun clearAllImages(collectionId: String)
-
-    @Query("""
-        SELECT i.* FROM images i
-        JOIN collection_images ci ON i.imageId = ci.imageId
-        WHERE ci.collectionId = :collectionId
-        ORDER BY ci.sortOrder ASC, ci.addedAt DESC
-    """)
-    fun getImagesInCollection(collectionId: String): Flow<List<ImageEntity>>
-
-    @Query("""
-        SELECT i.* FROM images i
-        JOIN collection_images ci ON i.imageId = ci.imageId
-        WHERE ci.collectionId = :collectionId
-        ORDER BY ci.sortOrder ASC, ci.addedAt DESC
-        LIMIT 4
-    """)
-    suspend fun getPreviewImages(collectionId: String): List<ImageEntity>
-
-    @Query("""
-        SELECT COUNT(*) FROM collection_images
-        WHERE collectionId = :collectionId
-    """)
-    suspend fun getPhotoCount(collectionId: String): Int
-
-    @Query("""
-        SELECT EXISTS(
-            SELECT 1 FROM collection_images
-            WHERE collectionId = :collectionId AND imageId = :imageId
-        )
-    """)
-    suspend fun containsImage(collectionId: String, imageId: String): Boolean
-
-    // ==========================================
-    // FILTER MANAGEMENT (for SMART collections)
-    // ==========================================
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insertFilter(filter: CollectionFilterEntity)
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insertFilters(filters: List<CollectionFilterEntity>)
-
-    @Query("DELETE FROM collection_filters WHERE collectionId = :collectionId")
-    suspend fun clearFilters(collectionId: String)
-
-    @Query("""
-        SELECT * FROM collection_filters
-        WHERE collectionId = :collectionId
-        ORDER BY createdAt ASC
-    """)
-    suspend fun getFilters(collectionId: String): List<CollectionFilterEntity>
-
-    @Query("""
-        SELECT * FROM collection_filters
-        WHERE collectionId = :collectionId
-        ORDER BY createdAt ASC
-    """)
-    fun getFiltersFlow(collectionId: String): Flow<List<CollectionFilterEntity>>
-
-    // ==========================================
-    // STATISTICS
-    // ==========================================
-
-    @Query("SELECT COUNT(*) FROM collections")
-    suspend fun getCollectionCount(): Int
-
-    @Query("SELECT COUNT(*) FROM collections WHERE type = 'SMART'")
-    suspend fun getSmartCollectionCount(): Int
-
-    @Query("SELECT COUNT(*) FROM collections WHERE type = 'STATIC'")
-    suspend fun getStaticCollectionCount(): Int
-
-    @Query("""
-        SELECT SUM(photoCount) FROM collections
-    """)
-    suspend fun getTotalPhotosInCollections(): Int?
-
-    // ==========================================
-    // UPDATES
-    // ==========================================
-
-    /**
-     * Update photo count cache (call after adding/removing images)
-     */
-    @Query("""
-        UPDATE collections
-        SET photoCount = (
-            SELECT COUNT(*) FROM collection_images
-            WHERE collectionId = :collectionId
-        ),
-        updatedAt = :updatedAt
-        WHERE collectionId = :collectionId
-    """)
-    suspend fun updatePhotoCount(collectionId: String, updatedAt: Long)
-
-    @Query("""
-        UPDATE collections
-        SET coverImageUri = :imageUri, updatedAt = :updatedAt
-        WHERE collectionId = :collectionId
-    """)
-    suspend fun updateCoverImage(collectionId: String, imageUri: String?, updatedAt: Long)
-
-    @Query("""
-        UPDATE collections
-        SET isPinned = :isPinned, updatedAt = :updatedAt
-        WHERE collectionId = :collectionId
-    """)
-    suspend fun updatePinned(collectionId: String, isPinned: Boolean, updatedAt: Long)
-
-    @Query("""
-        UPDATE collections
-        SET name = :name, description = :description, updatedAt = :updatedAt
-        WHERE collectionId = :collectionId
-    """)
-    suspend fun updateDetails(
-        collectionId: String,
-        name: String,
-        description: String?,
-        updatedAt: Long
-    )
-}

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

@@ -9,45 +9,6 @@ import com.placeholder.sherpai2.data.local.entity.ImageEntity
 import com.placeholder.sherpai2.data.local.model.ImageWithEverything
 import kotlinx.coroutines.flow.Flow
 
-/**
- * Data classes for statistics queries
- */
-data class DateCount(
-    val date: String,  // YYYY-MM-DD format
-    val count: Int
-)
-
-data class MonthCount(
-    val month: String, // YYYY-MM format
-    val count: Int
-)
-
-data class YearCount(
-    val year: String,  // YYYY format
-    val count: Int
-)
-
-data class DayOfWeekCount(
-    val dayOfWeek: Int, // 0 = Sunday, 6 = Saturday
-    val count: Int
-)
-
-data class HourCount(
-    val hour: Int,     // 0-23
-    val count: Int
-)
-
-/**
- * Face detection cache statistics
- */
-data class FaceCacheStats(
-    val totalImages: Int,
-    val imagesWithFaceCache: Int,
-    val imagesWithFaces: Int,
-    val imagesWithoutFaces: Int,
-    val needsScanning: Int
-)
-
 @Dao
 interface ImageDao {
 
@@ -107,334 +68,8 @@ interface ImageDao {
 
     /**
      * Get images by list of IDs.
+     * FIXED: Changed from List<Long> to List<String> to match ImageEntity.imageId type
      */
     @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>
-
-    // ==========================================
-    // FACE DETECTION CACHE QUERIES - CRITICAL FOR OPTIMIZATION
-    // ==========================================
-
-    /**
-     * Get all images that have faces (cached).
-     * This is the PRIMARY optimization query.
-     *
-     * Use this for person scanning instead of scanning ALL images.
-     * Estimated speed improvement: 50-70% for typical photo libraries.
-     */
-    @Query("""
-        SELECT * FROM images
-        WHERE hasFaces = 1
-        AND faceDetectionVersion = :currentVersion
-        ORDER BY capturedAt DESC
-    """)
-    suspend fun getImagesWithFaces(currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION): List<ImageEntity>
-
-    /**
-     * Get images with faces, limited (for progressive scanning)
-     */
-    @Query("""
-        SELECT * FROM images
-        WHERE hasFaces = 1
-        AND faceDetectionVersion = :currentVersion
-        ORDER BY capturedAt DESC
-        LIMIT :limit
-    """)
-    suspend fun getImagesWithFacesLimited(
-        limit: Int,
-        currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    ): List<ImageEntity>
-
-    /**
-     * Get images with a specific face count.
-     * Use cases:
-     * - Solo photos (faceCount = 1)
-     * - Couple photos (faceCount = 2)
-     * - Filter out groups (faceCount <= 2)
-     */
-    @Query("""
-        SELECT * FROM images
-        WHERE hasFaces = 1
-        AND faceCount = :count
-        AND faceDetectionVersion = :currentVersion
-        ORDER BY capturedAt DESC
-    """)
-    suspend fun getImagesByFaceCount(
-        count: Int,
-        currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    ): List<ImageEntity>
-
-    /**
-     * Get images with face count in range.
-     * Examples:
-     * - Solo or couple: minFaces=1, maxFaces=2
-     * - Groups only: minFaces=3, maxFaces=999
-     */
-    @Query("""
-        SELECT * FROM images
-        WHERE hasFaces = 1
-        AND faceCount BETWEEN :minFaces AND :maxFaces
-        AND faceDetectionVersion = :currentVersion
-        ORDER BY capturedAt DESC
-    """)
-    suspend fun getImagesByFaceCountRange(
-        minFaces: Int,
-        maxFaces: Int,
-        currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    ): List<ImageEntity>
-
-    /**
-     * Get images that need face detection scanning.
-     * These images have:
-     * - Never been scanned (hasFaces = null)
-     * - Old detection version
-     * - Invalid cache
-     */
-    @Query("""
-        SELECT * FROM images
-        WHERE hasFaces IS NULL
-        OR faceDetectionVersion IS NULL
-        OR faceDetectionVersion < :currentVersion
-        ORDER BY capturedAt DESC
-    """)
-    suspend fun getImagesNeedingFaceDetection(
-        currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    ): List<ImageEntity>
-
-    /**
-     * Get count of images needing face detection.
-     */
-    @Query("""
-        SELECT COUNT(*) FROM images
-        WHERE hasFaces IS NULL
-        OR faceDetectionVersion IS NULL
-        OR faceDetectionVersion < :currentVersion
-    """)
-    suspend fun getImagesNeedingFaceDetectionCount(
-        currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    ): Int
-
-    /**
-     * Update face detection cache for a single image.
-     * Called after detecting faces in an image.
-     */
-    @Query("""
-        UPDATE images
-        SET hasFaces = :hasFaces,
-            faceCount = :faceCount,
-            facesLastDetected = :timestamp,
-            faceDetectionVersion = :version
-        WHERE imageId = :imageId
-    """)
-    suspend fun updateFaceDetectionCache(
-        imageId: String,
-        hasFaces: Boolean,
-        faceCount: Int,
-        timestamp: Long = System.currentTimeMillis(),
-        version: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    )
-
-    /**
-     * Batch update face detection cache.
-     * More efficient when updating many images at once.
-     *
-     * Note: Room doesn't support batch updates directly,
-     * so this needs to be called multiple times in a transaction.
-     */
-    @Transaction
-    suspend fun updateFaceDetectionCacheBatch(updates: List<FaceDetectionCacheUpdate>) {
-        updates.forEach { update ->
-            updateFaceDetectionCache(
-                imageId = update.imageId,
-                hasFaces = update.hasFaces,
-                faceCount = update.faceCount,
-                timestamp = update.timestamp,
-                version = update.version
-            )
-        }
-    }
-
-    /**
-     * Get face detection cache statistics.
-     * Useful for UI display and determining background scan needs.
-     */
-    @Query("""
-        SELECT 
-            COUNT(*) as totalImages,
-            SUM(CASE WHEN hasFaces IS NOT NULL THEN 1 ELSE 0 END) as imagesWithFaceCache,
-            SUM(CASE WHEN hasFaces = 1 THEN 1 ELSE 0 END) as imagesWithFaces,
-            SUM(CASE WHEN hasFaces = 0 THEN 1 ELSE 0 END) as imagesWithoutFaces,
-            SUM(CASE WHEN hasFaces IS NULL OR faceDetectionVersion < :currentVersion THEN 1 ELSE 0 END) as needsScanning
-        FROM images
-    """)
-    suspend fun getFaceCacheStats(
-        currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    ): FaceCacheStats?
-
-    /**
-     * Invalidate face detection cache (force re-scan).
-     * Call this when upgrading face detection algorithm.
-     */
-    @Query("""
-        UPDATE images
-        SET faceDetectionVersion = NULL
-        WHERE faceDetectionVersion < :newVersion
-    """)
-    suspend fun invalidateFaceDetectionCache(newVersion: Int)
-
-    // ==========================================
-    // STATISTICS QUERIES
-    // ==========================================
-
-    /**
-     * Get photo counts by date (daily granularity)
-     * Returns all days that have at least one photo
-     */
-    @Query("""
-        SELECT 
-            date(capturedAt/1000, 'unixepoch') as date,
-            COUNT(*) as count
-        FROM images
-        GROUP BY date
-        ORDER BY date ASC
-    """)
-    suspend fun getPhotoCountsByDate(): List<DateCount>
-
-    /**
-     * Get photo counts by month (monthly granularity)
-     */
-    @Query("""
-        SELECT 
-            strftime('%Y-%m', capturedAt/1000, 'unixepoch') as month,
-            COUNT(*) as count
-        FROM images
-        GROUP BY month
-        ORDER BY month ASC
-    """)
-    suspend fun getPhotoCountsByMonth(): List<MonthCount>
-
-    /**
-     * Get photo counts by year (yearly granularity)
-     */
-    @Query("""
-        SELECT 
-            strftime('%Y', capturedAt/1000, 'unixepoch') as year,
-            COUNT(*) as count
-        FROM images
-        GROUP BY year
-        ORDER BY year DESC
-    """)
-    suspend fun getPhotoCountsByYear(): List<YearCount>
-
-    /**
-     * Get photo counts by year (Flow version for reactive UI)
-     */
-    @Query("""
-        SELECT 
-            strftime('%Y', capturedAt/1000, 'unixepoch') as year,
-            COUNT(*) as count
-        FROM images
-        GROUP BY year
-        ORDER BY year DESC
-    """)
-    fun getPhotoCountsByYearFlow(): Flow<List<YearCount>>
-
-    /**
-     * Get photo counts by day of week (0 = Sunday, 6 = Saturday)
-     * Shows which days you take the most photos
-     */
-    @Query("""
-        SELECT 
-            CAST(strftime('%w', capturedAt/1000, 'unixepoch') AS INTEGER) as dayOfWeek,
-            COUNT(*) as count
-        FROM images
-        GROUP BY dayOfWeek
-        ORDER BY dayOfWeek ASC
-    """)
-    suspend fun getPhotoCountsByDayOfWeek(): List<DayOfWeekCount>
-
-    /**
-     * Get photo counts by hour of day (0-23)
-     * Shows when you take the most photos
-     */
-    @Query("""
-        SELECT 
-            CAST(strftime('%H', capturedAt/1000, 'unixepoch') AS INTEGER) as hour,
-            COUNT(*) as count
-        FROM images
-        GROUP BY hour
-        ORDER BY hour ASC
-    """)
-    suspend fun getPhotoCountsByHour(): List<HourCount>
-
-    /**
-     * Get earliest and latest photo timestamps
-     * Used for date range calculations
-     */
-    @Query("""
-        SELECT 
-            MIN(capturedAt) as earliest,
-            MAX(capturedAt) as latest
-        FROM images
-    """)
-    suspend fun getPhotoDateRange(): PhotoDateRange?
-
-    /**
-     * Get photo count for a specific year
-     */
-    @Query("""
-        SELECT COUNT(*) FROM images
-        WHERE strftime('%Y', capturedAt/1000, 'unixepoch') = :year
-    """)
-    suspend fun getPhotoCountForYear(year: String): Int
-
-    /**
-     * Get average photos per day (for stats display)
-     */
-    @Query("""
-        SELECT 
-            CAST(COUNT(*) AS REAL) / 
-            CAST((MAX(capturedAt) - MIN(capturedAt)) / 86400000 AS REAL) as avgPerDay
-        FROM images
-        WHERE (SELECT COUNT(*) FROM images) > 0
-    """)
-    suspend fun getAveragePhotosPerDay(): Float?
-
-    @Query("SELECT * FROM images WHERE hasFaces = 1 ORDER BY faceCount DESC")
-    suspend fun getImagesWithFaces(): List<ImageEntity>
-
 }
-
-/**
- * Data class for date range result
- */
-data class PhotoDateRange(
-    val earliest: Long,
-    val latest: Long
-)
-
-/**
- * Data class for batch face detection cache updates
- */
-data class FaceDetectionCacheUpdate(
-    val imageId: String,
-    val hasFaces: Boolean,
-    val faceCount: Int,
-    val timestamp: Long = System.currentTimeMillis(),
-    val version: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-)

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

@@ -9,15 +9,6 @@ import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
 import com.placeholder.sherpai2.data.local.entity.TagEntity
 import kotlinx.coroutines.flow.Flow
 
-/**
- * Data class for burst statistics
- */
-data class BurstStats(
-    val totalBurstPhotos: Int,
-    val estimatedBurstGroups: Int,
-    val burstRepresentatives: Int
-)
-
 @Dao
 interface ImageTagDao {
 
@@ -53,90 +44,4 @@ interface ImageTagDao {
         WHERE it.imageId = :imageId AND it.visibility = 'PUBLIC'
     """)
     fun getTagsForImage(imageId: String): Flow<List<TagEntity>>
-
-    /**
-     * Insert image tag (for utilities tagging)
-     */
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insert(imageTag: ImageTagEntity): Long
-
-    // ==========================================
-    // BURST STATISTICS - ADDED FOR STATS SECTION
-    // ==========================================
-
-    /**
-     * Get comprehensive burst statistics
-     * Returns total burst photos, estimated groups, and representative count
-     */
-    @Query("""
-        SELECT 
-            (SELECT COUNT(DISTINCT it.imageId) 
-             FROM image_tags it 
-             INNER JOIN tags t ON it.tagId = t.tagId 
-             WHERE t.value = 'burst') as totalBurstPhotos,
-            (SELECT COUNT(DISTINCT it.imageId) / 3
-             FROM image_tags it 
-             INNER JOIN tags t ON it.tagId = t.tagId 
-             WHERE t.value = 'burst') as estimatedBurstGroups,
-            (SELECT COUNT(DISTINCT it.imageId)
-             FROM image_tags it 
-             INNER JOIN tags t ON it.tagId = t.tagId 
-             WHERE t.value = 'burst_representative') as burstRepresentatives
-    """)
-    suspend fun getBurstStats(): BurstStats?
-
-    /**
-     * Get burst statistics (Flow version for reactive UI)
-     */
-    @Query("""
-        SELECT 
-            (SELECT COUNT(DISTINCT it.imageId) 
-             FROM image_tags it 
-             INNER JOIN tags t ON it.tagId = t.tagId 
-             WHERE t.value = 'burst') as totalBurstPhotos,
-            (SELECT COUNT(DISTINCT it.imageId) / 3
-             FROM image_tags it 
-             INNER JOIN tags t ON it.tagId = t.tagId 
-             WHERE t.value = 'burst') as estimatedBurstGroups,
-            (SELECT COUNT(DISTINCT it.imageId)
-             FROM image_tags it 
-             INNER JOIN tags t ON it.tagId = t.tagId 
-             WHERE t.value = 'burst_representative') as burstRepresentatives
-    """)
-    fun getBurstStatsFlow(): Flow<BurstStats?>
-
-    /**
-     * Get count of burst photos
-     */
-    @Query("""
-        SELECT COUNT(DISTINCT it.imageId)
-        FROM image_tags it
-        INNER JOIN tags t ON it.tagId = t.tagId
-        WHERE t.value = 'burst'
-    """)
-    suspend fun getBurstPhotoCount(): Int
-
-    /**
-     * Get count of burst representative photos
-     * (photos marked as the best in each burst sequence)
-     */
-    @Query("""
-        SELECT COUNT(DISTINCT it.imageId)
-        FROM image_tags it
-        INNER JOIN tags t ON it.tagId = t.tagId
-        WHERE t.value = 'burst_representative'
-    """)
-    suspend fun getBurstRepresentativeCount(): Int
-
-    /**
-     * Get estimated number of burst groups
-     * Assumes average of 3 photos per burst
-     */
-    @Query("""
-        SELECT COUNT(DISTINCT it.imageId) / 3
-        FROM image_tags it
-        INNER JOIN tags t ON it.tagId = t.tagId
-        WHERE t.value = 'burst'
-    """)
-    suspend fun getEstimatedBurstGroupCount(): Int
 }

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

@@ -1,104 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.*
-import com.placeholder.sherpai2.data.local.entity.PersonAgeTagEntity
-import kotlinx.coroutines.flow.Flow
-
-/**
- * PersonAgeTagDao - Manage searchable age tags for children
- *
- * USAGE EXAMPLES:
- * - Search "emma age 3" → getImageIdsForTag("emma_age3")
- * - Find all photos of Emma at age 5 → getImageIdsForPersonAtAge(emmaId, 5)
- * - Get age progression → getTagsForPerson(emmaId) sorted by age
- */
-@Dao
-interface PersonAgeTagDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insertTag(tag: PersonAgeTagEntity)
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insertTags(tags: List<PersonAgeTagEntity>)
-
-    /**
-     * Get all age tags for a person (sorted by age)
-     * Useful for age progression timeline
-     */
-    @Query("SELECT * FROM person_age_tags WHERE personId = :personId ORDER BY ageAtCapture ASC")
-    suspend fun getTagsForPerson(personId: String): List<PersonAgeTagEntity>
-
-    /**
-     * Get all age tags for an image
-     */
-    @Query("SELECT * FROM person_age_tags WHERE imageId = :imageId")
-    suspend fun getTagsForImage(imageId: String): List<PersonAgeTagEntity>
-
-    /**
-     * Search by tag value (e.g., "emma_age3")
-     * Returns all image IDs matching this tag
-     */
-    @Query("SELECT DISTINCT imageId FROM person_age_tags WHERE tagValue = :tagValue")
-    suspend fun getImageIdsForTag(tagValue: String): List<String>
-
-    /**
-     * Get images of a person at a specific age
-     */
-    @Query("SELECT DISTINCT imageId FROM person_age_tags WHERE personId = :personId AND ageAtCapture = :age")
-    suspend fun getImageIdsForPersonAtAge(personId: String, age: Int): List<String>
-
-    /**
-     * Get images of a person in an age range
-     */
-    @Query("""
-        SELECT DISTINCT imageId FROM person_age_tags 
-        WHERE personId = :personId 
-        AND ageAtCapture BETWEEN :minAge AND :maxAge
-        ORDER BY ageAtCapture ASC
-    """)
-    suspend fun getImageIdsForPersonAgeRange(personId: String, minAge: Int, maxAge: Int): List<String>
-
-    /**
-     * Get all unique ages for a person (for age picker UI)
-     */
-    @Query("SELECT DISTINCT ageAtCapture FROM person_age_tags WHERE personId = :personId ORDER BY ageAtCapture ASC")
-    suspend fun getAgesForPerson(personId: String): List<Int>
-
-    /**
-     * Delete all tags for a person
-     */
-    @Query("DELETE FROM person_age_tags WHERE personId = :personId")
-    suspend fun deleteTagsForPerson(personId: String)
-
-    /**
-     * Delete all tags for an image
-     */
-    @Query("DELETE FROM person_age_tags WHERE imageId = :imageId")
-    suspend fun deleteTagsForImage(imageId: String)
-
-    /**
-     * Get count of photos at each age (for statistics)
-     */
-    @Query("""
-        SELECT ageAtCapture, COUNT(DISTINCT imageId) as count 
-        FROM person_age_tags 
-        WHERE personId = :personId 
-        GROUP BY ageAtCapture 
-        ORDER BY ageAtCapture ASC
-    """)
-    suspend fun getPhotoCountByAge(personId: String): List<AgePhotoCount>
-
-    /**
-     * Flow version for reactive UI
-     */
-    @Query("SELECT * FROM person_age_tags WHERE personId = :personId ORDER BY ageAtCapture ASC")
-    fun getTagsForPersonFlow(personId: String): Flow<List<PersonAgeTagEntity>>
-}
-
-/**
- * Data class for age photo count statistics
- */
-data class AgePhotoCount(
-    val ageAtCapture: Int,
-    val count: Int
-)

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

@@ -9,16 +9,6 @@ import com.placeholder.sherpai2.data.local.entity.TagEntity
 import com.placeholder.sherpai2.data.local.entity.TagWithUsage
 import kotlinx.coroutines.flow.Flow
 
-/**
- * Data class for tag statistics
- */
-data class TagStat(
-    val tagValue: String,
-    val tagType: String,
-    val imageCount: Int,
-    val tagId: String
-)
-
 /**
  * TagDao - Tag management with face recognition integration
  *
@@ -228,70 +218,4 @@ interface TagDao {
         LIMIT :limit
     """)
     suspend fun searchTagsWithUsage(query: String, limit: Int): List<TagWithUsage>
-
-    // ==========================================
-    // STATISTICS QUERIES - ADDED FOR STATS SECTION
-    // ==========================================
-
-    /**
-     * Get system tag statistics (for utilities stats display)
-     * Returns tag value, type, and count of tagged images
-     */
-    @Query("""
-        SELECT 
-            t.value as tagValue,
-            t.type as tagType,
-            COUNT(DISTINCT it.imageId) as imageCount,
-            t.tagId as tagId
-        FROM tags t
-        INNER JOIN image_tags it ON t.tagId = it.tagId
-        WHERE t.type = 'SYSTEM'
-        GROUP BY t.tagId
-        ORDER BY imageCount DESC
-    """)
-    suspend fun getSystemTagStats(): List<TagStat>
-
-    /**
-     * Get system tag statistics (Flow version for reactive UI)
-     */
-    @Query("""
-        SELECT 
-            t.value as tagValue,
-            t.type as tagType,
-            COUNT(DISTINCT it.imageId) as imageCount,
-            t.tagId as tagId
-        FROM tags t
-        INNER JOIN image_tags it ON t.tagId = it.tagId
-        WHERE t.type = 'SYSTEM'
-        GROUP BY t.tagId
-        ORDER BY imageCount DESC
-    """)
-    fun getSystemTagStatsFlow(): Flow<List<TagStat>>
-
-    /**
-     * Get count of photos with a specific system tag
-     */
-    @Query("""
-        SELECT COUNT(DISTINCT it.imageId)
-        FROM image_tags it
-        INNER JOIN tags t ON it.tagId = t.tagId
-        WHERE t.value = :tagValue AND t.type = 'SYSTEM'
-    """)
-    suspend fun getSystemTagCount(tagValue: String): Int
-
-    /**
-     * Get all tag types with counts
-     * Shows breakdown of SYSTEM vs USER vs GENERIC tags
-     */
-    @Query("""
-        SELECT 
-            t.type as tagValue,
-            t.type as tagType,
-            COUNT(DISTINCT t.tagId) as imageCount,
-            '' as tagId
-        FROM tags t
-        GROUP BY t.type
-        ORDER BY imageCount DESC
-    """)
-    suspend fun getTagTypeBreakdown(): List<TagStat>
 }

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

@@ -1,107 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-import java.util.UUID
-
-/**
- * CollectionEntity - User-created photo collections
- *
- * Types:
- * - SMART: Dynamic collection based on filters (re-evaluated)
- * - STATIC: Fixed snapshot of photos
- * - FAVORITE: Special favorites collection
- */
-@Entity(
-    tableName = "collections",
-    indices = [
-        Index(value = ["name"]),
-        Index(value = ["type"]),
-        Index(value = ["createdAt"])
-    ]
-)
-data class CollectionEntity(
-    @PrimaryKey
-    val collectionId: String,
-
-    val name: String,
-    val description: String?,
-
-    /**
-     * Cover image (auto-selected or user-chosen)
-     */
-    val coverImageUri: String?,
-
-    /**
-     * SMART | STATIC | FAVORITE
-     */
-    val type: String,
-
-    /**
-     * Cached photo count for performance
-     */
-    val photoCount: Int,
-
-    val createdAt: Long,
-    val updatedAt: Long,
-
-    /**
-     * Pinned to top of collections list
-     */
-    val isPinned: Boolean
-) {
-    companion object {
-        fun createSmart(
-            name: String,
-            description: String? = null
-        ): CollectionEntity {
-            val now = System.currentTimeMillis()
-            return CollectionEntity(
-                collectionId = UUID.randomUUID().toString(),
-                name = name,
-                description = description,
-                coverImageUri = null,
-                type = "SMART",
-                photoCount = 0,
-                createdAt = now,
-                updatedAt = now,
-                isPinned = false
-            )
-        }
-
-        fun createStatic(
-            name: String,
-            description: String? = null,
-            photoCount: Int = 0
-        ): CollectionEntity {
-            val now = System.currentTimeMillis()
-            return CollectionEntity(
-                collectionId = UUID.randomUUID().toString(),
-                name = name,
-                description = description,
-                coverImageUri = null,
-                type = "STATIC",
-                photoCount = photoCount,
-                createdAt = now,
-                updatedAt = now,
-                isPinned = false
-            )
-        }
-
-        fun createFavorite(): CollectionEntity {
-            val now = System.currentTimeMillis()
-            return CollectionEntity(
-                collectionId = "favorites",
-                name = "Favorites",
-                description = "Your favorite photos",
-                coverImageUri = null,
-                type = "FAVORITE",
-                photoCount = 0,
-                createdAt = now,
-                updatedAt = now,
-                isPinned = true
-            )
-        }
-    }
-}

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

@@ -1,70 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-import androidx.room.PrimaryKey
-import java.util.UUID
-
-/**
- * CollectionFilterEntity - Filters for SMART collections
- *
- * Filter Types:
- * - PERSON_INCLUDE: Person must be in photo
- * - PERSON_EXCLUDE: Person must NOT be in photo
- * - TAG_INCLUDE: Tag must be present
- * - TAG_EXCLUDE: Tag must NOT be present
- * - DATE_RANGE: Date filter (TODAY, THIS_WEEK, etc)
- */
-@Entity(
-    tableName = "collection_filters",
-    foreignKeys = [
-        ForeignKey(
-            entity = CollectionEntity::class,
-            parentColumns = ["collectionId"],
-            childColumns = ["collectionId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("collectionId"),
-        Index("filterType")
-    ]
-)
-data class CollectionFilterEntity(
-    @PrimaryKey
-    val filterId: String,
-
-    val collectionId: String,
-
-    /**
-     * PERSON_INCLUDE | PERSON_EXCLUDE | TAG_INCLUDE | TAG_EXCLUDE | DATE_RANGE
-     */
-    val filterType: String,
-
-    /**
-     * The filter value:
-     * - For PERSON_*: personId
-     * - For TAG_*: tag value
-     * - For DATE_RANGE: "TODAY", "THIS_WEEK", etc
-     */
-    val filterValue: String,
-
-    val createdAt: Long
-) {
-    companion object {
-        fun create(
-            collectionId: String,
-            filterType: String,
-            filterValue: String
-        ): CollectionFilterEntity {
-            return CollectionFilterEntity(
-                filterId = UUID.randomUUID().toString(),
-                collectionId = collectionId,
-                filterType = filterType,
-                filterValue = filterValue,
-                createdAt = System.currentTimeMillis()
-            )
-        }
-    }
-}

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

@@ -1,50 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-
-/**
- * CollectionImageEntity - Join table linking collections to images
- *
- * Supports:
- * - Custom sort order
- * - Timestamp when added
- */
-@Entity(
-    tableName = "collection_images",
-    primaryKeys = ["collectionId", "imageId"],
-    foreignKeys = [
-        ForeignKey(
-            entity = CollectionEntity::class,
-            parentColumns = ["collectionId"],
-            childColumns = ["collectionId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("collectionId"),
-        Index("imageId"),
-        Index("addedAt")
-    ]
-)
-data class CollectionImageEntity(
-    val collectionId: String,
-    val imageId: String,
-
-    /**
-     * When this image was added to the collection
-     */
-    val addedAt: Long,
-
-    /**
-     * Custom sort order (lower = earlier)
-     */
-    val sortOrder: Int
-)

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

@@ -5,24 +5,19 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.Index
 import androidx.room.PrimaryKey
-import org.json.JSONArray
-import org.json.JSONObject
 import java.util.UUID
 
 /**
- * PersonEntity - ENHANCED with child tracking and sibling relationships
+ * PersonEntity - NO DEFAULT VALUES for KSP compatibility
  */
 @Entity(
     tableName = "persons",
-    indices = [
+    indices = [Index(value = ["name"])]
-        Index(value = ["name"]),
-        Index(value = ["familyGroupId"])
-    ]
 )
 data class PersonEntity(
     @PrimaryKey
     @ColumnInfo(name = "id")
-    val id: String,
+    val id: String,                    // ← No default
 
     @ColumnInfo(name = "name")
     val name: String,
@@ -30,48 +25,26 @@ data class PersonEntity(
     @ColumnInfo(name = "dateOfBirth")
     val dateOfBirth: Long?,
 
-    @ColumnInfo(name = "isChild")
-    val isChild: Boolean,              // NEW: Auto-set based on age
-
-    @ColumnInfo(name = "siblingIds")
-    val siblingIds: String?,           // NEW: JSON list ["uuid1", "uuid2"]
-
-    @ColumnInfo(name = "familyGroupId")
-    val familyGroupId: String?,        // NEW: UUID for family unit
-
     @ColumnInfo(name = "relationship")
     val relationship: String?,
 
     @ColumnInfo(name = "createdAt")
-    val createdAt: Long,
+    val createdAt: Long,               // ← No default
 
     @ColumnInfo(name = "updatedAt")
-    val updatedAt: Long
+    val updatedAt: Long                // ← No default
 ) {
     companion object {
         fun create(
             name: String,
             dateOfBirth: Long? = null,
-            isChild: Boolean = false,
-            siblingIds: List<String> = emptyList(),
             relationship: String? = null
         ): PersonEntity {
             val now = System.currentTimeMillis()
-
-            // Create family group if siblings exist
-            val familyGroupId = if (siblingIds.isNotEmpty()) {
-                UUID.randomUUID().toString()
-            } else null
-
             return PersonEntity(
                 id = UUID.randomUUID().toString(),
                 name = name,
                 dateOfBirth = dateOfBirth,
-                isChild = isChild,
-                siblingIds = if (siblingIds.isNotEmpty()) {
-                    JSONArray(siblingIds).toString()
-                } else null,
-                familyGroupId = familyGroupId,
                 relationship = relationship,
                 createdAt = now,
                 updatedAt = now
@@ -79,17 +52,6 @@ data class PersonEntity(
         }
     }
 
-    fun getSiblingIds(): List<String> {
-        return if (siblingIds != null) {
-            try {
-                val jsonArray = JSONArray(siblingIds)
-                (0 until jsonArray.length()).map { jsonArray.getString(it) }
-            } catch (e: Exception) {
-                emptyList()
-            }
-        } else emptyList()
-    }
-
     fun getAge(): Int? {
         if (dateOfBirth == null) return null
         val now = System.currentTimeMillis()
@@ -112,7 +74,7 @@ data class PersonEntity(
 }
 
 /**
- * FaceModelEntity - MULTI-CENTROID support for temporal tracking
+ * FaceModelEntity - NO DEFAULT VALUES
  */
 @Entity(
     tableName = "face_models",
@@ -129,13 +91,13 @@ data class PersonEntity(
 data class FaceModelEntity(
     @PrimaryKey
     @ColumnInfo(name = "id")
-    val id: String,
+    val id: String,                    // ← No default
 
     @ColumnInfo(name = "personId")
     val personId: String,
 
-    @ColumnInfo(name = "centroidsJson")
+    @ColumnInfo(name = "embedding")
-    val centroidsJson: String,         // NEW: List<TemporalCentroid> as JSON
+    val embedding: String,
 
     @ColumnInfo(name = "trainingImageCount")
     val trainingImageCount: Int,
@@ -144,10 +106,10 @@ data class FaceModelEntity(
     val averageConfidence: Float,
 
     @ColumnInfo(name = "createdAt")
-    val createdAt: Long,
+    val createdAt: Long,               // ← No default
 
     @ColumnInfo(name = "updatedAt")
-    val updatedAt: Long,
+    val updatedAt: Long,               // ← No default
 
     @ColumnInfo(name = "lastUsed")
     val lastUsed: Long?,
@@ -156,42 +118,17 @@ data class FaceModelEntity(
     val isActive: Boolean
 ) {
     companion object {
-        /**
-         * Backwards compatible create() method
-         * Used by existing FaceRecognitionRepository code
-         */
         fun create(
             personId: String,
             embeddingArray: FloatArray,
             trainingImageCount: Int,
             averageConfidence: Float
-        ): FaceModelEntity {
-            return createFromEmbedding(personId, embeddingArray, trainingImageCount, averageConfidence)
-        }
-
-        /**
-         * Create from single embedding (backwards compatible)
-         */
-        fun createFromEmbedding(
-            personId: String,
-            embeddingArray: FloatArray,
-            trainingImageCount: Int,
-            averageConfidence: Float
         ): FaceModelEntity {
             val now = System.currentTimeMillis()
-            val centroid = TemporalCentroid(
-                embedding = embeddingArray.toList(),
-                effectiveTimestamp = now,
-                ageAtCapture = null,
-                photoCount = trainingImageCount,
-                timeRangeMonths = 12,
-                avgConfidence = averageConfidence
-            )
-
             return FaceModelEntity(
                 id = UUID.randomUUID().toString(),
                 personId = personId,
-                centroidsJson = serializeCentroids(listOf(centroid)),
+                embedding = embeddingArray.joinToString(","),
                 trainingImageCount = trainingImageCount,
                 averageConfidence = averageConfidence,
                 createdAt = now,
@@ -200,106 +137,15 @@ data class FaceModelEntity(
                 isActive = true
             )
         }
-
-        /**
-         * Create from multiple centroids (temporal tracking)
-         */
-        fun createFromCentroids(
-            personId: String,
-            centroids: List<TemporalCentroid>,
-            trainingImageCount: Int,
-            averageConfidence: Float
-        ): FaceModelEntity {
-            val now = System.currentTimeMillis()
-            return FaceModelEntity(
-                id = UUID.randomUUID().toString(),
-                personId = personId,
-                centroidsJson = serializeCentroids(centroids),
-                trainingImageCount = trainingImageCount,
-                averageConfidence = averageConfidence,
-                createdAt = now,
-                updatedAt = now,
-                lastUsed = null,
-                isActive = true
-            )
     }
 
-        /**
-         * Serialize list of centroids to JSON
-         */
-        private fun serializeCentroids(centroids: List<TemporalCentroid>): String {
-            val jsonArray = JSONArray()
-            centroids.forEach { centroid ->
-                val jsonObj = JSONObject()
-                jsonObj.put("embedding", JSONArray(centroid.embedding))
-                jsonObj.put("effectiveTimestamp", centroid.effectiveTimestamp)
-                jsonObj.put("ageAtCapture", centroid.ageAtCapture)
-                jsonObj.put("photoCount", centroid.photoCount)
-                jsonObj.put("timeRangeMonths", centroid.timeRangeMonths)
-                jsonObj.put("avgConfidence", centroid.avgConfidence)
-                jsonArray.put(jsonObj)
-            }
-            return jsonArray.toString()
-        }
-
-        /**
-         * Deserialize JSON to list of centroids
-         */
-        private fun deserializeCentroids(json: String): List<TemporalCentroid> {
-            val jsonArray = JSONArray(json)
-            return (0 until jsonArray.length()).map { i ->
-                val jsonObj = jsonArray.getJSONObject(i)
-                val embeddingArray = jsonObj.getJSONArray("embedding")
-                val embedding = (0 until embeddingArray.length()).map { j ->
-                    embeddingArray.getDouble(j).toFloat()
-                }
-                TemporalCentroid(
-                    embedding = embedding,
-                    effectiveTimestamp = jsonObj.getLong("effectiveTimestamp"),
-                    ageAtCapture = if (jsonObj.isNull("ageAtCapture")) null else jsonObj.getDouble("ageAtCapture").toFloat(),
-                    photoCount = jsonObj.getInt("photoCount"),
-                    timeRangeMonths = jsonObj.getInt("timeRangeMonths"),
-                    avgConfidence = jsonObj.getDouble("avgConfidence").toFloat()
-                )
-            }
-        }
-    }
-
-    fun getCentroids(): List<TemporalCentroid> {
-        return try {
-            FaceModelEntity.deserializeCentroids(centroidsJson)
-        } catch (e: Exception) {
-            emptyList()
-        }
-    }
-
-    // Backwards compatibility: get first centroid as single embedding
     fun getEmbeddingArray(): FloatArray {
-        val centroids = getCentroids()
+        return embedding.split(",").map { it.toFloat() }.toFloatArray()
-        return if (centroids.isNotEmpty()) {
-            centroids.first().getEmbeddingArray()
-        } else {
-            FloatArray(192) // Empty embedding
-        }
     }
 }
 
 /**
- * TemporalCentroid - Represents a face appearance at a specific time period
+ * PhotoFaceTagEntity - NO DEFAULT VALUES
- */
-data class TemporalCentroid(
-    val embedding: List<Float>,        // 192D vector
-    val effectiveTimestamp: Long,      // Center of time window
-    val ageAtCapture: Float?,          // Age in years (for children)
-    val photoCount: Int,               // Number of photos in this cluster
-    val timeRangeMonths: Int,          // Width of time window (e.g., 6 months)
-    val avgConfidence: Float           // Quality indicator
-) {
-    fun getEmbeddingArray(): FloatArray = embedding.toFloatArray()
-}
-
-/**
- * PhotoFaceTagEntity - Unchanged
  */
 @Entity(
     tableName = "photo_face_tags",
@@ -326,7 +172,7 @@ data class TemporalCentroid(
 data class PhotoFaceTagEntity(
     @PrimaryKey
     @ColumnInfo(name = "id")
-    val id: String,
+    val id: String,                    // ← No default
 
     @ColumnInfo(name = "imageId")
     val imageId: String,
@@ -344,7 +190,7 @@ data class PhotoFaceTagEntity(
     val embedding: String,
 
     @ColumnInfo(name = "detectedAt")
-    val detectedAt: Long,
+    val detectedAt: Long,              // ← No default
 
     @ColumnInfo(name = "verifiedByUser")
     val verifiedByUser: Boolean,
@@ -383,73 +229,3 @@ data class PhotoFaceTagEntity(
         return embedding.split(",").map { it.toFloat() }.toFloatArray()
     }
 }
-
-/**
- * PersonAgeTagEntity - NEW: Searchable age tags
- */
-@Entity(
-    tableName = "person_age_tags",
-    foreignKeys = [
-        ForeignKey(
-            entity = PersonEntity::class,
-            parentColumns = ["id"],
-            childColumns = ["personId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index(value = ["personId"]),
-        Index(value = ["imageId"]),
-        Index(value = ["ageAtCapture"]),
-        Index(value = ["tagValue"])
-    ]
-)
-data class PersonAgeTagEntity(
-    @PrimaryKey
-    @ColumnInfo(name = "id")
-    val id: String,
-
-    @ColumnInfo(name = "personId")
-    val personId: String,
-
-    @ColumnInfo(name = "imageId")
-    val imageId: String,
-
-    @ColumnInfo(name = "ageAtCapture")
-    val ageAtCapture: Int,
-
-    @ColumnInfo(name = "tagValue")
-    val tagValue: String,             // e.g., "emma_age3"
-
-    @ColumnInfo(name = "confidence")
-    val confidence: Float,
-
-    @ColumnInfo(name = "createdAt")
-    val createdAt: Long
-) {
-    companion object {
-        fun create(
-            personId: String,
-            personName: String,
-            imageId: String,
-            ageAtCapture: Int,
-            confidence: Float
-        ): PersonAgeTagEntity {
-            return PersonAgeTagEntity(
-                id = UUID.randomUUID().toString(),
-                personId = personId,
-                imageId = imageId,
-                ageAtCapture = ageAtCapture,
-                tagValue = "${personName.lowercase().replace(" ", "_")}_age$ageAtCapture",
-                confidence = confidence,
-                createdAt = System.currentTimeMillis()
-            )
-        }
-    }
-}

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

@@ -7,31 +7,19 @@ import androidx.room.PrimaryKey
 /**
  * Represents a single image on the device.
  *
- * This entity is intentionally immutable (mostly):
+ * This entity is intentionally immutable:
  * - imageUri identifies where the image lives
  * - sha256 prevents duplicates
  * - capturedAt is the EXIF timestamp
  *
- * FACE DETECTION CACHE (mutable for performance):
+ * This table should be append-only.
- * - hasFaces: Boolean flag to skip images without faces
- * - faceCount: Number of faces detected (0 if no faces)
- * - facesLastDetected: Timestamp of last face detection
- * - faceDetectionVersion: Version number for cache invalidation
- *
- * These fields are populated during:
- * 1. Initial model training (already detecting faces)
- * 2. Utility scans (burst detection, quality analysis)
- * 3. Any face detection operation
- * 4. Background maintenance scans
  */
 @Entity(
     tableName = "images",
     indices = [
         Index(value = ["imageUri"], unique = true),
         Index(value = ["sha256"], unique = true),
-        Index(value = ["capturedAt"]),
+        Index(value = ["capturedAt"])
-        Index(value = ["hasFaces"]),  // NEW: For fast filtering
-        Index(value = ["faceCount"])  // NEW: For range queries (singles, couples, groups)
     ]
 )
 data class ImageEntity(
@@ -63,113 +51,5 @@ data class ImageEntity(
     /**
      * CAMERA | SCREENSHOT | IMPORTED
      */
-    val source: String,
+    val source: String
-
+)
-    // ============================================================================
-    // FACE DETECTION CACHE - Populated asynchronously
-    // ============================================================================
-
-    /**
-     * Whether this image contains any faces.
-     * - true: At least one face detected
-     * - false: No faces detected
-     * - null: Not yet scanned (default for newly ingested images)
-     *
-     * Use this to skip images without faces during person scanning.
-     */
-    val hasFaces: Boolean? = null,
-
-    /**
-     * Number of faces detected in this image.
-     * - 0: No faces
-     * - 1: Solo person (useful for filtering)
-     * - 2: Couple (useful for filtering)
-     * - 3+: Group photo (useful for filtering)
-     * - null: Not yet scanned
-     *
-     * Use this for:
-     * - Finding solo photos of a person
-     * - Identifying couple photos
-     * - Filtering out group photos if needed
-     */
-    val faceCount: Int? = null,
-
-    /**
-     * Timestamp when faces were last detected in this image.
-     * Used for cache invalidation logic.
-     *
-     * Invalidate cache if:
-     * - Image modified date > facesLastDetected
-     * - faceDetectionVersion < current version
-     */
-    val facesLastDetected: Long? = null,
-
-    /**
-     * Face detection algorithm version.
-     * Increment this when improving face detection to invalidate old cache.
-     *
-     * Current version: 1
-     * - If detection algorithm improves, increment to 2
-     * - Query will re-scan images with version < 2
-     */
-    val faceDetectionVersion: Int? = null
-) {
-    companion object {
-        /**
-         * Current face detection algorithm version.
-         * Increment when making significant improvements to face detection.
-         */
-        const val CURRENT_FACE_DETECTION_VERSION = 1
-
-        /**
-         * Check if face detection cache is valid.
-         * Invalid if:
-         * - Never scanned (hasFaces == null)
-         * - Old detection version
-         * - Image modified after detection (would need file system check)
-         */
-        fun isFaceDetectionCacheValid(image: ImageEntity): Boolean {
-            return image.hasFaces != null &&
-                    image.faceDetectionVersion == CURRENT_FACE_DETECTION_VERSION
-        }
-    }
-
-    /**
-     * Check if this image needs face detection scanning.
-     */
-    fun needsFaceDetection(): Boolean {
-        return hasFaces == null ||
-                faceDetectionVersion == null ||
-                faceDetectionVersion < CURRENT_FACE_DETECTION_VERSION
-    }
-
-    /**
-     * Check if this image definitely has faces (cached).
-     */
-    fun hasCachedFaces(): Boolean {
-        return hasFaces == true && !needsFaceDetection()
-    }
-
-    /**
-     * Check if this image definitely has no faces (cached).
-     */
-    fun hasCachedNoFaces(): Boolean {
-        return hasFaces == false && !needsFaceDetection()
-    }
-
-    /**
-     * Get a copy with updated face detection cache.
-     */
-    fun withFaceDetectionCache(
-        hasFaces: Boolean,
-        faceCount: Int,
-        timestamp: Long = System.currentTimeMillis()
-    ): ImageEntity {
-        return copy(
-            hasFaces = hasFaces,
-            faceCount = faceCount,
-            facesLastDetected = timestamp,
-            faceDetectionVersion = CURRENT_FACE_DETECTION_VERSION
-        )
-    }
-}

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

@@ -1,18 +0,0 @@
-package com.placeholder.sherpai2.data.local.model
-
-import androidx.room.ColumnInfo
-import androidx.room.Embedded
-import com.placeholder.sherpai2.data.local.entity.CollectionEntity
-
-/**
- * CollectionWithDetails - Collection with computed preview data
- *
- * Room maps this directly from query results
- */
-data class CollectionWithDetails(
-    @Embedded
-    val collection: CollectionEntity,
-
-    @ColumnInfo(name = "actualPhotoCount")
-    val actualPhotoCount: Int
-)

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

@@ -1,46 +1,23 @@
 package com.placeholder.sherpai2.data.local.model
 
 import androidx.room.Embedded
-import androidx.room.Junction
 import androidx.room.Relation
 import com.placeholder.sherpai2.data.local.entity.*
 
-/**
- * ImageWithEverything - Fully hydrated image with ALL relationships
- *
- * Room loads this in ONE query using @Transaction!
- * NO N+1 problem - all tags and face tags loaded together
- *
- * Usage:
- * - ImageAggregateDao.observeAllImagesWithEverything()
- * - Search, Explore, Albums
- */
 data class ImageWithEverything(
+
     @Embedded
     val image: ImageEntity,
 
-    /**
-     * Tags for this image (via image_tags join table)
-     * Room automatically joins through ImageTagEntity
-     */
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "tagId",
-        associateBy = Junction(
-            value = ImageTagEntity::class,
-            parentColumn = "imageId",
-            entityColumn = "tagId"
-        )
-    )
-    val tags: List<TagEntity>,
-
-    /**
-     * Face tags for this image
-     * Room automatically loads all PhotoFaceTagEntity for this imageId
-     */
     @Relation(
         parentColumn = "imageId",
         entityColumn = "imageId"
     )
-    val faceTags: List<PhotoFaceTagEntity>
+    val tags: List<ImageTagEntity>,
+
+    @Relation(
+        parentColumn = "imageId",
+        entityColumn = "imageId"
+    )
+    val events: List<ImageEventEntity>
 )

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

@@ -1,327 +0,0 @@
-package com.placeholder.sherpai2.data.repository
-
-import com.placeholder.sherpai2.data.local.dao.CollectionDao
-import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
-import com.placeholder.sherpai2.data.local.entity.*
-import com.placeholder.sherpai2.data.local.model.CollectionWithDetails
-import com.placeholder.sherpai2.ui.search.DateRange
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.first
-import javax.inject.Inject
-import javax.inject.Singleton
-
-/**
- * CollectionRepository - Business logic for collections
- *
- * Handles:
- * - Creating smart/static collections
- * - Evaluating smart collection filters
- * - Managing photos in collections
- * - Export functionality
- */
-@Singleton
-class CollectionRepository @Inject constructor(
-    private val collectionDao: CollectionDao,
-    private val imageAggregateDao: ImageAggregateDao
-) {
-
-    // ==========================================
-    // COLLECTION OPERATIONS
-    // ==========================================
-
-    suspend fun createSmartCollection(
-        name: String,
-        description: String?,
-        includedPeople: Set<String>,
-        excludedPeople: Set<String>,
-        includedTags: Set<String>,
-        excludedTags: Set<String>,
-        dateRange: DateRange
-    ): String {
-        // Create collection
-        val collection = CollectionEntity.createSmart(name, description)
-        collectionDao.insert(collection)
-
-        // Save filters
-        val filters = mutableListOf<CollectionFilterEntity>()
-
-        includedPeople.forEach {
-            filters.add(
-                CollectionFilterEntity.create(
-                    collection.collectionId,
-                    "PERSON_INCLUDE",
-                    it
-                )
-            )
-        }
-
-        excludedPeople.forEach {
-            filters.add(
-                CollectionFilterEntity.create(
-                    collection.collectionId,
-                    "PERSON_EXCLUDE",
-                    it
-                )
-            )
-        }
-
-        includedTags.forEach {
-            filters.add(
-                CollectionFilterEntity.create(
-                    collection.collectionId,
-                    "TAG_INCLUDE",
-                    it
-                )
-            )
-        }
-
-        excludedTags.forEach {
-            filters.add(
-                CollectionFilterEntity.create(
-                    collection.collectionId,
-                    "TAG_EXCLUDE",
-                    it
-                )
-            )
-        }
-
-        if (dateRange != DateRange.ALL_TIME) {
-            filters.add(
-                CollectionFilterEntity.create(
-                    collection.collectionId,
-                    "DATE_RANGE",
-                    dateRange.name
-                )
-            )
-        }
-
-        if (filters.isNotEmpty()) {
-            collectionDao.insertFilters(filters)
-        }
-
-        // Evaluate and populate
-        evaluateSmartCollection(collection.collectionId)
-
-        return collection.collectionId
-    }
-
-    suspend fun createStaticCollection(
-        name: String,
-        description: String?,
-        imageIds: List<String>
-    ): String {
-        val collection = CollectionEntity.createStatic(name, description, imageIds.size)
-        collectionDao.insert(collection)
-
-        // Add images
-        val now = System.currentTimeMillis()
-        val collectionImages = imageIds.mapIndexed { index, imageId ->
-            CollectionImageEntity(
-                collectionId = collection.collectionId,
-                imageId = imageId,
-                addedAt = now,
-                sortOrder = index
-            )
-        }
-
-        collectionDao.addImages(collectionImages)
-        collectionDao.updatePhotoCount(collection.collectionId, now)
-
-        // Set cover image to first image
-        if (imageIds.isNotEmpty()) {
-            val firstImage = imageAggregateDao.observeAllImagesWithEverything()
-                .first()
-                .find { it.image.imageId == imageIds.first() }
-
-            if (firstImage != null) {
-                collectionDao.updateCoverImage(collection.collectionId, firstImage.image.imageUri, now)
-            }
-        }
-
-        return collection.collectionId
-    }
-
-    suspend fun deleteCollection(collectionId: String) {
-        collectionDao.deleteById(collectionId)
-    }
-
-    fun getAllCollections(): Flow<List<CollectionEntity>> {
-        return collectionDao.getAllCollections()
-    }
-
-    fun getCollection(collectionId: String): Flow<CollectionEntity?> {
-        return collectionDao.getByIdFlow(collectionId)
-    }
-
-    fun getCollectionWithDetails(collectionId: String): Flow<CollectionWithDetails?> {
-        return collectionDao.getCollectionWithDetails(collectionId)
-    }
-
-    // ==========================================
-    // IMAGE MANAGEMENT
-    // ==========================================
-
-    suspend fun addImageToCollection(collectionId: String, imageId: String) {
-        val now = System.currentTimeMillis()
-        val count = collectionDao.getPhotoCount(collectionId)
-
-        collectionDao.addImage(
-            CollectionImageEntity(
-                collectionId = collectionId,
-                imageId = imageId,
-                addedAt = now,
-                sortOrder = count
-            )
-        )
-
-        collectionDao.updatePhotoCount(collectionId, now)
-
-        // Update cover image if this is the first photo
-        if (count == 0) {
-            val images = collectionDao.getPreviewImages(collectionId)
-            if (images.isNotEmpty()) {
-                collectionDao.updateCoverImage(collectionId, images.first().imageUri, now)
-            }
-        }
-    }
-
-    suspend fun removeImageFromCollection(collectionId: String, imageId: String) {
-        collectionDao.removeImage(collectionId, imageId)
-        collectionDao.updatePhotoCount(collectionId, System.currentTimeMillis())
-    }
-
-    suspend fun toggleFavorite(imageId: String) {
-        val favCollection = collectionDao.getFavoriteCollection()
-            ?: run {
-                // Create favorites collection if it doesn't exist
-                val fav = CollectionEntity.createFavorite()
-                collectionDao.insert(fav)
-                fav
-            }
-
-        val isFavorite = collectionDao.containsImage(favCollection.collectionId, imageId)
-
-        if (isFavorite) {
-            removeImageFromCollection(favCollection.collectionId, imageId)
-        } else {
-            addImageToCollection(favCollection.collectionId, imageId)
-        }
-    }
-
-    suspend fun isFavorite(imageId: String): Boolean {
-        val favCollection = collectionDao.getFavoriteCollection() ?: return false
-        return collectionDao.containsImage(favCollection.collectionId, imageId)
-    }
-
-    fun getImagesInCollection(collectionId: String): Flow<List<ImageEntity>> {
-        return collectionDao.getImagesInCollection(collectionId)
-    }
-
-    // ==========================================
-    // SMART COLLECTION EVALUATION
-    // ==========================================
-
-    /**
-     * Re-evaluate a SMART collection's filters and update its images
-     */
-    suspend fun evaluateSmartCollection(collectionId: String) {
-        val collection = collectionDao.getById(collectionId) ?: return
-        if (collection.type != "SMART") return
-
-        val filters = collectionDao.getFilters(collectionId)
-        if (filters.isEmpty()) return
-
-        // Get all images
-        val allImages = imageAggregateDao.observeAllImagesWithEverything().first()
-
-        // Parse filters
-        val includedPeople = filters
-            .filter { it.filterType == "PERSON_INCLUDE" }
-            .map { it.filterValue }
-            .toSet()
-
-        val excludedPeople = filters
-            .filter { it.filterType == "PERSON_EXCLUDE" }
-            .map { it.filterValue }
-            .toSet()
-
-        val includedTags = filters
-            .filter { it.filterType == "TAG_INCLUDE" }
-            .map { it.filterValue }
-            .toSet()
-
-        val excludedTags = filters
-            .filter { it.filterType == "TAG_EXCLUDE" }
-            .map { it.filterValue }
-            .toSet()
-
-        // Filter images (same logic as SearchViewModel)
-        val matchingImages = allImages.filter { imageWithEverything ->
-            // TODO: Apply same Boolean logic as SearchViewModel
-            // For now, simple tag matching
-            val imageTags = imageWithEverything.tags.map { it.value }.toSet()
-
-            val hasIncludedTags = includedTags.isEmpty() || includedTags.all { it in imageTags }
-            val hasNoExcludedTags = excludedTags.isEmpty() || excludedTags.none { it in imageTags }
-
-            hasIncludedTags && hasNoExcludedTags
-        }.map { it.image.imageId }
-
-        // Update collection
-        collectionDao.clearAllImages(collectionId)
-
-        val now = System.currentTimeMillis()
-        val collectionImages = matchingImages.mapIndexed { index, imageId ->
-            CollectionImageEntity(
-                collectionId = collectionId,
-                imageId = imageId,
-                addedAt = now,
-                sortOrder = index
-            )
-        }
-
-        if (collectionImages.isNotEmpty()) {
-            collectionDao.addImages(collectionImages)
-
-            // Set cover image to first image
-            val firstImageId = matchingImages.first()
-            val firstImage = allImages.find { it.image.imageId == firstImageId }
-            if (firstImage != null) {
-                collectionDao.updateCoverImage(collectionId, firstImage.image.imageUri, now)
-            }
-        }
-
-        collectionDao.updatePhotoCount(collectionId, now)
-    }
-
-    /**
-     * Re-evaluate all SMART collections
-     */
-    suspend fun evaluateAllSmartCollections() {
-        val collections = collectionDao.getCollectionsByType("SMART").first()
-        collections.forEach { collection ->
-            evaluateSmartCollection(collection.collectionId)
-        }
-    }
-
-    // ==========================================
-    // UPDATES
-    // ==========================================
-
-    suspend fun updateCollectionDetails(
-        collectionId: String,
-        name: String,
-        description: String?
-    ) {
-        collectionDao.updateDetails(collectionId, name, description, System.currentTimeMillis())
-    }
-
-    suspend fun togglePinned(collectionId: String) {
-        val collection = collectionDao.getById(collectionId) ?: return
-        collectionDao.updatePinned(
-            collectionId,
-            !collection.isPinned,
-            System.currentTimeMillis()
-        )
-    }
-}

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

@@ -146,8 +146,6 @@ class FaceRecognitionRepository @Inject constructor(
     /**
      * Scan an image for faces and tag recognized persons.
      *
-     * ALSO UPDATES FACE DETECTION CACHE for optimization.
-     *
      * @param imageId String (from ImageEntity.imageId)
      */
     suspend fun scanImage(
@@ -156,16 +154,6 @@ class FaceRecognitionRepository @Inject constructor(
         threshold: Float = FaceNetModel.SIMILARITY_THRESHOLD_HIGH
     ): List<PhotoFaceTagEntity> = withContext(Dispatchers.Default) {
 
-        // OPTIMIZATION: Update face detection cache
-        // This makes future scans faster by skipping images without faces
-        withContext(Dispatchers.IO) {
-            imageDao.updateFaceDetectionCache(
-                imageId = imageId,
-                hasFaces = detectedFaces.isNotEmpty(),
-                faceCount = detectedFaces.size
-            )
-        }
-
         val faceModels = faceModelDao.getAllActiveFaceModels()
 
         if (faceModels.isEmpty()) {
@@ -388,14 +376,6 @@ class FaceRecognitionRepository @Inject constructor(
         photoFaceTagDao.deleteTagsForImage(imageId)
     }
 
-    /**
-     * Get all image IDs that have been tagged with this face model
-     * Used for scan optimization (skip already-tagged images)
-     */
-    suspend fun getImageIdsForFaceModel(faceModelId: String): List<String> = withContext(Dispatchers.IO) {
-        photoFaceTagDao.getImageIdsForFaceModel(faceModelId)
-    }
-
     fun cleanup() {
         faceNetModel.close()
     }
@@ -417,3 +397,4 @@ data class PersonFaceStats(
     val averageConfidence: Float,
     val lastDetectedAt: Long?
 )
+

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

@@ -3,7 +3,6 @@ package com.placeholder.sherpai2.di
 import android.content.Context
 import androidx.room.Room
 import com.placeholder.sherpai2.data.local.AppDatabase
-import com.placeholder.sherpai2.data.local.MIGRATION_7_8
 import com.placeholder.sherpai2.data.local.dao.*
 import dagger.Module
 import dagger.Provides
@@ -15,9 +14,9 @@ import javax.inject.Singleton
 /**
  * DatabaseModule - Provides database and ALL DAOs
  *
- * PHASE 2 UPDATES:
+ * DEVELOPMENT CONFIGURATION:
- * - Added PersonAgeTagDao
+ * - fallbackToDestructiveMigration enabled
- * - Added migration v7→v8 (commented out for development)
+ * - No migrations required
  */
 @Module
 @InstallIn(SingletonComponent::class)
@@ -35,12 +34,7 @@ object DatabaseModule {
             AppDatabase::class.java,
             "sherpai.db"
         )
-            // DEVELOPMENT MODE: Destructive migration (fresh install on schema change)
             .fallbackToDestructiveMigration()
-
-            // PRODUCTION MODE: Uncomment this and remove fallbackToDestructiveMigration()
-            // .addMigrations(MIGRATION_7_8)
-
             .build()
 
     // ===== CORE DAOs =====
@@ -82,14 +76,4 @@ object DatabaseModule {
     @Provides
     fun providePhotoFaceTagDao(db: AppDatabase): PhotoFaceTagDao =
         db.photoFaceTagDao()
-
-    @Provides
-    fun providePersonAgeTagDao(db: AppDatabase): PersonAgeTagDao =  // NEW
-        db.personAgeTagDao()
-
-    // ===== COLLECTIONS DAOs =====
-
-    @Provides
-    fun provideCollectionDao(db: AppDatabase): CollectionDao =
-        db.collectionDao()
 }

app/src/main/java/com/placeholder/sherpai2/domain/clustering/Faceclusteringservice.kt

@@ -1,465 +0,0 @@
-package com.placeholder.sherpai2.domain.clustering
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-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 com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.ml.FaceNetModel
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.withContext
-import java.util.concurrent.atomic.AtomicInteger
-import javax.inject.Inject
-import javax.inject.Singleton
-import kotlin.math.sqrt
-
-/**
- * FaceClusteringService - Auto-discover people in photo library
- *
- * STRATEGY:
- * 1. Load all images with faces (from cache)
- * 2. Detect faces and generate embeddings (parallel)
- * 3. DBSCAN clustering on embeddings
- * 4. Co-occurrence analysis (faces in same photo)
- * 5. Return high-quality clusters (10-100 people typical)
- *
- * PERFORMANCE:
- * - Uses face detection cache (only ~30% of photos)
- * - Parallel processing (12 concurrent)
- * - Smart sampling (don't need ALL faces for clustering)
- * - Result: ~2-5 minutes for 10,000 photo library
- */
-@Singleton
-class FaceClusteringService @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val imageDao: ImageDao
-) {
-
-    private val semaphore = Semaphore(12)
-
-    /**
-     * Main clustering entry point
-     *
-     * @param maxFacesToCluster Limit for performance (default 2000)
-     * @param onProgress Progress callback (current, total, message)
-     */
-    suspend fun discoverPeople(
-        maxFacesToCluster: Int = 2000,
-        onProgress: (Int, Int, String) -> Unit = { _, _, _ -> }
-    ): ClusteringResult = withContext(Dispatchers.Default) {
-
-        onProgress(0, 100, "Loading images with faces...")
-
-        // Step 1: Get images with faces (cached, fast!)
-        val imagesWithFaces = imageDao.getImagesWithFaces()
-
-        if (imagesWithFaces.isEmpty()) {
-            // Check if face cache is populated at all
-            val totalImages = withContext(Dispatchers.IO) {
-                imageDao.getImageCount()
-            }
-
-            if (totalImages == 0) {
-                return@withContext ClusteringResult(
-                    clusters = emptyList(),
-                    totalFacesAnalyzed = 0,
-                    processingTimeMs = 0,
-                    errorMessage = "No photos in library. Please wait for photo ingestion to complete."
-                )
-            }
-
-            // Images exist but no face cache - need to run PopulateFaceDetectionCacheUseCase first
-            return@withContext ClusteringResult(
-                clusters = emptyList(),
-                totalFacesAnalyzed = 0,
-                processingTimeMs = 0,
-                errorMessage = "Face detection cache not ready. Please wait for initial face scan to complete (check MainActivity progress bar)."
-            )
-        }
-
-        onProgress(10, 100, "Analyzing ${imagesWithFaces.size} photos...")
-
-        val startTime = System.currentTimeMillis()
-
-        // Step 2: Detect faces and generate embeddings (parallel)
-        val allFaces = detectFacesInImages(
-            images = imagesWithFaces.take(1000), // Smart limit: don't need all photos
-            onProgress = { current, total ->
-                onProgress(10 + (current * 40 / total), 100, "Detecting faces... $current/$total")
-            }
-        )
-
-        if (allFaces.isEmpty()) {
-            return@withContext ClusteringResult(
-                clusters = emptyList(),
-                totalFacesAnalyzed = 0,
-                processingTimeMs = System.currentTimeMillis() - startTime
-            )
-        }
-
-        onProgress(50, 100, "Clustering ${allFaces.size} faces...")
-
-        // Step 3: DBSCAN clustering on embeddings
-        val rawClusters = performDBSCAN(
-            faces = allFaces.take(maxFacesToCluster),
-            epsilon = 0.30f,  // BALANCED: Not too strict, not too loose
-            minPoints = 5      // Minimum 5 photos to form a cluster
-        )
-
-        onProgress(70, 100, "Analyzing relationships...")
-
-        // Step 4: Build co-occurrence graph
-        val coOccurrenceGraph = buildCoOccurrenceGraph(rawClusters)
-
-        onProgress(80, 100, "Selecting representative faces...")
-
-        // Step 5: Select representative faces for each cluster
-        val clusters = rawClusters.map { cluster ->
-            FaceCluster(
-                clusterId = cluster.clusterId,
-                faces = cluster.faces,
-                representativeFaces = selectRepresentativeFaces(cluster.faces, count = 6),
-                photoCount = cluster.faces.map { it.imageId }.distinct().size,
-                averageConfidence = cluster.faces.map { it.confidence }.average().toFloat(),
-                estimatedAge = estimateAge(cluster.faces),
-                potentialSiblings = findPotentialSiblings(cluster, rawClusters, coOccurrenceGraph)
-            )
-        }.sortedByDescending { it.photoCount } // Most frequent first
-
-        onProgress(100, 100, "Found ${clusters.size} people!")
-
-        ClusteringResult(
-            clusters = clusters,
-            totalFacesAnalyzed = allFaces.size,
-            processingTimeMs = System.currentTimeMillis() - startTime
-        )
-    }
-
-    /**
-     * Detect faces in images and generate embeddings (parallel)
-     */
-    private suspend fun detectFacesInImages(
-        images: List<ImageEntity>,
-        onProgress: (Int, Int) -> Unit
-    ): List<DetectedFaceWithEmbedding> = coroutineScope {
-
-        val detector = com.google.mlkit.vision.face.FaceDetection.getClient(
-            com.google.mlkit.vision.face.FaceDetectorOptions.Builder()
-                .setPerformanceMode(com.google.mlkit.vision.face.FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
-                .setMinFaceSize(0.15f)
-                .build()
-        )
-
-        val faceNetModel = FaceNetModel(context)
-        val allFaces = mutableListOf<DetectedFaceWithEmbedding>()
-        val processedCount = java.util.concurrent.atomic.AtomicInteger(0)
-
-        try {
-            val jobs = images.map { image ->
-                async {
-                    semaphore.acquire()
-                    try {
-                        val faces = detectFacesInImage(image, detector, faceNetModel)
-                        val current = processedCount.incrementAndGet()
-                        if (current % 10 == 0) {
-                            onProgress(current, images.size)
-                        }
-                        faces
-                    } finally {
-                        semaphore.release()
-                    }
-                }
-            }
-
-            jobs.awaitAll().flatten().also {
-                allFaces.addAll(it)
-            }
-
-        } finally {
-            detector.close()
-            faceNetModel.close()
-        }
-
-        allFaces
-    }
-
-    private suspend fun detectFacesInImage(
-        image: ImageEntity,
-        detector: com.google.mlkit.vision.face.FaceDetector,
-        faceNetModel: FaceNetModel
-    ): List<DetectedFaceWithEmbedding> = withContext(Dispatchers.IO) {
-
-        try {
-            val uri = Uri.parse(image.imageUri)
-            val bitmap = loadBitmapDownsampled(uri, 512) ?: return@withContext emptyList()
-
-            val mlImage = com.google.mlkit.vision.common.InputImage.fromBitmap(bitmap, 0)
-            val faces = com.google.android.gms.tasks.Tasks.await(detector.process(mlImage))
-
-            val result = faces.mapNotNull { face ->
-                try {
-                    val faceBitmap = Bitmap.createBitmap(
-                        bitmap,
-                        face.boundingBox.left.coerceIn(0, bitmap.width - 1),
-                        face.boundingBox.top.coerceIn(0, bitmap.height - 1),
-                        face.boundingBox.width().coerceAtMost(bitmap.width - face.boundingBox.left),
-                        face.boundingBox.height().coerceAtMost(bitmap.height - face.boundingBox.top)
-                    )
-
-                    val embedding = faceNetModel.generateEmbedding(faceBitmap)
-                    faceBitmap.recycle()
-
-                    DetectedFaceWithEmbedding(
-                        imageId = image.imageId,
-                        imageUri = image.imageUri,
-                        capturedAt = image.capturedAt,
-                        embedding = embedding,
-                        boundingBox = face.boundingBox,
-                        confidence = 1.0f // Placeholder
-                    )
-                } catch (e: Exception) {
-                    null
-                }
-            }
-
-            bitmap.recycle()
-            result
-
-        } catch (e: Exception) {
-            emptyList()
-        }
-    }
-
-    /**
-     * DBSCAN clustering algorithm
-     */
-    private fun performDBSCAN(
-        faces: List<DetectedFaceWithEmbedding>,
-        epsilon: Float,
-        minPoints: Int
-    ): List<RawCluster> {
-
-        val visited = mutableSetOf<Int>()
-        val clusters = mutableListOf<RawCluster>()
-        var clusterId = 0
-
-        for (i in faces.indices) {
-            if (i in visited) continue
-
-            val neighbors = findNeighbors(i, faces, epsilon)
-
-            if (neighbors.size < minPoints) {
-                visited.add(i)
-                continue // Noise point
-            }
-
-            // Start new cluster
-            val cluster = mutableListOf<DetectedFaceWithEmbedding>()
-            val queue = ArrayDeque(neighbors)
-            visited.add(i)
-            cluster.add(faces[i])
-
-            while (queue.isNotEmpty()) {
-                val pointIdx = queue.removeFirst()
-                if (pointIdx in visited) continue
-
-                visited.add(pointIdx)
-                cluster.add(faces[pointIdx])
-
-                val pointNeighbors = findNeighbors(pointIdx, faces, epsilon)
-                if (pointNeighbors.size >= minPoints) {
-                    queue.addAll(pointNeighbors.filter { it !in visited })
-                }
-            }
-
-            if (cluster.size >= minPoints) {
-                clusters.add(RawCluster(clusterId++, cluster))
-            }
-        }
-
-        return clusters
-    }
-
-    private fun findNeighbors(
-        pointIdx: Int,
-        faces: List<DetectedFaceWithEmbedding>,
-        epsilon: Float
-    ): List<Int> {
-        val point = faces[pointIdx]
-        return faces.indices.filter { i ->
-            i != pointIdx && cosineSimilarity(point.embedding, faces[i].embedding) > (1 - epsilon)
-        }
-    }
-
-    private fun cosineSimilarity(a: FloatArray, b: FloatArray): Float {
-        var dotProduct = 0f
-        var normA = 0f
-        var normB = 0f
-
-        for (i in a.indices) {
-            dotProduct += a[i] * b[i]
-            normA += a[i] * a[i]
-            normB += b[i] * b[i]
-        }
-
-        return dotProduct / (sqrt(normA) * sqrt(normB))
-    }
-
-    /**
-     * Build co-occurrence graph (faces appearing in same photos)
-     */
-    private fun buildCoOccurrenceGraph(clusters: List<RawCluster>): Map<Int, Map<Int, Int>> {
-        val graph = mutableMapOf<Int, MutableMap<Int, Int>>()
-
-        for (i in clusters.indices) {
-            graph[i] = mutableMapOf()
-            val imageIds = clusters[i].faces.map { it.imageId }.toSet()
-
-            for (j in clusters.indices) {
-                if (i == j) continue
-
-                val sharedImages = clusters[j].faces.count { it.imageId in imageIds }
-                if (sharedImages > 0) {
-                    graph[i]!![j] = sharedImages
-                }
-            }
-        }
-
-        return graph
-    }
-
-    private fun findPotentialSiblings(
-        cluster: RawCluster,
-        allClusters: List<RawCluster>,
-        coOccurrenceGraph: Map<Int, Map<Int, Int>>
-    ): List<Int> {
-        val clusterIdx = allClusters.indexOf(cluster)
-        if (clusterIdx == -1) return emptyList()
-
-        val siblings = coOccurrenceGraph[clusterIdx]
-            ?.filter { (_, count) -> count >= 5 } // At least 5 shared photos
-            ?.keys
-            ?.toList()
-            ?: emptyList()
-
-        return siblings
-    }
-
-    /**
-     * Select diverse representative faces for UI display
-     */
-    private fun selectRepresentativeFaces(
-        faces: List<DetectedFaceWithEmbedding>,
-        count: Int
-    ): List<DetectedFaceWithEmbedding> {
-        if (faces.size <= count) return faces
-
-        // Time-based sampling: spread across different dates
-        val sortedByTime = faces.sortedBy { it.capturedAt }
-        val step = faces.size / count
-
-        return (0 until count).map { i ->
-            sortedByTime[i * step]
-        }
-    }
-
-    /**
-     * Estimate if cluster represents a child (based on photo timestamps)
-     */
-    private fun estimateAge(faces: List<DetectedFaceWithEmbedding>): AgeEstimate {
-        val timestamps = faces.map { it.capturedAt }.sorted()
-        val span = timestamps.last() - timestamps.first()
-        val spanYears = span / (365.25 * 24 * 60 * 60 * 1000)
-
-        // If face appearance changes over 3+ years, likely a child
-        return if (spanYears > 3.0) {
-            AgeEstimate.CHILD
-        } else {
-            AgeEstimate.UNKNOWN
-        }
-    }
-
-    private fun loadBitmapDownsampled(uri: Uri, maxDim: Int): Bitmap? {
-        return try {
-            val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-            context.contentResolver.openInputStream(uri)?.use {
-                BitmapFactory.decodeStream(it, null, opts)
-            }
-
-            var sample = 1
-            while (opts.outWidth / sample > maxDim || opts.outHeight / sample > maxDim) {
-                sample *= 2
-            }
-
-            val finalOpts = BitmapFactory.Options().apply {
-                inSampleSize = sample
-                inPreferredConfig = Bitmap.Config.RGB_565
-            }
-
-            context.contentResolver.openInputStream(uri)?.use {
-                BitmapFactory.decodeStream(it, null, finalOpts)
-            }
-        } catch (e: Exception) {
-            null
-        }
-    }
-}
-
-// ==================
-// DATA CLASSES
-// ==================
-
-data class DetectedFaceWithEmbedding(
-    val imageId: String,
-    val imageUri: String,
-    val capturedAt: Long,
-    val embedding: FloatArray,
-    val boundingBox: android.graphics.Rect,
-    val confidence: Float
-) {
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (javaClass != other?.javaClass) return false
-        other as DetectedFaceWithEmbedding
-        return imageId == other.imageId
-    }
-
-    override fun hashCode(): Int = imageId.hashCode()
-}
-
-data class RawCluster(
-    val clusterId: Int,
-    val faces: List<DetectedFaceWithEmbedding>
-)
-
-data class FaceCluster(
-    val clusterId: Int,
-    val faces: List<DetectedFaceWithEmbedding>,
-    val representativeFaces: List<DetectedFaceWithEmbedding>,
-    val photoCount: Int,
-    val averageConfidence: Float,
-    val estimatedAge: AgeEstimate,
-    val potentialSiblings: List<Int>
-)
-
-data class ClusteringResult(
-    val clusters: List<FaceCluster>,
-    val totalFacesAnalyzed: Int,
-    val processingTimeMs: Long,
-    val errorMessage: String? = null
-)
-
-enum class AgeEstimate {
-    CHILD,     // Appearance changes significantly over time
-    ADULT,     // Stable appearance
-    UNKNOWN    // Not enough data
-}

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

@@ -1,10 +1,5 @@
 package com.placeholder.sherpai2.domain.repository
 
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.net.Uri
-import com.placeholder.sherpai2.data.local.dao.FaceCacheStats
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
 import com.placeholder.sherpai2.data.local.model.ImageWithEverything
 import kotlinx.coroutines.flow.Flow
 
@@ -28,60 +23,11 @@ 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>>
 
     fun getRecentImages(limit: Int): Flow<List<ImageWithEverything>>
-
-    // ==========================================
-    // FACE DETECTION CACHE - NEW METHODS
-    // ==========================================
-
-    /**
-     * Update face detection cache for a single image
-     * Called after detecting faces in an image
-     */
-    suspend fun updateFaceDetectionCache(
-        imageId: String,
-        hasFaces: Boolean,
-        faceCount: Int
-    )
-
-    /**
-     * Get cache statistics
-     * Useful for displaying cache coverage in UI
-     */
-    suspend fun getFaceCacheStats(): FaceCacheStats?
-
-    /**
-     * Get images that need face detection
-     * For background maintenance tasks
-     */
-    suspend fun getImagesNeedingFaceDetection(): List<ImageEntity>
-
-    /**
-     * Load bitmap from URI with optional BitmapFactory.Options
-     * Used for face detection and other image processing
-     */
-    suspend fun loadBitmap(
-        uri: Uri,
-        options: BitmapFactory.Options? = null
-    ): Bitmap?
 }

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

@@ -2,13 +2,10 @@ package com.placeholder.sherpai2.domain.repository
 
 import android.content.ContentUris
 import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
 import android.net.Uri
 import android.provider.MediaStore
 import android.util.Log
 import com.placeholder.sherpai2.data.local.dao.EventDao
-import com.placeholder.sherpai2.data.local.dao.FaceCacheStats
 import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
 import com.placeholder.sherpai2.data.local.dao.ImageDao
 import com.placeholder.sherpai2.data.local.dao.ImageEventDao
@@ -18,20 +15,11 @@ 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 - SUPER FAST ingestion
- *
- * OPTIMIZATIONS:
- * - Skip SHA256 computation entirely (use URI as unique key)
- * - Larger batch sizes (200 instead of 100)
- * - Less frequent progress updates
- * - No unnecessary string operations
- */
 @Singleton
 class ImageRepositoryImpl @Inject constructor(
     private val imageDao: ImageDao,
@@ -45,57 +33,25 @@ class ImageRepositoryImpl @Inject constructor(
         return aggregateDao.observeImageWithEverything(imageId)
     }
 
-    override suspend fun getImageCount(): Int = withContext(Dispatchers.IO) {
-        return@withContext imageDao.getImageCount()
-    }
-
-    override suspend fun ingestImages(): Unit = withContext(Dispatchers.IO) {
-        ingestImagesWithProgress { _, _ -> }
-    }
-
     /**
-     * OPTIMIZED ingestion - 2-3x faster than before!
+     * Ingest all images from MediaStore.
+     * Uses _ID and DATE_ADDED to ensure no image is skipped, even if DATE_TAKEN is identical.
      */
-    override suspend fun ingestImagesWithProgress(
+    override suspend fun ingestImages(): Unit = withContext(Dispatchers.IO) {
-        onProgress: (current: Int, total: Int) -> Unit
-    ): Unit = withContext(Dispatchers.IO) {
         try {
+            val imageList = mutableListOf<ImageEntity>()
+
             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
             )
 
             val sortOrder = "${MediaStore.Images.Media.DATE_ADDED} ASC"
 
-            // Count total images
-            var totalImages = 0
-            context.contentResolver.query(
-                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
-                arrayOf(MediaStore.Images.Media._ID),
-                null,
-                null,
-                null
-            )?.use { cursor ->
-                totalImages = cursor.count
-            }
-
-            if (totalImages == 0) {
-                Log.i("ImageRepository", "No images found")
-                return@withContext
-            }
-
-            Log.i("ImageRepository", "Found $totalImages images")
-            onProgress(0, totalImages)
-
-            // LARGER batches for speed
-            val batchSize = 200
-            var processed = 0
-            val ingestTime = System.currentTimeMillis()
-
             context.contentResolver.query(
                 MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                 projection,
@@ -103,86 +59,77 @@ class ImageRepositoryImpl @Inject constructor(
                 null,
                 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)
+                    val displayName = cursor.getString(nameCol)
                     val dateTaken = cursor.getLong(dateTakenCol)
                     val dateAdded = cursor.getLong(dateAddedCol)
                     val width = cursor.getInt(widthCol)
                     val height = cursor.getInt(heightCol)
-                    val filePath = cursor.getString(dataCol) ?: ""
 
-                    val contentUri = ContentUris.withAppendedId(
+                    val contentUri: Uri = ContentUris.withAppendedId(
-                        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                        MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id
-                        id
                     )
 
-                    // OPTIMIZATION: Use URI as SHA256 (skip expensive hash computation)
+                    val sha256 = computeSHA256(contentUri)
-                    val uriString = contentUri.toString()
+                    if (sha256 == null) {
+                        Log.w("ImageRepository", "Skipped image: $displayName (cannot read bytes)")
+                        continue
+                    }
 
                     val imageEntity = ImageEntity(
                         imageId = UUID.randomUUID().toString(),
-                        imageUri = uriString,
+                        imageUri = contentUri.toString(),
-                        sha256 = uriString, // Fast! No file I/O
+                        sha256 = sha256,
                         capturedAt = if (dateTaken > 0) dateTaken else dateAdded * 1000,
-                        ingestedAt = ingestTime,
+                        ingestedAt = System.currentTimeMillis(),
                         width = width,
                         height = height,
-                        source = determineSourceFast(filePath)
+                        source = "CAMERA" // or SCREENSHOT / IMPORTED
                     )
 
-                    batch.add(imageEntity)
+                    imageList += imageEntity
-                    processed++
+                    Log.i("ImageRepository", "Processing image: $displayName, SHA256: $sha256")
-
-                    // Insert batch
-                    if (batch.size >= batchSize) {
-                        imageDao.insertImages(batch)
-                        batch.clear()
-
-                        // Update progress less frequently (every 200 images)
-                        withContext(Dispatchers.Main) {
-                            onProgress(processed, totalImages)
-                        }
-
-                        yield()
                 }
             }
 
-                // Insert remaining
+            if (imageList.isNotEmpty()) {
-                if (batch.isNotEmpty()) {
+                imageDao.insertImages(imageList)
-                    imageDao.insertImages(batch)
+                Log.i("ImageRepository", "Ingested ${imageList.size} images")
-                    withContext(Dispatchers.Main) {
+            } else {
-                        onProgress(processed, totalImages)
+                Log.i("ImageRepository", "No images found on device")
             }
-                }
-            }
-
-            Log.i("ImageRepository", "Ingestion complete: $processed images")
 
         } catch (e: Exception) {
             Log.e("ImageRepository", "Error ingesting images", e)
-            throw e
         }
     }
 
     /**
-     * FAST source determination - no regex, just contains checks
+     * Compute SHA256 from a MediaStore Uri safely.
      */
-    private fun determineSourceFast(filePath: String): String {
+    private fun computeSHA256(uri: Uri): String? {
-        return when {
+        return try {
-            filePath.contains("DCIM", ignoreCase = true) -> "CAMERA"
+            val digest = MessageDigest.getInstance("SHA-256")
-            filePath.contains("Screenshot", ignoreCase = true) -> "SCREENSHOT"
+            context.contentResolver.openInputStream(uri)?.use { input ->
-            filePath.contains("Download", ignoreCase = true) -> "IMPORTED"
+                val buffer = ByteArray(8192)
-            filePath.contains("WhatsApp", ignoreCase = true) -> "IMPORTED"
+                var read: Int
-            else -> "CAMERA"
+                while (input.read(buffer).also { read = it } > 0) {
+                    digest.update(buffer, 0, read)
+                }
+            } ?: return null
+            digest.digest().joinToString("") { "%02x".format(it) }
+        } catch (e: Exception) {
+            Log.e("ImageRepository", "Failed SHA256 for $uri", e)
+            null
         }
     }
 
@@ -197,41 +144,4 @@ class ImageRepositoryImpl @Inject constructor(
     override fun getRecentImages(limit: Int): Flow<List<ImageWithEverything>> {
         return imageDao.getRecentImages(limit)
     }
-
-    // Face detection cache methods
-    override suspend fun updateFaceDetectionCache(
-        imageId: String,
-        hasFaces: Boolean,
-        faceCount: Int
-    ) = withContext(Dispatchers.IO) {
-        imageDao.updateFaceDetectionCache(
-            imageId = imageId,
-            hasFaces = hasFaces,
-            faceCount = faceCount,
-            timestamp = System.currentTimeMillis(),
-            version = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-        )
-    }
-
-    override suspend fun getFaceCacheStats(): FaceCacheStats? = withContext(Dispatchers.IO) {
-        imageDao.getFaceCacheStats()
-    }
-
-    override suspend fun getImagesNeedingFaceDetection(): List<ImageEntity> = withContext(Dispatchers.IO) {
-        imageDao.getImagesNeedingFaceDetection()
-    }
-
-    override suspend fun loadBitmap(
-        uri: Uri,
-        options: BitmapFactory.Options?
-    ): Bitmap? = withContext(Dispatchers.IO) {
-        try {
-            context.contentResolver.openInputStream(uri)?.use { stream ->
-                BitmapFactory.decodeStream(stream, null, options)
-            }
-        } catch (e: Exception) {
-            Log.e("ImageRepository", "Failed to load bitmap from $uri", e)
-            null
-        }
-    }
 }

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

@@ -1,124 +0,0 @@
-package com.placeholder.sherpai2.domain.repository
-
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-
-/**
- * Extension functions for ImageRepository to support face detection cache
- *
- * Add these methods to your ImageRepository interface or implementation
- */
-
-/**
- * Update face detection cache for a single image
- * Called after detecting faces in an image
- */
-suspend fun ImageRepository.updateFaceDetectionCache(
-    imageId: String,
-    hasFaces: Boolean,
-    faceCount: Int
-) {
-    // Assuming you have access to ImageDao in your repository
-    // Adjust based on your actual repository structure
-    getImageDao().updateFaceDetectionCache(
-        imageId = imageId,
-        hasFaces = hasFaces,
-        faceCount = faceCount,
-        timestamp = System.currentTimeMillis(),
-        version = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-    )
-}
-
-/**
- * Get cache statistics
- * Useful for displaying cache coverage in UI
- */
-suspend fun ImageRepository.getFaceCacheStats() =
-    getImageDao().getFaceCacheStats()
-
-/**
- * Get images that need face detection
- * For background maintenance tasks
- */
-suspend fun ImageRepository.getImagesNeedingFaceDetection() =
-    getImageDao().getImagesNeedingFaceDetection()
-
-/**
- * Batch populate face detection cache
- * For initial cache population or maintenance
- */
-suspend fun ImageRepository.populateFaceDetectionCache(
-    onProgress: (current: Int, total: Int) -> Unit = { _, _ -> }
-) {
-    val imagesToProcess = getImageDao().getImagesNeedingFaceDetection()
-    val total = imagesToProcess.size
-
-    imagesToProcess.forEachIndexed { index, image ->
-        try {
-            // Detect faces (implement based on your face detection logic)
-            val faceCount = detectFaceCount(image.imageUri)
-
-            updateFaceDetectionCache(
-                imageId = image.imageId,
-                hasFaces = faceCount > 0,
-                faceCount = faceCount
-            )
-
-            if (index % 10 == 0) {
-                onProgress(index, total)
-            }
-        } catch (e: Exception) {
-            // Skip errors, continue with next image
-        }
-    }
-
-    onProgress(total, total)
-}
-
-/**
- * Helper to get ImageDao from repository
- * Adjust based on your actual repository structure
- */
-private fun ImageRepository.getImageDao(): ImageDao {
-    // This assumes your ImageRepository has a reference to ImageDao
-    // Adjust based on your actual implementation:
-    // Option 1: If ImageRepository is an interface, add this as a method
-    // Option 2: If it's a class, access the dao directly
-    // Option 3: Pass ImageDao as a parameter to these functions
-    throw NotImplementedError("Implement based on your repository structure")
-}
-
-/**
- * Helper to detect face count
- * Implement based on your face detection logic
- */
-private suspend fun ImageRepository.detectFaceCount(imageUri: String): Int {
-    // Implement your face detection logic here
-    // This is a placeholder - adjust based on your FaceDetectionHelper
-    throw NotImplementedError("Implement based on your face detection logic")
-}
-
-/**
- * ALTERNATIVE: If you prefer to add methods directly to ImageRepository,
- * add these to your ImageRepository interface:
- *
- * interface ImageRepository {
- *     // ... existing methods
- *
- *     suspend fun updateFaceDetectionCache(
- *         imageId: String,
- *         hasFaces: Boolean,
- *         faceCount: Int
- *     )
- *
- *     suspend fun getFaceCacheStats(): FaceCacheStats?
- *
- *     suspend fun getImagesNeedingFaceDetection(): List<ImageEntity>
- *
- *     suspend fun populateFaceDetectionCache(
- *         onProgress: (current: Int, total: Int) -> Unit = { _, _ -> }
- *     )
- * }
- *
- * Then implement these in your ImageRepositoryImpl class.
- */

app/src/main/java/com/placeholder/sherpai2/domain/training/Clustertrainingservice.kt

@@ -1,234 +0,0 @@
-package com.placeholder.sherpai2.domain.training
-
-import android.content.Context
-import android.graphics.BitmapFactory
-import android.net.Uri
-import com.placeholder.sherpai2.data.local.dao.FaceModelDao
-import com.placeholder.sherpai2.data.local.dao.PersonDao
-import com.placeholder.sherpai2.data.local.entity.FaceModelEntity
-import com.placeholder.sherpai2.data.local.entity.PersonEntity
-import com.placeholder.sherpai2.data.local.entity.TemporalCentroid
-import com.placeholder.sherpai2.domain.clustering.FaceCluster
-import com.placeholder.sherpai2.ml.FaceNetModel
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import javax.inject.Inject
-import javax.inject.Singleton
-import kotlin.math.abs
-
-/**
- * ClusterTrainingService - Train multi-centroid face models from clusters
- *
- * STRATEGY:
- * 1. For children: Create multiple temporal centroids (one per age period)
- * 2. For adults: Create single centroid (stable appearance)
- * 3. Use K-Means clustering on timestamps to find age groups
- * 4. Calculate centroid for each time period
- */
-@Singleton
-class ClusterTrainingService @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val personDao: PersonDao,
-    private val faceModelDao: FaceModelDao
-) {
-
-    private val faceNetModel by lazy { FaceNetModel(context) }
-
-    /**
-     * Train a person from an auto-discovered cluster
-     *
-     * @return PersonId on success
-     */
-    suspend fun trainFromCluster(
-        cluster: FaceCluster,
-        name: String,
-        dateOfBirth: Long?,
-        isChild: Boolean,
-        siblingClusterIds: List<Int>,
-        onProgress: (Int, Int, String) -> Unit = { _, _, _ -> }
-    ): String = withContext(Dispatchers.Default) {
-
-        onProgress(0, 100, "Creating person...")
-
-        // Step 1: Create PersonEntity
-        val person = PersonEntity.create(
-            name = name,
-            dateOfBirth = dateOfBirth,
-            isChild = isChild,
-            siblingIds = emptyList(), // Will update after siblings are created
-            relationship = if (isChild) "Child" else null
-        )
-
-        withContext(Dispatchers.IO) {
-            personDao.insert(person)
-        }
-
-        onProgress(20, 100, "Analyzing face variations...")
-
-        // Step 2: Generate embeddings for all faces in cluster
-        val facesWithEmbeddings = cluster.faces.mapNotNull { face ->
-            try {
-                val bitmap = context.contentResolver.openInputStream(Uri.parse(face.imageUri))?.use {
-                    BitmapFactory.decodeStream(it)
-                } ?: return@mapNotNull null
-
-                // Generate embedding
-                val embedding = faceNetModel.generateEmbedding(bitmap)
-                bitmap.recycle()
-
-                Triple(face.imageUri, face.capturedAt, embedding)
-            } catch (e: Exception) {
-                null
-            }
-        }
-
-        if (facesWithEmbeddings.isEmpty()) {
-            throw Exception("Failed to process any faces from cluster")
-        }
-
-        onProgress(50, 100, "Creating face model...")
-
-        // Step 3: Create centroids based on whether person is a child
-        val centroids = if (isChild && dateOfBirth != null) {
-            createTemporalCentroidsForChild(
-                facesWithEmbeddings = facesWithEmbeddings,
-                dateOfBirth = dateOfBirth
-            )
-        } else {
-            createSingleCentroid(facesWithEmbeddings)
-        }
-
-        onProgress(80, 100, "Saving model...")
-
-        // Step 4: Calculate average confidence
-        val avgConfidence = centroids.map { it.avgConfidence }.average().toFloat()
-
-        // Step 5: Create FaceModelEntity
-        val faceModel = FaceModelEntity.createFromCentroids(
-            personId = person.id,
-            centroids = centroids,
-            trainingImageCount = cluster.faces.size,
-            averageConfidence = avgConfidence
-        )
-
-        withContext(Dispatchers.IO) {
-            faceModelDao.insertFaceModel(faceModel)
-        }
-
-        onProgress(100, 100, "Complete!")
-
-        person.id
-    }
-
-    /**
-     * Create temporal centroids for a child
-     * Groups faces by age and creates one centroid per age period
-     */
-    private fun createTemporalCentroidsForChild(
-        facesWithEmbeddings: List<Triple<String, Long, FloatArray>>,
-        dateOfBirth: Long
-    ): List<TemporalCentroid> {
-
-        // Group faces by age (in years)
-        val facesByAge = facesWithEmbeddings.groupBy { (_, capturedAt, _) ->
-            val ageMs = capturedAt - dateOfBirth
-            val ageYears = (ageMs / (365.25 * 24 * 60 * 60 * 1000)).toInt()
-            ageYears.coerceIn(0, 18) // Cap at 18 years
-        }
-
-        // Create one centroid per age group
-        return facesByAge.map { (age, faces) ->
-            val embeddings = faces.map { it.third }
-            val avgEmbedding = averageEmbeddings(embeddings)
-            val avgTimestamp = faces.map { it.second }.average().toLong()
-
-            // Calculate confidence (how similar faces are to each other)
-            val confidences = embeddings.map { emb ->
-                cosineSimilarity(avgEmbedding, emb)
-            }
-            val avgConfidence = confidences.average().toFloat()
-
-            TemporalCentroid(
-                embedding = avgEmbedding.toList(),
-                effectiveTimestamp = avgTimestamp,
-                ageAtCapture = age.toFloat(),
-                photoCount = faces.size,
-                timeRangeMonths = 12, // 1 year window
-                avgConfidence = avgConfidence
-            )
-        }.sortedBy { it.ageAtCapture }
-    }
-
-    /**
-     * Create single centroid for an adult (stable appearance)
-     */
-    private fun createSingleCentroid(
-        facesWithEmbeddings: List<Triple<String, Long, FloatArray>>
-    ): List<TemporalCentroid> {
-
-        val embeddings = facesWithEmbeddings.map { it.third }
-        val avgEmbedding = averageEmbeddings(embeddings)
-        val avgTimestamp = facesWithEmbeddings.map { it.second }.average().toLong()
-
-        val confidences = embeddings.map { emb ->
-            cosineSimilarity(avgEmbedding, emb)
-        }
-        val avgConfidence = confidences.average().toFloat()
-
-        return listOf(
-            TemporalCentroid(
-                embedding = avgEmbedding.toList(),
-                effectiveTimestamp = avgTimestamp,
-                ageAtCapture = null,
-                photoCount = facesWithEmbeddings.size,
-                timeRangeMonths = 24, // 2 year window for adults
-                avgConfidence = avgConfidence
-            )
-        )
-    }
-
-    /**
-     * Average multiple embeddings into one
-     */
-    private fun averageEmbeddings(embeddings: List<FloatArray>): FloatArray {
-        val size = embeddings.first().size
-        val avg = FloatArray(size) { 0f }
-
-        embeddings.forEach { embedding ->
-            for (i in embedding.indices) {
-                avg[i] += embedding[i]
-            }
-        }
-
-        val count = embeddings.size.toFloat()
-        for (i in avg.indices) {
-            avg[i] /= count
-        }
-
-        // Normalize to unit length
-        val norm = kotlin.math.sqrt(avg.map { it * it }.sum())
-        return avg.map { it / norm }.toFloatArray()
-    }
-
-    /**
-     * Calculate cosine similarity between two embeddings
-     */
-    private fun cosineSimilarity(a: FloatArray, b: FloatArray): Float {
-        var dotProduct = 0f
-        var normA = 0f
-        var normB = 0f
-
-        for (i in a.indices) {
-            dotProduct += a[i] * b[i]
-            normA += a[i] * a[i]
-            normB += b[i] * b[i]
-        }
-
-        return dotProduct / (kotlin.math.sqrt(normA) * kotlin.math.sqrt(normB))
-    }
-
-    fun cleanup() {
-        faceNetModel.close()
-    }
-}

app/src/main/java/com/placeholder/sherpai2/domain/usecase/Populatefacedetectioncacheusecase.kt

@@ -1,221 +0,0 @@
-package com.placeholder.sherpai2.domain.usecase
-
-import android.content.Context
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.tasks.await
-import kotlinx.coroutines.withContext
-import java.util.concurrent.atomic.AtomicInteger
-import javax.inject.Inject
-import javax.inject.Singleton
-
-/**
- * PopulateFaceDetectionCache - HYPER-PARALLEL face scanning
- *
- * STRATEGY: Use ACCURATE mode BUT with MASSIVE parallelization
- * - 50 concurrent detections (not 10!)
- * - Semaphore limits to prevent OOM
- * - Atomic counters for thread-safe progress
- * - Smaller images (768px) for speed without quality loss
- *
- * RESULT: ~2000-3000 images/minute on modern phones
- */
-@Singleton
-class PopulateFaceDetectionCacheUseCase @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val imageDao: ImageDao
-) {
-
-    // Limit concurrent operations to prevent OOM
-    private val semaphore = Semaphore(50) // 50 concurrent detections!
-
-    /**
-     * HYPER-PARALLEL face detection with ACCURATE mode
-     */
-    suspend fun execute(
-        onProgress: (Int, Int, String?) -> Unit = { _, _, _ -> }
-    ): Int = withContext(Dispatchers.IO) {
-
-        // Create detector with ACCURATE mode but optimized settings
-        val detector = com.google.mlkit.vision.face.FaceDetection.getClient(
-            com.google.mlkit.vision.face.FaceDetectorOptions.Builder()
-                .setPerformanceMode(com.google.mlkit.vision.face.FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
-                .setLandmarkMode(com.google.mlkit.vision.face.FaceDetectorOptions.LANDMARK_MODE_NONE) // Don't need landmarks for cache
-                .setClassificationMode(com.google.mlkit.vision.face.FaceDetectorOptions.CLASSIFICATION_MODE_NONE) // Don't need classification
-                .setMinFaceSize(0.1f) // Detect smaller faces
-                .build()
-        )
-
-        try {
-            val imagesToScan = imageDao.getImagesNeedingFaceDetection()
-
-            if (imagesToScan.isEmpty()) {
-                return@withContext 0
-            }
-
-            val total = imagesToScan.size
-            val scanned = AtomicInteger(0)
-            val pendingUpdates = mutableListOf<CacheUpdate>()
-            val updatesMutex = kotlinx.coroutines.sync.Mutex()
-
-            // Process ALL images in parallel with semaphore control
-            coroutineScope {
-                val jobs = imagesToScan.map { image ->
-                    async(Dispatchers.Default) {
-                        semaphore.acquire()
-                        try {
-                            // Load bitmap with medium downsampling (768px = good balance)
-                            val bitmap = loadBitmapOptimized(android.net.Uri.parse(image.imageUri))
-
-                            if (bitmap == null) {
-                                return@async CacheUpdate(image.imageId, false, 0, image.imageUri)
-                            }
-
-                            // Detect faces
-                            val inputImage = com.google.mlkit.vision.common.InputImage.fromBitmap(bitmap, 0)
-                            val faces = detector.process(inputImage).await()
-                            bitmap.recycle()
-
-                            CacheUpdate(
-                                imageId = image.imageId,
-                                hasFaces = faces.isNotEmpty(),
-                                faceCount = faces.size,
-                                imageUri = image.imageUri
-                            )
-                        } catch (e: Exception) {
-                            CacheUpdate(image.imageId, false, 0, image.imageUri)
-                        } finally {
-                            semaphore.release()
-
-                            // Update progress
-                            val current = scanned.incrementAndGet()
-                            if (current % 50 == 0 || current == total) {
-                                onProgress(current, total, image.imageUri)
-                            }
-                        }
-                    }
-                }
-
-                // Wait for all to complete and collect results
-                jobs.awaitAll().forEach { update ->
-                    updatesMutex.withLock {
-                        pendingUpdates.add(update)
-
-                        // Batch write to DB every 100 updates
-                        if (pendingUpdates.size >= 100) {
-                            flushUpdates(pendingUpdates.toList())
-                            pendingUpdates.clear()
-                        }
-                    }
-                }
-
-                // Flush remaining
-                updatesMutex.withLock {
-                    if (pendingUpdates.isNotEmpty()) {
-                        flushUpdates(pendingUpdates)
-                    }
-                }
-            }
-
-            scanned.get()
-        } finally {
-            detector.close()
-        }
-    }
-
-    /**
-     * Optimized bitmap loading with configurable max dimension
-     */
-    private fun loadBitmapOptimized(uri: android.net.Uri, maxDim: Int = 768): android.graphics.Bitmap? {
-        return try {
-            // Get dimensions
-            val options = android.graphics.BitmapFactory.Options().apply {
-                inJustDecodeBounds = true
-            }
-            context.contentResolver.openInputStream(uri)?.use { stream ->
-                android.graphics.BitmapFactory.decodeStream(stream, null, options)
-            }
-
-            // Calculate sample size
-            var sampleSize = 1
-            while (options.outWidth / sampleSize > maxDim ||
-                options.outHeight / sampleSize > maxDim) {
-                sampleSize *= 2
-            }
-
-            // Load with sample size
-            val finalOptions = android.graphics.BitmapFactory.Options().apply {
-                inSampleSize = sampleSize
-                inPreferredConfig = android.graphics.Bitmap.Config.ARGB_8888 // Better quality
-            }
-
-            context.contentResolver.openInputStream(uri)?.use { stream ->
-                android.graphics.BitmapFactory.decodeStream(stream, null, finalOptions)
-            }
-        } catch (e: Exception) {
-            null
-        }
-    }
-
-    /**
-     * Batch DB update
-     */
-    private suspend fun flushUpdates(updates: List<CacheUpdate>) = withContext(Dispatchers.IO) {
-        updates.forEach { update ->
-            try {
-                imageDao.updateFaceDetectionCache(
-                    imageId = update.imageId,
-                    hasFaces = update.hasFaces,
-                    faceCount = update.faceCount
-                )
-            } catch (e: Exception) {
-                // Skip failed updates //todo
-            }
-        }
-    }
-
-    suspend fun getUncachedImageCount(): Int = withContext(Dispatchers.IO) {
-        imageDao.getImagesNeedingFaceDetectionCount()
-    }
-
-    suspend fun getCacheStats(): CacheStats = withContext(Dispatchers.IO) {
-        val stats = imageDao.getFaceCacheStats()
-        CacheStats(
-            totalImages = stats?.totalImages ?: 0,
-            imagesWithFaceCache = stats?.imagesWithFaceCache ?: 0,
-            imagesWithFaces = stats?.imagesWithFaces ?: 0,
-            imagesWithoutFaces = stats?.imagesWithoutFaces ?: 0,
-            needsScanning = stats?.needsScanning ?: 0
-        )
-    }
-}
-
-private data class CacheUpdate(
-    val imageId: String,
-    val hasFaces: Boolean,
-    val faceCount: Int,
-    val imageUri: String
-)
-
-data class CacheStats(
-    val totalImages: Int,
-    val imagesWithFaceCache: Int,
-    val imagesWithFaces: Int,
-    val imagesWithoutFaces: Int,
-    val needsScanning: Int
-) {
-    val cacheProgress: Float
-        get() = if (totalImages > 0) {
-            imagesWithFaceCache.toFloat() / totalImages.toFloat()
-        } else 0f
-
-    val isComplete: Boolean
-        get() = needsScanning == 0
-}

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

@@ -12,6 +12,7 @@ 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
@@ -24,8 +25,8 @@ import javax.inject.Inject
  * Features:
  * - Search within album
  * - Date filtering
+ * - Simple/Verbose toggle
  * - Album stats
- * - Export functionality
  */
 @HiltViewModel
 class AlbumViewModel @Inject constructor(
@@ -53,6 +54,10 @@ class AlbumViewModel @Inject constructor(
     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()
     }
@@ -88,7 +93,7 @@ class AlbumViewModel @Inject constructor(
         combine(
             _searchQuery,
             _dateRange
-        ) { query: String, dateRange: DateRange ->
+        ) { query, dateRange ->
             Pair(query, dateRange)
         }.collectLatest { (query, dateRange) ->
             val imageIds = imageTagDao.findImagesByTag(tag.tagId, 0.5f)
@@ -114,7 +119,7 @@ class AlbumViewModel @Inject constructor(
                 .distinctBy { it.id }
 
             _uiState.value = AlbumUiState.Success(
-                albumName = tag.value.replace("_", " ").replaceFirstChar { it.uppercase() },
+                albumName = tag.value.replace("_", " ").capitalize(),
                 albumType = "Tag",
                 photos = imagesWithFaces,
                 personCount = uniquePersons.size,
@@ -133,7 +138,7 @@ class AlbumViewModel @Inject constructor(
         combine(
             _searchQuery,
             _dateRange
-        ) { query: String, dateRange: DateRange ->
+        ) { query, dateRange ->
             Pair(query, dateRange)
         }.collectLatest { (query, dateRange) ->
             val images = faceRecognitionRepository.getImagesForPerson(albumId)
@@ -179,7 +184,7 @@ class AlbumViewModel @Inject constructor(
         combine(
             _searchQuery,
             _dateRange
-        ) { query: String, _: DateRange ->
+        ) { query, _ ->
             query
         }.collectLatest { query ->
             val images = imageDao.getImagesInRange(startTime, endTime)
@@ -219,6 +224,13 @@ class AlbumViewModel @Inject constructor(
         _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
@@ -299,6 +311,10 @@ class AlbumViewModel @Inject constructor(
             set(Calendar.MILLISECOND, 0)
         }.timeInMillis
     }
+
+    private fun String.capitalize(): String {
+        return this.replaceFirstChar { it.uppercase() }
+    }
 }
 
 sealed class AlbumUiState {

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

@@ -1,9 +1,10 @@
 package com.placeholder.sherpai2.ui.album
 
-import androidx.compose.foundation.clickable
+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.*
@@ -11,24 +12,25 @@ 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 coil.compose.AsyncImage
 import com.placeholder.sherpai2.ui.search.DateRange
+import com.placeholder.sherpai2.ui.search.DisplayMode
+import com.placeholder.sherpai2.ui.search.components.ImageGridItem
 
 /**
- * AlbumViewScreen - CLEAN VERSION with Export
+ * AlbumViewScreen - Beautiful album detail view
  *
- * REMOVED:
+ * Features:
- * - DisplayMode toggle
+ * - Album stats
- * - Verbose person tags
+ * - Search within album
- *
+ * - Date filtering
- * ADDED:
+ * - Simple/Verbose toggle
- * - Export menu (Folder, Zip, Collage)
+ * - Clean person display
- * - Clean simple layout
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -40,8 +42,7 @@ fun AlbumViewScreen(
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
     val searchQuery by viewModel.searchQuery.collectAsStateWithLifecycle()
     val dateRange by viewModel.dateRange.collectAsStateWithLifecycle()
-
+    val displayMode by viewModel.displayMode.collectAsStateWithLifecycle()
-    var showExportMenu by remember { mutableStateOf(false) }
 
     Scaffold(
         topBar = {
@@ -73,9 +74,15 @@ fun AlbumViewScreen(
                     }
                 },
                 actions = {
-                    // Export button
+                    IconButton(onClick = { viewModel.toggleDisplayMode() }) {
-                    IconButton(onClick = { showExportMenu = true }) {
+                        Icon(
-                        Icon(Icons.Default.FileDownload, "Export")
+                            imageVector = if (displayMode == DisplayMode.SIMPLE) {
+                                Icons.Default.ViewList
+                            } else {
+                                Icons.Default.ViewModule
+                            },
+                            contentDescription = "Toggle view"
+                        )
                     }
                 }
             )
@@ -121,6 +128,7 @@ fun AlbumViewScreen(
                     state = state,
                     searchQuery = searchQuery,
                     dateRange = dateRange,
+                    displayMode = displayMode,
                     onSearchChange = { viewModel.setSearchQuery(it) },
                     onDateRangeChange = { viewModel.setDateRange(it) },
                     onImageClick = onImageClick,
@@ -129,33 +137,6 @@ fun AlbumViewScreen(
             }
         }
     }
-
-    // Export menu dialog
-    if (showExportMenu) {
-        ExportDialog(
-            albumName = when (val state = uiState) {
-                is AlbumUiState.Success -> state.albumName
-                else -> "Album"
-            },
-            photoCount = when (val state = uiState) {
-                is AlbumUiState.Success -> state.photos.size
-                else -> 0
-            },
-            onDismiss = { showExportMenu = false },
-            onExportToFolder = {
-                // TODO: Implement folder export
-                showExportMenu = false
-            },
-            onExportToZip = {
-                // TODO: Implement zip export
-                showExportMenu = false
-            },
-            onExportToCollage = {
-                // TODO: Implement collage export
-                showExportMenu = false
-            }
-        )
-    }
 }
 
 @Composable
@@ -163,6 +144,7 @@ private fun AlbumContent(
     state: AlbumUiState.Success,
     searchQuery: String,
     dateRange: DateRange,
+    displayMode: DisplayMode,
     onSearchChange: (String) -> Unit,
     onDateRangeChange: (DateRange) -> Unit,
     onImageClick: (String) -> Unit,
@@ -225,8 +207,7 @@ private fun AlbumContent(
                 .padding(horizontal = 16.dp),
             horizontalArrangement = Arrangement.spacedBy(8.dp)
         ) {
-            items(DateRange.entries.size) { index ->
+            items(DateRange.entries) { range ->
-                val range = DateRange.entries[index]
                 val isActive = dateRange == range
                 FilterChip(
                     selected = isActive,
@@ -264,6 +245,7 @@ private fun AlbumContent(
                 ) { photo ->
                     PhotoCard(
                         photo = photo,
+                        displayMode = displayMode,
                         onImageClick = onImageClick
                     )
                 }
@@ -273,11 +255,7 @@ private fun AlbumContent(
 }
 
 @Composable
-private fun StatItem(
+private fun StatItem(icon: androidx.compose.ui.graphics.vector.ImageVector, label: String, value: String) {
-    icon: androidx.compose.ui.graphics.vector.ImageVector,
-    label: String,
-    value: String
-) {
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.spacedBy(4.dp)
@@ -301,180 +279,79 @@ private fun StatItem(
     }
 }
 
-/**
- * PhotoCard - CLEAN VERSION: Simple image + person names
- */
 @Composable
 private fun PhotoCard(
     photo: AlbumPhoto,
+    displayMode: DisplayMode,
     onImageClick: (String) -> Unit
 ) {
     Card(
-        modifier = Modifier
+        modifier = Modifier.fillMaxWidth(),
-            .fillMaxWidth()
-            .aspectRatio(1f)
-            .clickable { onImageClick(photo.image.imageUri) },
         shape = RoundedCornerShape(12.dp)
     ) {
-        Box {
+        Column {
-            // Image
+            ImageGridItem(
-            AsyncImage(
+                image = photo.image,
-                model = photo.image.imageUri,
+                onClick = { onImageClick(photo.image.imageUri) }
-                contentDescription = null,
-                modifier = Modifier.fillMaxSize(),
-                contentScale = androidx.compose.ui.layout.ContentScale.Crop
             )
 
-            // Person names overlay (if any)
             if (photo.persons.isNotEmpty()) {
+                when (displayMode) {
+                    DisplayMode.SIMPLE -> {
                         Surface(
-                    color = MaterialTheme.colorScheme.surface.copy(alpha = 0.9f),
+                            color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f),
-                    modifier = Modifier
+                            modifier = Modifier.fillMaxWidth()
-                        .align(Alignment.BottomCenter)
-                        .fillMaxWidth()
                         ) {
                             Text(
-                        text = photo.persons.take(2).joinToString(", ") { it.name },
+                                text = photo.persons.take(3).joinToString(", ") { it.name },
                                 style = MaterialTheme.typography.bodySmall,
                                 modifier = Modifier.padding(8.dp),
                                 maxLines = 1,
-                        overflow = TextOverflow.Ellipsis,
+                                overflow = TextOverflow.Ellipsis
-                        fontWeight = FontWeight.Medium
                             )
                         }
                     }
-        }
+                    DisplayMode.VERBOSE -> {
-    }
-}
-
-/**
- * Export Dialog
- */
-@Composable
-private fun ExportDialog(
-    albumName: String,
-    photoCount: Int,
-    onDismiss: () -> Unit,
-    onExportToFolder: () -> Unit,
-    onExportToZip: () -> Unit,
-    onExportToCollage: () -> Unit
-) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        icon = { Icon(Icons.Default.FileDownload, null) },
-        title = { Text("Export Album") },
-        text = {
-            Column(
-                modifier = Modifier.fillMaxWidth(),
-                verticalArrangement = Arrangement.spacedBy(12.dp)
-            ) {
-                Text(
-                    "$photoCount photos from \"$albumName\"",
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-
-                // Export to Folder
-                ExportOption(
-                    icon = Icons.Default.Folder,
-                    title = "Export to Folder",
-                    description = "Save all photos to a folder",
-                    onClick = onExportToFolder
-                )
-
-                // Export to Zip
-                ExportOption(
-                    icon = Icons.Default.FolderZip,
-                    title = "Export as ZIP",
-                    description = "Create a compressed archive",
-                    onClick = onExportToZip
-                )
-
-                // Export to Collage (placeholder)
-                ExportOption(
-                    icon = Icons.Default.GridView,
-                    title = "Create Collage",
-                    description = "Coming soon!",
-                    onClick = onExportToCollage,
-                    enabled = false
-                )
-            }
-        },
-        confirmButton = {
-            TextButton(onClick = onDismiss) {
-                Text("Cancel")
-            }
-        }
-    )
-}
-
-@Composable
-private fun ExportOption(
-    icon: androidx.compose.ui.graphics.vector.ImageVector,
-    title: String,
-    description: String,
-    onClick: () -> Unit,
-    enabled: Boolean = true
-) {
                         Surface(
-        modifier = Modifier
+                            color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f),
-            .fillMaxWidth()
+                            modifier = Modifier.fillMaxWidth()
-            .clickable(enabled = enabled, onClick = onClick),
-        shape = RoundedCornerShape(12.dp),
-        color = if (enabled) {
-            MaterialTheme.colorScheme.surfaceVariant
-        } else {
-            MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
-        }
                         ) {
+                            Column(
+                                modifier = Modifier.padding(8.dp),
+                                verticalArrangement = Arrangement.spacedBy(4.dp)
+                            ) {
+                                photo.persons.take(3).forEachIndexed { index, person ->
                                     Row(
-            modifier = Modifier.padding(16.dp),
+                                        horizontalArrangement = Arrangement.spacedBy(6.dp),
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
                                         verticalAlignment = Alignment.CenterVertically
                                     ) {
-            Surface(
-                shape = RoundedCornerShape(8.dp),
-                color = MaterialTheme.colorScheme.primary.copy(
-                    alpha = if (enabled) 1f else 0.5f
-                ),
-                modifier = Modifier.size(40.dp)
-            ) {
-                Box(contentAlignment = Alignment.Center) {
                                         Icon(
-                        icon,
+                                            Icons.Default.Face,
-                        contentDescription = null,
+                                            null,
-                        modifier = Modifier.size(24.dp),
+                                            Modifier.size(14.dp),
-                        tint = MaterialTheme.colorScheme.onPrimary
+                                            MaterialTheme.colorScheme.primary
-                    )
-                }
-            }
-
-            Column(modifier = Modifier.weight(1f)) {
-                Text(
-                    title,
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.SemiBold,
-                    color = if (enabled) {
-                        MaterialTheme.colorScheme.onSurface
-                    } else {
-                        MaterialTheme.colorScheme.onSurface.copy(alpha = 0.5f)
-                    }
                                         )
                                         Text(
-                    description,
+                                            text = person.name,
                                             style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant.copy(
+                                            modifier = Modifier.weight(1f),
-                        alpha = if (enabled) 1f else 0.5f
+                                            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
                                             )
                                         }
-
+                                    }
-            if (enabled) {
+                                }
-                Icon(
+                            }
-                    Icons.Default.ChevronRight,
+                        }
-                    contentDescription = null,
+                    }
-                    tint = MaterialTheme.colorScheme.onSurfaceVariant
+                }
-                )
             }
         }
     }

app/src/main/java/com/placeholder/sherpai2/ui/collections/Collectionsscreen.kt

@@ -1,389 +0,0 @@
-package com.placeholder.sherpai2.ui.collections
-
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.grid.*
-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.Color
-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 coil.compose.AsyncImage
-
-/**
- * CollectionsScreen - Main collections list
- *
- * Features:
- * - Grid of collection cards
- * - Create new collection button
- * - Filter by type (all, smart, static)
- * - Collection details on click
- */
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun CollectionsScreen(
-    onCollectionClick: (String) -> Unit,
-    onCreateClick: () -> Unit,
-    viewModel: CollectionsViewModel = hiltViewModel()
-) {
-    val collections by viewModel.collections.collectAsStateWithLifecycle()
-    val creationState by viewModel.creationState.collectAsStateWithLifecycle()
-
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = {
-                    Column {
-                        Text(
-                            "Collections",
-                            style = MaterialTheme.typography.titleLarge,
-                            fontWeight = FontWeight.Bold
-                        )
-                        Text(
-                            viewModel.getCollectionSummary(),
-                            style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
-                        )
-                    }
-                },
-                actions = {
-                    IconButton(onClick = { viewModel.refreshSmartCollections() }) {
-                        Icon(Icons.Default.Refresh, "Refresh smart collections")
-                    }
-                }
-            )
-        },
-        floatingActionButton = {
-            ExtendedFloatingActionButton(
-                onClick = onCreateClick,
-                icon = { Icon(Icons.Default.Add, null) },
-                text = { Text("New Collection") }
-            )
-        }
-    ) { paddingValues ->
-        if (collections.isEmpty()) {
-            EmptyState(
-                onCreateClick = onCreateClick,
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(paddingValues)
-            )
-        } else {
-            LazyVerticalGrid(
-                columns = GridCells.Adaptive(160.dp),
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(paddingValues),
-                contentPadding = PaddingValues(16.dp),
-                horizontalArrangement = Arrangement.spacedBy(12.dp),
-                verticalArrangement = Arrangement.spacedBy(12.dp)
-            ) {
-                items(
-                    items = collections,
-                    key = { it.collectionId }
-                ) { collection ->
-                    CollectionCard(
-                        collection = collection,
-                        onClick = { onCollectionClick(collection.collectionId) },
-                        onPinToggle = { viewModel.togglePinned(collection.collectionId) },
-                        onDelete = { viewModel.deleteCollection(collection.collectionId) }
-                    )
-                }
-            }
-        }
-    }
-
-    // Creation dialog (shown from SearchScreen or other places)
-    when (val state = creationState) {
-        is CreationState.SmartFromSearch -> {
-            CreateCollectionDialog(
-                title = "Smart Collection",
-                subtitle = "${state.photoCount} photos matching filters",
-                onConfirm = { name, description ->
-                    viewModel.createSmartCollection(name, description)
-                },
-                onDismiss = { viewModel.cancelCreation() }
-            )
-        }
-        is CreationState.StaticFromImages -> {
-            CreateCollectionDialog(
-                title = "Static Collection",
-                subtitle = "${state.photoCount} photos selected",
-                onConfirm = { name, description ->
-                    viewModel.createStaticCollection(name, description)
-                },
-                onDismiss = { viewModel.cancelCreation() }
-            )
-        }
-        CreationState.None -> { /* No dialog */ }
-    }
-}
-
-@Composable
-private fun CollectionCard(
-    collection: com.placeholder.sherpai2.data.local.entity.CollectionEntity,
-    onClick: () -> Unit,
-    onPinToggle: () -> Unit,
-    onDelete: () -> Unit
-) {
-    var showMenu by remember { mutableStateOf(false) }
-
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .aspectRatio(0.75f)
-            .clickable(onClick = onClick),
-        shape = RoundedCornerShape(16.dp)
-    ) {
-        Box(modifier = Modifier.fillMaxSize()) {
-            // Cover image or placeholder
-            if (collection.coverImageUri != null) {
-                AsyncImage(
-                    model = collection.coverImageUri,
-                    contentDescription = null,
-                    modifier = Modifier.fillMaxSize(),
-                    contentScale = androidx.compose.ui.layout.ContentScale.Crop
-                )
-            } else {
-                // Placeholder
-                Surface(
-                    modifier = Modifier.fillMaxSize(),
-                    color = MaterialTheme.colorScheme.surfaceVariant
-                ) {
-                    Icon(
-                        Icons.Default.Photo,
-                        contentDescription = null,
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(48.dp),
-                        tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.3f)
-                    )
-                }
-            }
-
-            // Gradient overlay for text
-            Surface(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .align(Alignment.BottomCenter),
-                color = Color.Black.copy(alpha = 0.6f)
-            ) {
-                Column(
-                    modifier = Modifier.padding(12.dp),
-                    verticalArrangement = Arrangement.spacedBy(4.dp)
-                ) {
-                    Row(
-                        modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.SpaceBetween,
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Text(
-                            collection.name,
-                            style = MaterialTheme.typography.titleMedium,
-                            fontWeight = FontWeight.Bold,
-                            color = Color.White,
-                            maxLines = 1,
-                            overflow = TextOverflow.Ellipsis,
-                            modifier = Modifier.weight(1f)
-                        )
-
-                        Box {
-                            IconButton(
-                                onClick = { showMenu = true },
-                                modifier = Modifier.size(24.dp)
-                            ) {
-                                Icon(
-                                    Icons.Default.MoreVert,
-                                    null,
-                                    tint = Color.White
-                                )
-                            }
-
-                            DropdownMenu(
-                                expanded = showMenu,
-                                onDismissRequest = { showMenu = false }
-                            ) {
-                                DropdownMenuItem(
-                                    text = { Text(if (collection.isPinned) "Unpin" else "Pin") },
-                                    onClick = {
-                                        onPinToggle()
-                                        showMenu = false
-                                    },
-                                    leadingIcon = {
-                                        Icon(
-                                            if (collection.isPinned) Icons.Default.PushPin else Icons.Default.PushPin,
-                                            null
-                                        )
-                                    }
-                                )
-                                DropdownMenuItem(
-                                    text = { Text("Delete") },
-                                    onClick = {
-                                        onDelete()
-                                        showMenu = false
-                                    },
-                                    leadingIcon = {
-                                        Icon(Icons.Default.Delete, null)
-                                    }
-                                )
-                            }
-                        }
-                    }
-
-                    Row(
-                        horizontalArrangement = Arrangement.spacedBy(8.dp),
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        // Type badge
-                        Surface(
-                            color = when (collection.type) {
-                                "SMART" -> Color(0xFF2196F3)
-                                "FAVORITE" -> Color(0xFFF44336)
-                                else -> Color(0xFF4CAF50)
-                            }.copy(alpha = 0.9f),
-                            shape = RoundedCornerShape(4.dp)
-                        ) {
-                            Text(
-                                when (collection.type) {
-                                    "SMART" -> "Smart"
-                                    "FAVORITE" -> "Fav"
-                                    else -> "Static"
-                                },
-                                modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
-                                style = MaterialTheme.typography.labelSmall,
-                                color = Color.White
-                            )
-                        }
-
-                        // Photo count
-                        Text(
-                            "${collection.photoCount} photos",
-                            style = MaterialTheme.typography.bodySmall,
-                            color = Color.White.copy(alpha = 0.9f)
-                        )
-                    }
-                }
-            }
-
-            // Pinned indicator
-            if (collection.isPinned) {
-                Icon(
-                    Icons.Default.PushPin,
-                    contentDescription = "Pinned",
-                    modifier = Modifier
-                        .align(Alignment.TopEnd)
-                        .padding(8.dp)
-                        .size(20.dp),
-                    tint = Color.White
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun EmptyState(
-    onCreateClick: () -> Unit,
-    modifier: Modifier = Modifier
-) {
-    Box(
-        modifier = modifier,
-        contentAlignment = Alignment.Center
-    ) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            Icon(
-                Icons.Default.Collections,
-                contentDescription = null,
-                modifier = Modifier.size(72.dp),
-                tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
-            )
-            Text(
-                "No Collections Yet",
-                style = MaterialTheme.typography.titleLarge,
-                fontWeight = FontWeight.Bold
-            )
-            Text(
-                "Create collections from searches or manually select photos",
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant
-            )
-            Button(onClick = onCreateClick) {
-                Icon(Icons.Default.Add, null, Modifier.size(18.dp))
-                Spacer(Modifier.width(8.dp))
-                Text("Create Collection")
-            }
-        }
-    }
-}
-
-@Composable
-private fun CreateCollectionDialog(
-    title: String,
-    subtitle: String,
-    onConfirm: (name: String, description: String?) -> Unit,
-    onDismiss: () -> Unit
-) {
-    var name by remember { mutableStateOf("") }
-    var description by remember { mutableStateOf("") }
-
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        icon = { Icon(Icons.Default.Collections, null) },
-        title = {
-            Column {
-                Text(title)
-                Text(
-                    subtitle,
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-        },
-        text = {
-            Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
-                OutlinedTextField(
-                    value = name,
-                    onValueChange = { name = it },
-                    label = { Text("Collection Name") },
-                    singleLine = true,
-                    modifier = Modifier.fillMaxWidth()
-                )
-                OutlinedTextField(
-                    value = description,
-                    onValueChange = { description = it },
-                    label = { Text("Description (optional)") },
-                    maxLines = 3,
-                    modifier = Modifier.fillMaxWidth()
-                )
-            }
-        },
-        confirmButton = {
-            Button(
-                onClick = {
-                    if (name.isNotBlank()) {
-                        onConfirm(name.trim(), description.trim().ifBlank { null })
-                    }
-                },
-                enabled = name.isNotBlank()
-            ) {
-                Text("Create")
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) {
-                Text("Cancel")
-            }
-        }
-    )
-}

app/src/main/java/com/placeholder/sherpai2/ui/collections/Collectionsviewmodel.kt

@@ -1,159 +0,0 @@
-package com.placeholder.sherpai2.ui.collections
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.data.local.entity.CollectionEntity
-import com.placeholder.sherpai2.data.repository.CollectionRepository
-import com.placeholder.sherpai2.ui.search.DateRange
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * CollectionsViewModel - Manages collections list and creation
- */
-@HiltViewModel
-class CollectionsViewModel @Inject constructor(
-    private val collectionRepository: CollectionRepository
-) : ViewModel() {
-
-    // All collections
-    val collections: StateFlow<List<CollectionEntity>> = collectionRepository
-        .getAllCollections()
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5000),
-            initialValue = emptyList()
-        )
-
-    // UI state for creation dialog
-    private val _creationState = MutableStateFlow<CreationState>(CreationState.None)
-    val creationState: StateFlow<CreationState> = _creationState.asStateFlow()
-
-    // ==========================================
-    // COLLECTION CREATION
-    // ==========================================
-
-    fun startSmartCollectionFromSearch(
-        includedPeople: Set<String>,
-        excludedPeople: Set<String>,
-        includedTags: Set<String>,
-        excludedTags: Set<String>,
-        dateRange: DateRange,
-        photoCount: Int
-    ) {
-        _creationState.value = CreationState.SmartFromSearch(
-            includedPeople = includedPeople,
-            excludedPeople = excludedPeople,
-            includedTags = includedTags,
-            excludedTags = excludedTags,
-            dateRange = dateRange,
-            photoCount = photoCount
-        )
-    }
-
-    fun startStaticCollectionFromImages(imageIds: List<String>) {
-        _creationState.value = CreationState.StaticFromImages(
-            imageIds = imageIds,
-            photoCount = imageIds.size
-        )
-    }
-
-    fun cancelCreation() {
-        _creationState.value = CreationState.None
-    }
-
-    fun createSmartCollection(name: String, description: String?) {
-        val state = _creationState.value as? CreationState.SmartFromSearch ?: return
-
-        viewModelScope.launch {
-            collectionRepository.createSmartCollection(
-                name = name,
-                description = description,
-                includedPeople = state.includedPeople,
-                excludedPeople = state.excludedPeople,
-                includedTags = state.includedTags,
-                excludedTags = state.excludedTags,
-                dateRange = state.dateRange
-            )
-
-            _creationState.value = CreationState.None
-        }
-    }
-
-    fun createStaticCollection(name: String, description: String?) {
-        val state = _creationState.value as? CreationState.StaticFromImages ?: return
-
-        viewModelScope.launch {
-            collectionRepository.createStaticCollection(
-                name = name,
-                description = description,
-                imageIds = state.imageIds
-            )
-
-            _creationState.value = CreationState.None
-        }
-    }
-
-    // ==========================================
-    // COLLECTION MANAGEMENT
-    // ==========================================
-
-    fun deleteCollection(collectionId: String) {
-        viewModelScope.launch {
-            collectionRepository.deleteCollection(collectionId)
-        }
-    }
-
-    fun togglePinned(collectionId: String) {
-        viewModelScope.launch {
-            collectionRepository.togglePinned(collectionId)
-        }
-    }
-
-    fun refreshSmartCollections() {
-        viewModelScope.launch {
-            collectionRepository.evaluateAllSmartCollections()
-        }
-    }
-
-    // ==========================================
-    // STATISTICS
-    // ==========================================
-
-    fun getCollectionSummary(): String {
-        val count = collections.value.size
-        val smartCount = collections.value.count { it.type == "SMART" }
-        val staticCount = collections.value.count { it.type == "STATIC" }
-
-        return when {
-            count == 0 -> "No collections yet"
-            smartCount > 0 && staticCount > 0 -> "$smartCount smart • $staticCount static"
-            smartCount > 0 -> "$smartCount smart collections"
-            staticCount > 0 -> "$staticCount static collections"
-            else -> "$count collections"
-        }
-    }
-}
-
-/**
- * Creation state for dialogs
- */
-sealed class CreationState {
-    object None : CreationState()
-
-    data class SmartFromSearch(
-        val includedPeople: Set<String>,
-        val excludedPeople: Set<String>,
-        val includedTags: Set<String>,
-        val excludedTags: Set<String>,
-        val dateRange: DateRange,
-        val photoCount: Int
-    ) : CreationState()
-
-    data class StaticFromImages(
-        val imageIds: List<String>,
-        val photoCount: Int
-    ) : CreationState()
-}

app/src/main/java/com/placeholder/sherpai2/ui/discover/Discoverpeoplescreen.kt

@@ -1,687 +0,0 @@
-package com.placeholder.sherpai2.ui.discover
-
-import android.graphics.BitmapFactory
-import android.net.Uri
-import androidx.compose.foundation.Image
-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.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.foundation.lazy.grid.items
-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.asImageBitmap
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.placeholder.sherpai2.domain.clustering.AgeEstimate
-import com.placeholder.sherpai2.domain.clustering.FaceCluster
-import java.text.SimpleDateFormat
-import java.util.*
-
-/**
- * DiscoverPeopleScreen - Beautiful auto-clustering UI
- *
- * FLOW:
- * 1. Hero CTA: "Discover People in Your Photos"
- * 2. Auto-clustering progress (2-5 min)
- * 3. Grid of discovered people
- * 4. Tap cluster → Name person + metadata
- * 5. Background deep scan starts
- */
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun DiscoverPeopleScreen(
-    viewModel: DiscoverPeopleViewModel = hiltViewModel()
-) {
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-
-    // NO SCAFFOLD - MainScreen already has TopAppBar
-    Box(modifier = Modifier.fillMaxSize()) {
-        when (val state = uiState) {
-            is DiscoverUiState.Idle -> IdleScreen(
-                onStartDiscovery = { viewModel.startDiscovery() }
-            )
-
-            is DiscoverUiState.Clustering -> ClusteringProgressScreen(
-                progress = state.progress,
-                total = state.total,
-                message = state.message
-            )
-
-            is DiscoverUiState.NamingReady -> ClusterGridScreen(
-                result = state.result,
-                onClusterClick = { cluster ->
-                    viewModel.selectCluster(cluster)
-                }
-            )
-
-            is DiscoverUiState.NamingCluster -> NamingDialog(
-                cluster = state.selectedCluster,
-                suggestedSiblings = state.suggestedSiblings,
-                onConfirm = { name, dob, isChild, siblings ->
-                    viewModel.confirmClusterName(
-                        cluster = state.selectedCluster,
-                        name = name,
-                        dateOfBirth = dob,
-                        isChild = isChild,
-                        selectedSiblings = siblings
-                    )
-                },
-                onDismiss = { viewModel.cancelNaming() }
-            )
-
-            is DiscoverUiState.NoPeopleFound -> EmptyStateScreen(
-                message = state.message
-            )
-
-            is DiscoverUiState.Error -> ErrorScreen(
-                message = state.message,
-                onRetry = { viewModel.startDiscovery() }
-            )
-        }
-    }
-}
-
-/**
- * Idle state - Hero CTA to start discovery
- */
-@Composable
-fun IdleScreen(
-    onStartDiscovery: () -> Unit
-) {
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(32.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center
-    ) {
-        Icon(
-            imageVector = Icons.Default.AutoAwesome,
-            contentDescription = null,
-            modifier = Modifier.size(120.dp),
-            tint = MaterialTheme.colorScheme.primary
-        )
-
-        Spacer(Modifier.height(24.dp))
-
-        Text(
-            text = "Discover People",
-            style = MaterialTheme.typography.headlineLarge,
-            fontWeight = FontWeight.Bold,
-            textAlign = TextAlign.Center
-        )
-
-        Spacer(Modifier.height(16.dp))
-
-        Text(
-            text = "Let AI automatically find and group faces in your photos. " +
-                    "You'll name them, and we'll tag all their photos.",
-            style = MaterialTheme.typography.bodyLarge,
-            textAlign = TextAlign.Center,
-            color = MaterialTheme.colorScheme.onSurfaceVariant
-        )
-
-        Spacer(Modifier.height(32.dp))
-
-        Button(
-            onClick = onStartDiscovery,
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(56.dp),
-            colors = ButtonDefaults.buttonColors(
-                containerColor = MaterialTheme.colorScheme.primary
-            )
-        ) {
-            Icon(
-                imageVector = Icons.Default.AutoAwesome,
-                contentDescription = null,
-                modifier = Modifier.size(24.dp)
-            )
-            Spacer(Modifier.width(8.dp))
-            Text(
-                text = "Start Discovery",
-                style = MaterialTheme.typography.titleMedium,
-                fontWeight = FontWeight.Bold
-            )
-        }
-
-        Spacer(Modifier.height(16.dp))
-
-        Card(
-            modifier = Modifier.fillMaxWidth(),
-            colors = CardDefaults.cardColors(
-                containerColor = MaterialTheme.colorScheme.surfaceVariant
-            )
-        ) {
-            Column(
-                modifier = Modifier.padding(16.dp),
-                verticalArrangement = Arrangement.spacedBy(8.dp)
-            ) {
-                InfoRow(Icons.Default.Speed, "Fast: Analyzes ~1000 photos in 2-5 minutes")
-                InfoRow(Icons.Default.Security, "Private: Everything stays on your device")
-                InfoRow(Icons.Default.AutoAwesome, "Smart: Groups faces automatically")
-            }
-        }
-    }
-}
-
-@Composable
-fun InfoRow(icon: androidx.compose.ui.graphics.vector.ImageVector, text: String) {
-    Row(
-        verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.spacedBy(12.dp)
-    ) {
-        Icon(
-            imageVector = icon,
-            contentDescription = null,
-            tint = MaterialTheme.colorScheme.primary,
-            modifier = Modifier.size(20.dp)
-        )
-        Text(
-            text = text,
-            style = MaterialTheme.typography.bodyMedium
-        )
-    }
-}
-
-/**
- * Clustering progress screen
- */
-@Composable
-fun ClusteringProgressScreen(
-    progress: Int,
-    total: Int,
-    message: String
-) {
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(32.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center
-    ) {
-        CircularProgressIndicator(
-            modifier = Modifier.size(80.dp),
-            strokeWidth = 6.dp
-        )
-
-        Spacer(Modifier.height(32.dp))
-
-        Text(
-            text = "Discovering People...",
-            style = MaterialTheme.typography.headlineSmall,
-            fontWeight = FontWeight.Bold
-        )
-
-        Spacer(Modifier.height(16.dp))
-
-        LinearProgressIndicator(
-            progress = { if (total > 0) progress.toFloat() / total.toFloat() else 0f },
-            modifier = Modifier.fillMaxWidth(),
-        )
-
-        Spacer(Modifier.height(8.dp))
-
-        Text(
-            text = message,
-            style = MaterialTheme.typography.bodyMedium,
-            color = MaterialTheme.colorScheme.onSurfaceVariant
-        )
-
-        Spacer(Modifier.height(24.dp))
-
-        Text(
-            text = "This will take 2-5 minutes. You can leave and come back later.",
-            style = MaterialTheme.typography.bodySmall,
-            textAlign = TextAlign.Center,
-            color = MaterialTheme.colorScheme.onSurfaceVariant
-        )
-    }
-}
-
-/**
- * Grid of discovered clusters
- */
-@Composable
-fun ClusterGridScreen(
-    result: com.placeholder.sherpai2.domain.clustering.ClusteringResult,
-    onClusterClick: (FaceCluster) -> Unit
-) {
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(16.dp)
-    ) {
-        Text(
-            text = "Found ${result.clusters.size} People",
-            style = MaterialTheme.typography.headlineSmall,
-            fontWeight = FontWeight.Bold
-        )
-
-        Spacer(Modifier.height(8.dp))
-
-        Text(
-            text = "Tap to name each person. We'll then tag all their photos.",
-            style = MaterialTheme.typography.bodyMedium,
-            color = MaterialTheme.colorScheme.onSurfaceVariant
-        )
-
-        Spacer(Modifier.height(16.dp))
-
-        LazyVerticalGrid(
-            columns = GridCells.Fixed(2),
-            horizontalArrangement = Arrangement.spacedBy(12.dp),
-            verticalArrangement = Arrangement.spacedBy(12.dp)
-        ) {
-            items(result.clusters) { cluster ->
-                ClusterCard(
-                    cluster = cluster,
-                    onClick = { onClusterClick(cluster) }
-                )
-            }
-        }
-    }
-}
-
-/**
- * Single cluster card
- */
-@Composable
-fun ClusterCard(
-    cluster: FaceCluster,
-    onClick: () -> Unit
-) {
-    val context = LocalContext.current
-
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .clickable(onClick = onClick),
-        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
-    ) {
-        Column {
-            // Face grid (2x3)
-            LazyVerticalGrid(
-                columns = GridCells.Fixed(3),
-                modifier = Modifier.height(180.dp),
-                userScrollEnabled = false
-            ) {
-                items(cluster.representativeFaces.take(6)) { face ->
-                    val bitmap = remember(face.imageUri) {
-                        try {
-                            context.contentResolver.openInputStream(Uri.parse(face.imageUri))?.use {
-                                BitmapFactory.decodeStream(it)
-                            }
-                        } catch (e: Exception) {
-                            null
-                        }
-                    }
-
-                    if (bitmap != null) {
-                        Image(
-                            bitmap = bitmap.asImageBitmap(),
-                            contentDescription = null,
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .aspectRatio(1f),
-                            contentScale = ContentScale.Crop
-                        )
-                    } else {
-                        Box(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .aspectRatio(1f)
-                                .background(MaterialTheme.colorScheme.surfaceVariant),
-                            contentAlignment = Alignment.Center
-                        ) {
-                            Icon(
-                                imageVector = Icons.Default.Person,
-                                contentDescription = null,
-                                tint = MaterialTheme.colorScheme.onSurfaceVariant
-                            )
-                        }
-                    }
-                }
-            }
-
-            // Info
-            Column(
-                modifier = Modifier.padding(12.dp)
-            ) {
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text(
-                        text = "${cluster.photoCount} photos",
-                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.Bold
-                    )
-
-                    if (cluster.estimatedAge == AgeEstimate.CHILD) {
-                        Surface(
-                            shape = RoundedCornerShape(12.dp),
-                            color = MaterialTheme.colorScheme.primaryContainer
-                        ) {
-                            Text(
-                                text = "Child",
-                                modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
-                                style = MaterialTheme.typography.labelSmall,
-                                color = MaterialTheme.colorScheme.onPrimaryContainer
-                            )
-                        }
-                    }
-                }
-
-                if (cluster.potentialSiblings.isNotEmpty()) {
-                    Spacer(Modifier.height(4.dp))
-                    Text(
-                        text = "Appears with ${cluster.potentialSiblings.size} other person(s)",
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-            }
-        }
-    }
-}
-
-/**
- * Naming dialog
- */
-@Composable
-fun NamingDialog(
-    cluster: FaceCluster,
-    suggestedSiblings: List<FaceCluster>,
-    onConfirm: (String, Long?, Boolean, List<Int>) -> Unit,
-    onDismiss: () -> Unit
-) {
-    var name by remember { mutableStateOf("") }
-    var isChild by remember { mutableStateOf(cluster.estimatedAge == AgeEstimate.CHILD) }
-    var dateOfBirth by remember { mutableStateOf<Long?>(null) }
-    var selectedSiblings by remember { mutableStateOf<Set<Int>>(emptySet()) }
-    var showDatePicker by remember { mutableStateOf(false) }
-    val context = LocalContext.current
-
-    // Date picker dialog
-    if (showDatePicker) {
-        val calendar = java.util.Calendar.getInstance()
-        if (dateOfBirth != null) {
-            calendar.timeInMillis = dateOfBirth!!
-        }
-
-        val datePickerDialog = android.app.DatePickerDialog(
-            context,
-            { _, year, month, dayOfMonth ->
-                val cal = java.util.Calendar.getInstance()
-                cal.set(year, month, dayOfMonth)
-                dateOfBirth = cal.timeInMillis
-                showDatePicker = false
-            },
-            calendar.get(java.util.Calendar.YEAR),
-            calendar.get(java.util.Calendar.MONTH),
-            calendar.get(java.util.Calendar.DAY_OF_MONTH)
-        )
-
-        datePickerDialog.setOnDismissListener {
-            showDatePicker = false
-        }
-
-        DisposableEffect(Unit) {
-            datePickerDialog.show()
-            onDispose {
-                datePickerDialog.dismiss()
-            }
-        }
-    }
-
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = {
-            Text("Name This Person")
-        },
-        text = {
-            Column(
-                verticalArrangement = Arrangement.spacedBy(16.dp)
-            ) {
-                // FACE PREVIEW - Show 6 representative faces
-                Text(
-                    text = "${cluster.photoCount} photos found",
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-
-                LazyVerticalGrid(
-                    columns = GridCells.Fixed(3),
-                    modifier = Modifier.height(180.dp),
-                    horizontalArrangement = Arrangement.spacedBy(4.dp),
-                    verticalArrangement = Arrangement.spacedBy(4.dp)
-                ) {
-                    items(cluster.representativeFaces.take(6)) { face ->
-                        val bitmap = remember(face.imageUri) {
-                            try {
-                                context.contentResolver.openInputStream(Uri.parse(face.imageUri))?.use {
-                                    BitmapFactory.decodeStream(it)
-                                }
-                            } catch (e: Exception) {
-                                null
-                            }
-                        }
-
-                        if (bitmap != null) {
-                            Image(
-                                bitmap = bitmap.asImageBitmap(),
-                                contentDescription = null,
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .aspectRatio(1f)
-                                    .clip(RoundedCornerShape(8.dp)),
-                                contentScale = ContentScale.Crop
-                            )
-                        } else {
-                            Box(
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .aspectRatio(1f)
-                                    .clip(RoundedCornerShape(8.dp))
-                                    .background(MaterialTheme.colorScheme.surfaceVariant),
-                                contentAlignment = Alignment.Center
-                            ) {
-                                Icon(
-                                    imageVector = Icons.Default.Person,
-                                    contentDescription = null,
-                                    tint = MaterialTheme.colorScheme.onSurfaceVariant
-                                )
-                            }
-                        }
-                    }
-                }
-
-                HorizontalDivider()
-
-                // Name input
-                OutlinedTextField(
-                    value = name,
-                    onValueChange = { name = it },
-                    label = { Text("Name") },
-                    singleLine = true,
-                    modifier = Modifier.fillMaxWidth()
-                )
-
-                // Is child toggle
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text("This person is a child")
-                    Switch(
-                        checked = isChild,
-                        onCheckedChange = { isChild = it }
-                    )
-                }
-
-                // Date of birth (if child)
-                if (isChild) {
-                    OutlinedButton(
-                        onClick = { showDatePicker = true },
-                        modifier = Modifier.fillMaxWidth()
-                    ) {
-                        Icon(Icons.Default.CalendarToday, null)
-                        Spacer(Modifier.width(8.dp))
-                        Text(
-                            if (dateOfBirth != null) {
-                                SimpleDateFormat("MMM dd, yyyy", Locale.getDefault())
-                                    .format(Date(dateOfBirth!!))
-                            } else {
-                                "Set Date of Birth"
-                            }
-                        )
-                    }
-                }
-
-                // Suggested siblings
-                if (suggestedSiblings.isNotEmpty()) {
-                    Text(
-                        "Appears with these people (select siblings):",
-                        style = MaterialTheme.typography.labelMedium
-                    )
-
-                    suggestedSiblings.forEach { sibling ->
-                        Row(
-                            modifier = Modifier.fillMaxWidth(),
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-                            Checkbox(
-                                checked = sibling.clusterId in selectedSiblings,
-                                onCheckedChange = { checked ->
-                                    selectedSiblings = if (checked) {
-                                        selectedSiblings + sibling.clusterId
-                                    } else {
-                                        selectedSiblings - sibling.clusterId
-                                    }
-                                }
-                            )
-                            Text("Person ${sibling.clusterId + 1} (${sibling.photoCount} photos)")
-                        }
-                    }
-                }
-            }
-        },
-        confirmButton = {
-            TextButton(
-                onClick = {
-                    onConfirm(
-                        name,
-                        dateOfBirth,
-                        isChild,
-                        selectedSiblings.toList()
-                    )
-                },
-                enabled = name.isNotBlank()
-            ) {
-                Text("Save & Train")
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) {
-                Text("Cancel")
-            }
-        }
-    )
-
-    // TODO: Add DatePickerDialog when showDatePicker is true
-}
-
-/**
- * Empty state screen
- */
-@Composable
-fun EmptyStateScreen(message: String) {
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(32.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center
-    ) {
-        Icon(
-            imageVector = Icons.Default.PersonOff,
-            contentDescription = null,
-            modifier = Modifier.size(80.dp),
-            tint = MaterialTheme.colorScheme.onSurfaceVariant
-        )
-
-        Spacer(Modifier.height(16.dp))
-
-        Text(
-            text = message,
-            style = MaterialTheme.typography.bodyLarge,
-            textAlign = TextAlign.Center
-        )
-    }
-}
-
-/**
- * Error screen
- */
-@Composable
-fun ErrorScreen(
-    message: String,
-    onRetry: () -> Unit
-) {
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(32.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center
-    ) {
-        Icon(
-            imageVector = Icons.Default.Error,
-            contentDescription = null,
-            modifier = Modifier.size(80.dp),
-            tint = MaterialTheme.colorScheme.error
-        )
-
-        Spacer(Modifier.height(16.dp))
-
-        Text(
-            text = "Oops!",
-            style = MaterialTheme.typography.headlineMedium,
-            fontWeight = FontWeight.Bold
-        )
-
-        Spacer(Modifier.height(8.dp))
-
-        Text(
-            text = message,
-            style = MaterialTheme.typography.bodyLarge,
-            textAlign = TextAlign.Center,
-            color = MaterialTheme.colorScheme.onSurfaceVariant
-        )
-
-        Spacer(Modifier.height(24.dp))
-
-        Button(onClick = onRetry) {
-            Text("Try Again")
-        }
-    }
-}

app/src/main/java/com/placeholder/sherpai2/ui/discover/Discoverpeopleviewmodel.kt

@@ -1,222 +0,0 @@
-package com.placeholder.sherpai2.ui.discover
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.domain.clustering.ClusteringResult
-import com.placeholder.sherpai2.domain.clustering.FaceCluster
-import com.placeholder.sherpai2.domain.clustering.FaceClusteringService
-import com.placeholder.sherpai2.domain.training.ClusterTrainingService
-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 javax.inject.Inject
-
-/**
- * DiscoverPeopleViewModel - Manages auto-clustering and naming flow
- *
- * PHASE 2: Now includes multi-centroid training from clusters
- *
- * STATE FLOW:
- * 1. Idle → User taps "Discover People"
- * 2. Clustering → Auto-analyzing faces (2-5 min)
- * 3. NamingReady → Shows clusters, user names them
- * 4. Training → Creating multi-centroid face model
- * 5. Complete → Ready to scan library
- */
-@HiltViewModel
-class DiscoverPeopleViewModel @Inject constructor(
-    private val clusteringService: FaceClusteringService,
-    private val trainingService: ClusterTrainingService
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow<DiscoverUiState>(DiscoverUiState.Idle)
-    val uiState: StateFlow<DiscoverUiState> = _uiState.asStateFlow()
-
-    // Track which clusters have been named
-    private val namedClusterIds = mutableSetOf<Int>()
-
-    /**
-     * Start auto-clustering process
-     */
-    fun startDiscovery() {
-        viewModelScope.launch {
-            try {
-                // Clear named clusters for new discovery
-                namedClusterIds.clear()
-
-                _uiState.value = DiscoverUiState.Clustering(0, 100, "Starting...")
-
-                val result = clusteringService.discoverPeople(
-                    onProgress = { current, total, message ->
-                        _uiState.value = DiscoverUiState.Clustering(current, total, message)
-                    }
-                )
-
-                // Check for errors
-                if (result.errorMessage != null) {
-                    _uiState.value = DiscoverUiState.Error(result.errorMessage)
-                    return@launch
-                }
-
-                if (result.clusters.isEmpty()) {
-                    _uiState.value = DiscoverUiState.NoPeopleFound(
-                        "No faces found in your library. Make sure face detection cache is populated."
-                    )
-                } else {
-                    _uiState.value = DiscoverUiState.NamingReady(result)
-                }
-
-            } catch (e: Exception) {
-                _uiState.value = DiscoverUiState.Error(
-                    e.message ?: "Failed to discover people"
-                )
-            }
-        }
-    }
-
-    /**
-     * User selected a cluster to name
-     */
-    fun selectCluster(cluster: FaceCluster) {
-        val currentState = _uiState.value
-        if (currentState is DiscoverUiState.NamingReady) {
-            _uiState.value = DiscoverUiState.NamingCluster(
-                result = currentState.result,
-                selectedCluster = cluster,
-                suggestedSiblings = currentState.result.clusters.filter {
-                    it.clusterId in cluster.potentialSiblings
-                }
-            )
-        }
-    }
-
-    /**
-     * User confirmed name and metadata for a cluster
-     *
-     * CREATES:
-     * 1. PersonEntity with all metadata (name, DOB, siblings)
-     * 2. Multi-centroid FaceModelEntity (temporal tracking for children)
-     * 3. Removes cluster from display
-     */
-    fun confirmClusterName(
-        cluster: FaceCluster,
-        name: String,
-        dateOfBirth: Long?,
-        isChild: Boolean,
-        selectedSiblings: List<Int>
-    ) {
-        viewModelScope.launch {
-            try {
-                val currentState = _uiState.value
-                if (currentState !is DiscoverUiState.NamingCluster) return@launch
-
-                // Train person from cluster
-                val personId = trainingService.trainFromCluster(
-                    cluster = cluster,
-                    name = name,
-                    dateOfBirth = dateOfBirth,
-                    isChild = isChild,
-                    siblingClusterIds = selectedSiblings,
-                    onProgress = { current, total, message ->
-                        _uiState.value = DiscoverUiState.Clustering(current, total, message)
-                    }
-                )
-
-                // Mark cluster as named
-                namedClusterIds.add(cluster.clusterId)
-
-                // Filter out named clusters
-                val remainingClusters = currentState.result.clusters
-                    .filter { it.clusterId !in namedClusterIds }
-
-                if (remainingClusters.isEmpty()) {
-                    // All clusters named! Show success
-                    _uiState.value = DiscoverUiState.NoPeopleFound(
-                        "All people have been named! 🎉\n\nGo to 'People' to see your trained models."
-                    )
-                } else {
-                    // Return to naming screen with remaining clusters
-                    _uiState.value = DiscoverUiState.NamingReady(
-                        result = currentState.result.copy(clusters = remainingClusters)
-                    )
-                }
-
-            } catch (e: Exception) {
-                _uiState.value = DiscoverUiState.Error(
-                    e.message ?: "Failed to create person: ${e.message}"
-                )
-            }
-        }
-    }
-
-    /**
-     * Cancel naming and go back to cluster list
-     */
-    fun cancelNaming() {
-        val currentState = _uiState.value
-        if (currentState is DiscoverUiState.NamingCluster) {
-            _uiState.value = DiscoverUiState.NamingReady(
-                result = currentState.result
-            )
-        }
-    }
-
-    /**
-     * Reset to idle state
-     */
-    fun reset() {
-        _uiState.value = DiscoverUiState.Idle
-    }
-}
-
-/**
- * UI States for Discover People flow
- */
-sealed class DiscoverUiState {
-
-    /**
-     * Initial state - user hasn't started discovery
-     */
-    object Idle : DiscoverUiState()
-
-    /**
-     * Auto-clustering in progress
-     */
-    data class Clustering(
-        val progress: Int,
-        val total: Int,
-        val message: String
-    ) : DiscoverUiState()
-
-    /**
-     * Clustering complete, ready for user to name people
-     */
-    data class NamingReady(
-        val result: ClusteringResult
-    ) : DiscoverUiState()
-
-    /**
-     * User is naming a specific cluster
-     */
-    data class NamingCluster(
-        val result: ClusteringResult,
-        val selectedCluster: FaceCluster,
-        val suggestedSiblings: List<FaceCluster>
-    ) : DiscoverUiState()
-
-    /**
-     * No people found in library
-     */
-    data class NoPeopleFound(
-        val message: String
-    ) : DiscoverUiState()
-
-    /**
-     * Error occurred
-     */
-    data class Error(
-        val message: String
-    ) : DiscoverUiState()
-}

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

@@ -23,28 +23,57 @@ import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 
 /**
- * CLEANED ExploreScreen - No gradient header banner
+ * ExploreScreen - REDESIGNED
- *
- * Removed:
- * - Gradient header box (lines 46-75) that created banner effect
- * - "Explore" title (MainScreen shows it)
  *
  * Features:
- * - Rectangular album cards (compact)
+ * - Rectangular album cards (more compact)
  * - Stories section (recent highlights)
  * - Clickable navigation to AlbumViewScreen
  * - Beautiful gradients and icons
- * - Mobile-friendly scrolling
  */
 @Composable
 fun ExploreScreen(
     onAlbumClick: (albumType: String, albumId: String) -> Unit,
-    viewModel: ExploreViewModel = hiltViewModel(),
+    viewModel: ExploreViewModel = hiltViewModel()
-    modifier: Modifier = Modifier
 ) {
     val uiState by viewModel.uiState.collectAsState()
 
-    Box(modifier = modifier.fillMaxSize()) {
+    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(
@@ -54,18 +83,12 @@ fun ExploreScreen(
                     CircularProgressIndicator()
                 }
             }
-
             is ExploreViewModel.ExploreUiState.Success -> {
-                if (state.smartAlbums.isEmpty()) {
-                    EmptyExploreView()
-                } else {
                 ExploreContent(
                     smartAlbums = state.smartAlbums,
                     onAlbumClick = onAlbumClick
                 )
             }
-            }
-
             is ExploreViewModel.ExploreUiState.Error -> {
                 Box(
                     modifier = Modifier.fillMaxSize(),
@@ -73,25 +96,17 @@ fun ExploreScreen(
                 ) {
                     Column(
                         horizontalAlignment = Alignment.CenterHorizontally,
-                        verticalArrangement = Arrangement.spacedBy(12.dp),
+                        verticalArrangement = Arrangement.spacedBy(8.dp)
-                        modifier = Modifier.padding(32.dp)
                     ) {
                         Icon(
                             Icons.Default.Error,
                             contentDescription = null,
-                            modifier = Modifier.size(64.dp),
+                            modifier = Modifier.size(48.dp),
                             tint = MaterialTheme.colorScheme.error
                         )
-                        Text(
-                            text = "Error Loading Albums",
-                            style = MaterialTheme.typography.titleLarge,
-                            fontWeight = FontWeight.Bold
-                        )
                         Text(
                             text = state.message,
-                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.error
-                            color = MaterialTheme.colorScheme.onSurfaceVariant,
-                            textAlign = androidx.compose.ui.text.style.TextAlign.Center
                         )
                     }
                 }
@@ -100,9 +115,6 @@ fun ExploreScreen(
     }
 }
 
-/**
- * Main content - scrollable album sections
- */
 @Composable
 private fun ExploreContent(
     smartAlbums: List<SmartAlbum>,
@@ -115,14 +127,11 @@ private fun ExploreContent(
     ) {
         // Stories Section (Recent Highlights)
         item {
-            val storyAlbums = smartAlbums.filter { it.imageCount > 0 }.take(10)
-            if (storyAlbums.isNotEmpty()) {
             StoriesSection(
-                    albums = storyAlbums,
+                albums = smartAlbums.filter { it.imageCount > 0 }.take(10),
                 onAlbumClick = onAlbumClick
             )
         }
-        }
 
         // Time-based Albums
         val timeAlbums = smartAlbums.filterIsInstance<SmartAlbum.TimeRange>()
@@ -216,7 +225,7 @@ private fun ExploreContent(
 }
 
 /**
- * Stories section - circular album previews
+ * Stories section - Instagram-style circular highlights
  */
 @Composable
 private fun StoriesSection(
@@ -285,8 +294,7 @@ private fun StoryCircle(
             style = MaterialTheme.typography.labelSmall,
             maxLines = 2,
             modifier = Modifier.width(80.dp),
-            fontWeight = FontWeight.Medium,
+            fontWeight = FontWeight.Medium
-            textAlign = androidx.compose.ui.text.style.TextAlign.Center
         )
 
         Text(
@@ -334,7 +342,7 @@ private fun AlbumSection(
 }
 
 /**
- * Rectangular album card - compact design
+ * Rectangular album card - more compact than square
  */
 @Composable
 private fun AlbumCard(
@@ -390,44 +398,6 @@ private fun AlbumCard(
     }
 }
 
-/**
- * Empty state
- */
-@Composable
-private fun EmptyExploreView() {
-    Box(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(32.dp),
-        contentAlignment = Alignment.Center
-    ) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            Icon(
-                Icons.Default.PhotoAlbum,
-                contentDescription = null,
-                modifier = Modifier.size(80.dp),
-                tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
-            )
-
-            Text(
-                "No Albums Yet",
-                style = MaterialTheme.typography.titleLarge,
-                fontWeight = FontWeight.Bold
-            )
-
-            Text(
-                "Add photos to your collection to see smart albums",
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = androidx.compose.ui.text.style.TextAlign.Center
-            )
-        }
-    }
-}
-
 /**
  * Get navigation parameters for album
  */

app/src/main/java/com/placeholder/sherpai2/ui/imagedetail/ImageDetailScreen.kt

@@ -1,323 +1,86 @@
 package com.placeholder.sherpai2.ui.imagedetail
 
-import androidx.compose.foundation.background
 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.Color
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.navigation.NavController
 import coil.compose.AsyncImage
-import com.placeholder.sherpai2.data.local.entity.TagEntity
 import com.placeholder.sherpai2.ui.imagedetail.viewmodel.ImageDetailViewModel
-import net.engawapg.lib.zoomable.rememberZoomState
+
-import net.engawapg.lib.zoomable.zoomable
+
-import java.net.URLEncoder
+
 
 /**
- * ImageDetailScreen - COMPLETE with navigation and tags
+ * ImageDetailScreen
  *
- * Features:
+ * Purpose:
- * - Full-screen zoomable image
+ *  - Add tags
- * - Previous/Next navigation buttons
+ *  - Remove tags
- * - Image counter (3/45)
+ *  - Validate write propagation
- * - Tags button (toggle show/hide)
- * - Shows all tags on photo
  */
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ImageDetailScreen(
     modifier: Modifier = Modifier,
     imageUri: String,
-    onBack: () -> Unit,
+    onBack: () -> Unit
-    navController: NavController? = null,
-    allImageUris: List<String> = emptyList(), // Pass from caller
-    viewModel: ImageDetailViewModel = hiltViewModel() // ✅ FIXED: Use hiltViewModel
 ) {
+    val viewModel: ImageDetailViewModel = androidx.lifecycle.viewmodel.compose.viewModel()
 
     LaunchedEffect(imageUri) {
         viewModel.loadImage(imageUri)
     }
 
     val tags by viewModel.tags.collectAsStateWithLifecycle()
-    var showTags by remember { mutableStateOf(false) }
 
-    // Navigation state
+    var newTag by remember { mutableStateOf("") }
-    val currentIndex = if (allImageUris.isNotEmpty()) allImageUris.indexOf(imageUri) else -1
-    val hasNavigation = allImageUris.isNotEmpty() && currentIndex >= 0
-    val canGoPrevious = hasNavigation && currentIndex > 0
-    val canGoNext = hasNavigation && currentIndex < allImageUris.size - 1
 
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = {
-                    if (hasNavigation) {
-                        Text(
-                            "${currentIndex + 1} / ${allImageUris.size}",
-                            style = MaterialTheme.typography.titleMedium
-                        )
-                    } else {
-                        Text("Photo")
-                    }
-                },
-                navigationIcon = {
-                    IconButton(onClick = onBack) {
-                        Icon(Icons.Default.ArrowBack, "Back")
-                    }
-                },
-                actions = {
-                    // Tags toggle button
-                    IconButton(onClick = { showTags = !showTags }) {
-                        Row(
-                            horizontalArrangement = Arrangement.spacedBy(4.dp),
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-                            if (tags.isNotEmpty()) {
-                                Badge(
-                                    containerColor = if (showTags)
-                                        MaterialTheme.colorScheme.primary
-                                    else
-                                        MaterialTheme.colorScheme.surfaceVariant
-                                ) {
-                                    Text(
-                                        tags.size.toString(),
-                                        color = if (showTags)
-                                            MaterialTheme.colorScheme.onPrimary
-                                        else
-                                            MaterialTheme.colorScheme.onSurfaceVariant
-                                    )
-                                }
-                            }
-                            Icon(
-                                if (showTags) Icons.Default.Label else Icons.Default.LocalOffer,
-                                "Show Tags",
-                                tint = if (showTags)
-                                    MaterialTheme.colorScheme.primary
-                                else
-                                    MaterialTheme.colorScheme.onSurfaceVariant
-                            )
-                        }
-                    }
-
-                    // Previous button (only show if has navigation)
-                    if (hasNavigation && navController != null) {
-                        IconButton(
-                            onClick = {
-                                if (canGoPrevious) {
-                                    val prevUri = allImageUris[currentIndex - 1]
-                                    val encoded = URLEncoder.encode(prevUri, "UTF-8")
-                                    navController.navigate("image_detail/$encoded") {
-                                        popUpTo("image_detail/${URLEncoder.encode(imageUri, "UTF-8")}") {
-                                            inclusive = true
-                                        }
-                                    }
-                                }
-                            },
-                            enabled = canGoPrevious
-                        ) {
-                            Icon(Icons.Default.KeyboardArrowLeft, "Previous")
-                        }
-
-                        // Next button (only show if has navigation)
-                        IconButton(
-                            onClick = {
-                                if (canGoNext) {
-                                    val nextUri = allImageUris[currentIndex + 1]
-                                    val encoded = URLEncoder.encode(nextUri, "UTF-8")
-                                    navController.navigate("image_detail/$encoded") {
-                                        popUpTo("image_detail/${URLEncoder.encode(imageUri, "UTF-8")}") {
-                                            inclusive = true
-                                        }
-                                    }
-                                }
-                            },
-                            enabled = canGoNext
-                        ) {
-                            Icon(Icons.Default.KeyboardArrowRight, "Next")
-                        }
-                    }
-                }
-            )
-        }
-    ) { paddingValues ->
     Column(
         modifier = modifier
             .fillMaxSize()
-                .padding(paddingValues)
+            .padding(12.dp)
     ) {
-            // Zoomable image
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .weight(1f)
-                    .background(Color.Black)
-            ) {
-                val zoomState = rememberZoomState()
 
         AsyncImage(
             model = imageUri,
-                    contentDescription = "Photo",
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .zoomable(zoomState),
-                    contentScale = ContentScale.Fit
-                )
-            }
-
-            // Tags panel (slides up when enabled)
-            if (showTags) {
-                Surface(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .heightIn(max = 300.dp),
-                    color = MaterialTheme.colorScheme.surfaceVariant,
-                    tonalElevation = 3.dp
-                ) {
-                    LazyColumn(
-                        contentPadding = PaddingValues(16.dp),
-                        verticalArrangement = Arrangement.spacedBy(8.dp)
-                    ) {
-                        item {
-                            Text(
-                                "Tags (${tags.size})",
-                                style = MaterialTheme.typography.titleMedium,
-                                fontWeight = FontWeight.Bold
-                            )
-                        }
-
-                        if (tags.isEmpty()) {
-                            item {
-                                Text(
-                                    "No tags yet",
-                                    style = MaterialTheme.typography.bodyMedium,
-                                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                                )
-                            }
-                        }
-
-                        items(tags, key = { it.tagId }) { tag ->
-                            TagCard(
-                                tag = tag,
-                                onRemove = { viewModel.removeTag(tag) }
-                            )
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun TagCard(
-    tag: TagEntity,
-    onRemove: () -> Unit
-) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(
-            containerColor = when (tag.type) {
-                "PERSON" -> MaterialTheme.colorScheme.primaryContainer
-                "SYSTEM" -> MaterialTheme.colorScheme.secondaryContainer
-                else -> MaterialTheme.colorScheme.tertiaryContainer
-            }
-        ),
-        shape = RoundedCornerShape(8.dp)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(12.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Column(modifier = Modifier.weight(1f)) {
-                Row(
-                    horizontalArrangement = Arrangement.spacedBy(8.dp),
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Icon(
-                        imageVector = when (tag.type) {
-                            "PERSON" -> Icons.Default.Face
-                            "SYSTEM" -> Icons.Default.AutoAwesome
-                            else -> Icons.Default.Label
-                        },
             contentDescription = null,
-                        modifier = Modifier.size(20.dp),
+            modifier = Modifier
-                        tint = when (tag.type) {
+                .fillMaxWidth()
-                            "PERSON" -> MaterialTheme.colorScheme.primary
+                .aspectRatio(1f)
-                            "SYSTEM" -> MaterialTheme.colorScheme.secondary
-                            else -> MaterialTheme.colorScheme.tertiary
-                        }
         )
-                    Text(
+
-                        text = tag.getDisplayValue(), // Uses TagEntity's built-in method
+        Spacer(modifier = Modifier.height(12.dp))
-                        style = MaterialTheme.typography.bodyLarge,
+
-                        fontWeight = FontWeight.SemiBold
+        OutlinedTextField(
+            value = newTag,
+            onValueChange = { newTag = it },
+            label = { Text("Add tag") },
+            modifier = Modifier.fillMaxWidth()
         )
+
+        Button(
+            onClick = {
+                viewModel.addTag(newTag)
+                newTag = ""
+            },
+            modifier = Modifier.padding(top = 8.dp)
+        ) {
+            Text("Add Tag")
         }
 
+        Spacer(modifier = Modifier.height(16.dp))
+
+        tags.forEach { tag ->
             Row(
-                    horizontalArrangement = Arrangement.spacedBy(4.dp),
+                horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
+                modifier = Modifier.fillMaxWidth()
             ) {
-                    Text(
+                Text(tag.value)
-                        text = tag.type.lowercase().replaceFirstChar { it.uppercase() },
+                TextButton(onClick = { viewModel.removeTag(tag) }) {
-                        style = MaterialTheme.typography.labelSmall,
+                    Text("Remove")
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                    Text(
-                        text = "•",
-                        style = MaterialTheme.typography.labelSmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                    Text(
-                        text = formatTimestamp(tag.createdAt),
-                        style = MaterialTheme.typography.labelSmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-            }
-
-            // Remove button (only for user-created tags)
-            if (tag.isUserTag()) {
-                IconButton(
-                    onClick = onRemove,
-                    colors = IconButtonDefaults.iconButtonColors(
-                        contentColor = MaterialTheme.colorScheme.error
-                    )
-                ) {
-                    Icon(Icons.Default.Delete, "Remove tag")
                 }
             }
         }
     }
 }
-
-/**
- * Format timestamp to relative time
- */
-private fun formatTimestamp(timestamp: Long): String {
-    val now = System.currentTimeMillis()
-    val diff = now - timestamp
-
-    return when {
-        diff < 60_000 -> "Just now"
-        diff < 3600_000 -> "${diff / 60_000}m ago"
-        diff < 86400_000 -> "${diff / 3600_000}h ago"
-        diff < 604800_000 -> "${diff / 86400_000}d ago"
-        else -> "${diff / 604800_000}w ago"
-    }
-}

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

@@ -1,11 +1,11 @@
 package com.placeholder.sherpai2.ui.modelinventory
 
 import androidx.compose.foundation.background
-import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 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.*
@@ -13,408 +13,388 @@ 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.Color
+import androidx.compose.ui.graphics.vector.ImageVector
 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 java.text.SimpleDateFormat
+import java.util.*
 
 /**
- * PersonInventoryScreen - Simplified to match corrected ViewModel
+ * PersonInventoryScreen - Manage trained face models
  *
  * Features:
- * - List of all persons with face models
+ * - List all trained persons
- * - Scan button to find person in library
+ * - View stats
- * - Real-time scanning progress
+ * - DELETE models
- * - Delete person functionality
+ * - SCAN LIBRARY to find person in all photos (NEW!)
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun PersonInventoryScreen(
+    modifier: Modifier = Modifier,
     viewModel: PersonInventoryViewModel = hiltViewModel(),
-    onNavigateToPersonDetail: (String) -> Unit
+    onViewPersonPhotos: (String) -> Unit = {}
 ) {
-    val personsWithModels by viewModel.personsWithModels.collectAsStateWithLifecycle()
+    val uiState by viewModel.uiState.collectAsState()
-    val scanningState by viewModel.scanningState.collectAsStateWithLifecycle()
+    val scanningState by viewModel.scanningState.collectAsState()
+
+    var personToDelete by remember { mutableStateOf<PersonInventoryViewModel.PersonWithStats?>(null) }
+    var personToScan by remember { mutableStateOf<PersonInventoryViewModel.PersonWithStats?>(null) }
 
     Scaffold(
         topBar = {
             TopAppBar(
-                title = {
+                title = { Text("Trained People") },
-                    Column {
-                        Text("People")
-                        if (scanningState is ScanningState.Scanning) {
-                            Text(
-                                "⚡ Scanning...",
-                                style = MaterialTheme.typography.bodySmall,
-                                color = MaterialTheme.colorScheme.primary
-                            )
-                        }
-                    }
-                },
                 colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.surface
+                    containerColor = MaterialTheme.colorScheme.primaryContainer
-                )
+                ),
+                actions = {
+                    IconButton(onClick = { viewModel.loadPersons() }) {
+                        Icon(Icons.Default.Refresh, contentDescription = "Refresh")
+                    }
+                }
             )
         }
-    ) { padding ->
+    ) { paddingValues ->
-        Column(Modifier.padding(padding)) {
+        Box(
-            // Stats card
+            modifier = modifier
-            if (personsWithModels.isNotEmpty()) {
+                .fillMaxSize()
-                StatsCard(personsWithModels)
+                .padding(paddingValues)
+        ) {
+            when (val state = uiState) {
+                is PersonInventoryViewModel.InventoryUiState.Loading -> {
+                    LoadingView()
                 }
 
-            // Scanning progress (if active)
+                is PersonInventoryViewModel.InventoryUiState.Success -> {
-            when (val state = scanningState) {
+                    if (state.persons.isEmpty()) {
-                is ScanningState.Scanning -> {
+                        EmptyView()
-                    ScanningProgressCard(state)
-                }
-                is ScanningState.Complete -> {
-                    CompletionCard(state) {
-                        viewModel.resetScanningState()
-                    }
-                }
-                is ScanningState.Error -> {
-                    ErrorCard(state) {
-                        viewModel.resetScanningState()
-                    }
-                }
-                else -> {}
-            }
-
-            // Person list
-            if (personsWithModels.isEmpty()) {
-                EmptyState()
                     } else {
-                PersonList(
+                        PersonListView(
-                    persons = personsWithModels,
+                            persons = state.persons,
-                    onScan = { personId ->
+                            onDeleteClick = { personToDelete = it },
-                        viewModel.scanForPerson(personId)
+                            onScanClick = { personToScan = it },
-                    },
+                            onViewPhotos = { onViewPersonPhotos(it.person.id) },
-                    onView = { personId ->
+                            scanningState = scanningState
-                        onNavigateToPersonDetail(personId)
-                    },
-                    onDelete = { personId ->
-                        viewModel.deletePerson(personId)
-                    }
                         )
                     }
                 }
-    }
-}
-
-@Composable
-private fun StatsCard(persons: List<PersonWithModelInfo>) {
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(16.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.primaryContainer
-        )
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceEvenly
-        ) {
-            StatItem(
-                icon = Icons.Default.Person,
-                value = persons.size.toString(),
-                label = "People"
-            )
-            StatItem(
-                icon = Icons.Default.Collections,
-                value = persons.sumOf { it.taggedPhotoCount }.toString(),
-                label = "Tagged"
-            )
-        }
-    }
-}
-
-@Composable
-private fun StatItem(
-    icon: androidx.compose.ui.graphics.vector.ImageVector,
-    value: String,
-    label: String
-) {
-    Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
-        modifier = Modifier.padding(8.dp)
-    ) {
-        Icon(
-            icon,
-            contentDescription = null,
-            modifier = Modifier.size(32.dp),
-            tint = MaterialTheme.colorScheme.primary
-        )
-        Spacer(Modifier.height(4.dp))
-        Text(
-            value,
-            style = MaterialTheme.typography.headlineMedium,
-            fontWeight = FontWeight.Bold,
-            color = MaterialTheme.colorScheme.onPrimaryContainer
-        )
-        Text(
-            label,
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onPrimaryContainer
-        )
-    }
-}
-
-@Composable
-private fun ScanningProgressCard(state: ScanningState.Scanning) {
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 16.dp, vertical = 8.dp),
-        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,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Text(
-                    "Scanning for ${state.personName}",
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
-                )
-                Text(
-                    "${state.completed} / ${state.total}",
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.secondary
-                )
-            }
 
-            LinearProgressIndicator(
+                is PersonInventoryViewModel.InventoryUiState.Error -> {
-                progress = { if (state.total > 0) state.completed.toFloat() / state.total.toFloat() else 0f },
+                    ErrorView(
-                modifier = Modifier.fillMaxWidth(),
+                        message = state.message,
+                        onRetry = { viewModel.loadPersons() }
                     )
+                }
+            }
 
-            Row(
+            // Scanning overlay
-                modifier = Modifier.fillMaxWidth(),
+            if (scanningState is PersonInventoryViewModel.ScanningState.Scanning) {
-                horizontalArrangement = Arrangement.SpaceBetween
+                ScanningOverlay(scanningState as PersonInventoryViewModel.ScanningState.Scanning)
-            ) {
-                Text(
-                    "✓ ${state.facesFound} matches found",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.primary
-                )
-                Text(
-                    "%.1f img/sec".format(state.speed),
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSecondaryContainer
-                )
             }
         }
     }
-}
 
-@Composable
+    // Delete confirmation dialog
-private fun CompletionCard(state: ScanningState.Complete, onDismiss: () -> Unit) {
+    personToDelete?.let { personWithStats ->
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 16.dp, vertical = 8.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.primaryContainer
-        )
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Row(
-                horizontalArrangement = Arrangement.spacedBy(12.dp),
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Icon(
-                    Icons.Default.CheckCircle,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.size(32.dp)
-                )
-                Column {
-                    Text(
-                        "Scan Complete!",
-                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.Bold
-                    )
-                    Text(
-                        "Found ${state.personName} in ${state.facesFound} photos",
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onPrimaryContainer
-                    )
-                }
-            }
-            IconButton(onClick = onDismiss) {
-                Icon(Icons.Default.Close, "Dismiss")
-            }
-        }
-    }
-}
-
-@Composable
-private fun ErrorCard(state: ScanningState.Error, onDismiss: () -> Unit) {
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 16.dp, vertical = 8.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.errorContainer
-        )
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Row(
-                horizontalArrangement = Arrangement.spacedBy(12.dp),
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Icon(
-                    Icons.Default.Error,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.error,
-                    modifier = Modifier.size(32.dp)
-                )
-                Column {
-                    Text(
-                        "Scan Failed",
-                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.Bold
-                    )
-                    Text(
-                        state.message,
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onErrorContainer
-                    )
-                }
-            }
-            IconButton(onClick = onDismiss) {
-                Icon(Icons.Default.Close, "Dismiss")
-            }
-        }
-    }
-}
-
-@Composable
-private fun PersonList(
-    persons: List<PersonWithModelInfo>,
-    onScan: (String) -> Unit,
-    onView: (String) -> Unit,
-    onDelete: (String) -> Unit
-) {
-    LazyColumn(
-        contentPadding = PaddingValues(vertical = 8.dp)
-    ) {
-        items(
-            items = persons,
-            key = { it.person.id }
-        ) { person ->
-            PersonCard(
-                person = person,
-                onScan = { onScan(person.person.id) },
-                onView = { onView(person.person.id) },
-                onDelete = { onDelete(person.person.id) }
-            )
-        }
-    }
-}
-
-@Composable
-private fun PersonCard(
-    person: PersonWithModelInfo,
-    onScan: () -> Unit,
-    onView: () -> Unit,
-    onDelete: () -> Unit
-) {
-    var showDeleteDialog by remember { mutableStateOf(false) }
-
-    if (showDeleteDialog) {
         AlertDialog(
-            onDismissRequest = { showDeleteDialog = false },
+            onDismissRequest = { personToDelete = null },
-            title = { Text("Delete ${person.person.name}?") },
+            title = { Text("Delete ${personWithStats.person.name}?") },
-            text = { Text("This will remove the face model and all tagged photos. This cannot be undone.") },
+            text = {
+                Text(
+                    "This will delete the face model and all ${personWithStats.stats.taggedPhotoCount} " +
+                            "face tags. Your photos will NOT be deleted."
+                )
+            },
             confirmButton = {
                 TextButton(
                     onClick = {
-                        showDeleteDialog = false
+                        viewModel.deletePerson(
-                        onDelete()
+                            personWithStats.person.id,
-                    }
+                            personWithStats.stats.faceModelId
+                        )
+                        personToDelete = null
+                    },
+                    colors = ButtonDefaults.textButtonColors(
+                        contentColor = MaterialTheme.colorScheme.error
+                    )
                 ) {
-                    Text("Delete", color = MaterialTheme.colorScheme.error)
+                    Text("Delete")
                 }
             },
             dismissButton = {
-                TextButton(onClick = { showDeleteDialog = false }) {
+                TextButton(onClick = { personToDelete = null }) {
                     Text("Cancel")
                 }
             }
         )
     }
 
+    // Scan library confirmation dialog
+    personToScan?.let { personWithStats ->
+        AlertDialog(
+            onDismissRequest = { personToScan = null },
+            icon = { Icon(Icons.Default.Search, contentDescription = null) },
+            title = { Text("Scan Library for ${personWithStats.person.name}?") },
+            text = {
+                Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                    Text(
+                        "This will scan your entire photo library and automatically tag " +
+                                "all photos containing ${personWithStats.person.name}."
+                    )
+                    Text(
+                        "Currently tagged: ${personWithStats.stats.taggedPhotoCount} photos",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+            },
+            confirmButton = {
+                Button(
+                    onClick = {
+                        viewModel.scanLibraryForPerson(
+                            personWithStats.person.id,
+                            personWithStats.stats.faceModelId
+                        )
+                        personToScan = null
+                    }
+                ) {
+                    Icon(Icons.Default.Search, contentDescription = null)
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text("Start Scan")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { personToScan = null }) {
+                    Text("Cancel")
+                }
+            }
+        )
+    }
+}
+
+@Composable
+private fun LoadingView() {
+    Box(
+        modifier = Modifier.fillMaxSize(),
+        contentAlignment = Alignment.Center
+    ) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            CircularProgressIndicator()
+            Text(
+                text = "Loading trained models...",
+                style = MaterialTheme.typography.bodyMedium
+            )
+        }
+    }
+}
+
+@Composable
+private fun EmptyView() {
+    Box(
+        modifier = Modifier.fillMaxSize(),
+        contentAlignment = Alignment.Center
+    ) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+            modifier = Modifier.padding(32.dp)
+        ) {
+            Icon(
+                Icons.Default.Face,
+                contentDescription = null,
+                modifier = Modifier.size(64.dp),
+                tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.5f)
+            )
+            Text(
+                text = "No trained people yet",
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.Bold
+            )
+            Text(
+                text = "Train a person using 10+ photos to start recognizing faces",
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+    }
+}
+
+@Composable
+private fun ErrorView(
+    message: String,
+    onRetry: () -> Unit
+) {
+    Box(
+        modifier = Modifier.fillMaxSize(),
+        contentAlignment = Alignment.Center
+    ) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+            modifier = Modifier.padding(32.dp)
+        ) {
+            Icon(
+                Icons.Default.Warning,
+                contentDescription = null,
+                modifier = Modifier.size(64.dp),
+                tint = MaterialTheme.colorScheme.error
+            )
+            Text(
+                text = "Error",
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.Bold
+            )
+            Text(
+                text = message,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            Button(onClick = onRetry) {
+                Icon(Icons.Default.Refresh, contentDescription = null)
+                Spacer(modifier = Modifier.width(8.dp))
+                Text("Retry")
+            }
+        }
+    }
+}
+
+@Composable
+private fun PersonListView(
+    persons: List<PersonInventoryViewModel.PersonWithStats>,
+    onDeleteClick: (PersonInventoryViewModel.PersonWithStats) -> Unit,
+    onScanClick: (PersonInventoryViewModel.PersonWithStats) -> Unit,
+    onViewPhotos: (PersonInventoryViewModel.PersonWithStats) -> Unit,
+    scanningState: PersonInventoryViewModel.ScanningState
+) {
+    LazyColumn(
+        contentPadding = PaddingValues(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp)
+    ) {
+        // Summary card
+        item {
+            SummaryCard(totalPersons = persons.size)
+            Spacer(modifier = Modifier.height(8.dp))
+        }
+
+        // Person cards
+        items(persons) { personWithStats ->
+            PersonCard(
+                personWithStats = personWithStats,
+                onDeleteClick = { onDeleteClick(personWithStats) },
+                onScanClick = { onScanClick(personWithStats) },
+                onViewPhotos = { onViewPhotos(personWithStats) },
+                isScanning = scanningState is PersonInventoryViewModel.ScanningState.Scanning &&
+                        scanningState.personId == personWithStats.person.id
+            )
+        }
+    }
+}
+
+@Composable
+private fun SummaryCard(totalPersons: Int) {
     Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.primaryContainer
+        )
+    ) {
+        Row(
             modifier = Modifier
                 .fillMaxWidth()
-            .padding(horizontal = 16.dp, vertical = 8.dp)
+                .padding(16.dp),
-    ) {
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        Column(Modifier.padding(16.dp)) {
+            verticalAlignment = Alignment.CenterVertically
-            Row(
+        ) {
-                modifier = Modifier.fillMaxWidth(),
+            Icon(
+                Icons.Default.Face,
+                contentDescription = null,
+                modifier = Modifier.size(48.dp),
+                tint = MaterialTheme.colorScheme.primary
+            )
+            Column {
+                Text(
+                    text = "$totalPersons trained ${if (totalPersons == 1) "person" else "people"}",
+                    style = MaterialTheme.typography.titleLarge,
+                    fontWeight = FontWeight.Bold
+                )
+                Text(
+                    text = "Face recognition models ready",
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.7f)
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun PersonCard(
+    personWithStats: PersonInventoryViewModel.PersonWithStats,
+    onDeleteClick: () -> Unit,
+    onScanClick: () -> Unit,
+    onViewPhotos: () -> Unit,
+    isScanning: Boolean
+) {
+    val stats = personWithStats.stats
+
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            // Header: Name and actions
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(12.dp),
                     verticalAlignment = Alignment.CenterVertically
                 ) {
-                // Avatar
                     Box(
                         modifier = Modifier
                             .size(48.dp)
                             .clip(CircleShape)
-                        .background(MaterialTheme.colorScheme.primaryContainer),
+                            .background(MaterialTheme.colorScheme.primary),
                         contentAlignment = Alignment.Center
                     ) {
-                    Icon(
+                        Text(
-                        Icons.Default.Person,
+                            text = personWithStats.person.name.take(1).uppercase(),
-                        contentDescription = null,
+                            style = MaterialTheme.typography.titleLarge,
-                        tint = MaterialTheme.colorScheme.onPrimaryContainer
+                            fontWeight = FontWeight.Bold,
+                            color = MaterialTheme.colorScheme.onPrimary
                         )
                     }
 
-                Spacer(Modifier.width(16.dp))
+                    Column {
-
-                // Name and stats
-                Column(Modifier.weight(1f)) {
                         Text(
-                        person.person.name,
+                            text = personWithStats.person.name,
                             style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.Bold
+                            fontWeight = FontWeight.Bold,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
                         )
-
-                    val trainingCount = person.faceModel?.trainingImageCount ?: 0
                         Text(
-                        "${person.taggedPhotoCount} photos • $trainingCount trained",
+                            text = "ID: ${personWithStats.person.id.take(8)}",
                             style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.outline
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
                         )
                     }
+                }
 
-                // Delete button
+                IconButton(onClick = onDeleteClick) {
-                IconButton(onClick = { showDeleteDialog = true }) {
                     Icon(
                         Icons.Default.Delete,
                         contentDescription = "Delete",
@@ -423,39 +403,113 @@ private fun PersonCard(
                 }
             }
 
-            Spacer(Modifier.height(12.dp))
+            Spacer(modifier = Modifier.height(16.dp))
 
-            // Action buttons
+            // Stats grid
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceEvenly
+            ) {
+                StatItem(
+                    icon = Icons.Default.PhotoCamera,
+                    label = "Training",
+                    value = "${stats.trainingImageCount}"
+                )
+                StatItem(
+                    icon = Icons.Default.AccountBox,
+                    label = "Tagged",
+                    value = "${stats.taggedPhotoCount}"
+                )
+                StatItem(
+                    icon = Icons.Default.CheckCircle,
+                    label = "Confidence",
+                    value = "${(stats.averageConfidence * 100).toInt()}%",
+                    valueColor = if (stats.averageConfidence >= 0.8f) {
+                        MaterialTheme.colorScheme.primary
+                    } else if (stats.averageConfidence >= 0.6f) {
+                        MaterialTheme.colorScheme.tertiary
+                    } else {
+                        MaterialTheme.colorScheme.error
+                    }
+                )
+            }
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Last detected
+            stats.lastDetectedAt?.let { timestamp ->
+                Surface(
+                    modifier = Modifier.fillMaxWidth(),
+                    color = MaterialTheme.colorScheme.surfaceVariant,
+                    shape = RoundedCornerShape(8.dp)
+                ) {
+                    Row(
+                        modifier = Modifier.padding(12.dp),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Icon(
+                            Icons.Default.DateRange,
+                            contentDescription = null,
+                            modifier = Modifier.size(16.dp),
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                        Text(
+                            text = "Last detected: ${formatDate(timestamp)}",
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+            }
+
+            Spacer(modifier = Modifier.height(12.dp))
+
+            // Action buttons row
             Row(
                 modifier = Modifier.fillMaxWidth(),
                 horizontalArrangement = Arrangement.spacedBy(8.dp)
             ) {
-                // Scan button
+                // Scan Library button (PRIMARY ACTION)
                 Button(
-                    onClick = onScan,
+                    onClick = onScanClick,
-                    modifier = Modifier.weight(1f)
+                    modifier = Modifier.weight(1f),
+                    enabled = !isScanning,
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = MaterialTheme.colorScheme.primary
+                    )
                 ) {
+                    if (isScanning) {
+                        CircularProgressIndicator(
+                            modifier = Modifier.size(16.dp),
+                            color = MaterialTheme.colorScheme.onPrimary,
+                            strokeWidth = 2.dp
+                        )
+                    } else {
                         Icon(
                             Icons.Default.Search,
                             contentDescription = null,
                             modifier = Modifier.size(18.dp)
                         )
-                    Spacer(Modifier.width(4.dp))
+                    }
-                    Text("Scan Library", maxLines = 1)
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(if (isScanning) "Scanning..." else "Scan Library")
                 }
 
-                // View button
+                // View photos button
+                if (stats.taggedPhotoCount > 0) {
                     OutlinedButton(
-                    onClick = onView,
+                        onClick = onViewPhotos,
                         modifier = Modifier.weight(1f)
                     ) {
                         Icon(
-                        Icons.Default.Collections,
+                            Icons.Default.Photo,
                             contentDescription = null,
                             modifier = Modifier.size(18.dp)
                         )
-                    Spacer(Modifier.width(4.dp))
+                        Spacer(modifier = Modifier.width(8.dp))
-                    Text("View Photos", maxLines = 1)
+                        Text("View (${stats.taggedPhotoCount})")
+                    }
                 }
             }
         }
@@ -463,33 +517,98 @@ private fun PersonCard(
 }
 
 @Composable
-private fun EmptyState() {
+private fun StatItem(
+    icon: ImageVector,
+    label: String,
+    value: String,
+    valueColor: Color = MaterialTheme.colorScheme.primary
+) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        Icon(
+            icon,
+            contentDescription = null,
+            modifier = Modifier.size(24.dp),
+            tint = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+        Text(
+            text = value,
+            style = MaterialTheme.typography.titleMedium,
+            fontWeight = FontWeight.Bold,
+            color = valueColor
+        )
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+    }
+}
+
+/**
+ * Scanning overlay showing progress
+ */
+@Composable
+private fun ScanningOverlay(state: PersonInventoryViewModel.ScanningState.Scanning) {
     Box(
         modifier = Modifier
             .fillMaxSize()
-            .padding(32.dp),
+            .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.95f)),
         contentAlignment = Alignment.Center
+    ) {
+        Card(
+            modifier = Modifier
+                .fillMaxWidth(0.85f)
+                .padding(24.dp),
+            elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
         ) {
             Column(
+                modifier = Modifier.padding(24.dp),
                 horizontalAlignment = Alignment.CenterHorizontally,
                 verticalArrangement = Arrangement.spacedBy(16.dp)
             ) {
                 Icon(
-                Icons.Default.PersonAdd,
+                    Icons.Default.Search,
                     contentDescription = null,
-                modifier = Modifier.size(72.dp),
+                    modifier = Modifier.size(48.dp),
-                tint = MaterialTheme.colorScheme.outline
+                    tint = MaterialTheme.colorScheme.primary
                 )
+
                 Text(
-                "No People Yet",
+                    text = "Scanning Library",
                     style = MaterialTheme.typography.titleLarge,
                     fontWeight = FontWeight.Bold
                 )
+
                 Text(
-                "Train your first face model to get started",
+                    text = "Finding ${state.personName} in your photos...",
                     style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.outline
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+
+                LinearProgressIndicator(
+                    progress = { state.progress / state.total.toFloat() },
+                    modifier = Modifier.fillMaxWidth(),
+                )
+
+                Text(
+                    text = "${state.progress} / ${state.total} photos scanned",
+                    style = MaterialTheme.typography.bodySmall
+                )
+
+                Text(
+                    text = "${state.facesFound} faces detected",
+                    style = MaterialTheme.typography.labelMedium,
+                    color = MaterialTheme.colorScheme.primary
                 )
             }
         }
+    }
+}
+
+private fun formatDate(timestamp: Long): String {
+    val formatter = SimpleDateFormat("MMM d, yyyy h:mm a", Locale.getDefault())
+    return formatter.format(Date(timestamp))
 }

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

@@ -1,288 +1,349 @@
 package com.placeholder.sherpai2.ui.modelinventory
 
-import android.content.Context
+import android.app.Application
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.net.Uri
-import androidx.lifecycle.ViewModel
+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.FaceModelDao
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.dao.PersonDao
-import com.placeholder.sherpai2.data.local.dao.PhotoFaceTagDao
-import com.placeholder.sherpai2.data.local.entity.FaceModelEntity
-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.DetectedFace
-import com.placeholder.sherpai2.ml.FaceNetModel
+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 dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
-import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.sync.withPermit
 import kotlinx.coroutines.withContext
-import java.util.concurrent.atomic.AtomicInteger
+import kotlinx.coroutines.tasks.await
 import javax.inject.Inject
 
 /**
- * SPEED OPTIMIZED - Realistic 3-4x improvement
+ * PersonInventoryViewModel - Enhanced with smart threshold strategy
  *
- * KEY OPTIMIZATIONS:
+ * Toggle diagnostics in DebugFlags.kt:
- * ✅ Semaphore(12) - Balanced (was 5, can't do 50 = ANR)
+ * - ENABLE_FACE_RECOGNITION_LOGGING = true/false
- * ✅ Downsample to 512px for detection (4x fewer pixels)
+ * - USE_LIBERAL_THRESHOLDS = true/false
- * ✅ RGB_565 for detection (2x less memory)
- * ✅ Load only face regions for embedding (not full images)
- * ✅ Reuse single FaceNetModel (no init overhead)
- * ✅ No chunking (parallel processing)
- * ✅ Batch DB writes (100 at once)
- * ✅ Keep ACCURATE mode (need quality)
- * ✅ Leverage face cache (populated on startup)
- *
- * RESULT: 119 images in ~90sec (was ~5min)
  */
 @HiltViewModel
 class PersonInventoryViewModel @Inject constructor(
-    @ApplicationContext private val context: Context,
+    application: Application,
-    private val personDao: PersonDao,
+    private val faceRecognitionRepository: FaceRecognitionRepository,
-    private val faceModelDao: FaceModelDao,
+    private val imageRepository: ImageRepository
-    private val photoFaceTagDao: PhotoFaceTagDao,
+) : AndroidViewModel(application) {
-    private val imageDao: ImageDao
-) : ViewModel() {
 
-    private val _personsWithModels = MutableStateFlow<List<PersonWithModelInfo>>(emptyList())
+    private val _uiState = MutableStateFlow<InventoryUiState>(InventoryUiState.Loading)
-    val personsWithModels: StateFlow<List<PersonWithModelInfo>> = _personsWithModels.asStateFlow()
+    val uiState: StateFlow<InventoryUiState> = _uiState.asStateFlow()
 
     private val _scanningState = MutableStateFlow<ScanningState>(ScanningState.Idle)
     val scanningState: StateFlow<ScanningState> = _scanningState.asStateFlow()
 
-    private val semaphore = Semaphore(12)  // Sweet spot
+    private val faceDetector by lazy {
-    private val batchUpdateMutex = Mutex()
+        val options = FaceDetectorOptions.Builder()
-    private val BATCH_DB_SIZE = 100
+            .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+            .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
+            .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
+            .setMinFaceSize(0.10f)
+            .build()
+        FaceDetection.getClient(options)
+    }
+
+    data class PersonWithStats(
+        val person: PersonEntity,
+        val stats: PersonFaceStats
+    )
+
+    sealed class InventoryUiState {
+        object Loading : InventoryUiState()
+        data class Success(val persons: List<PersonWithStats>) : InventoryUiState()
+        data class Error(val message: String) : InventoryUiState()
+    }
+
+    sealed class ScanningState {
+        object Idle : ScanningState()
+        data class Scanning(
+            val personId: String,
+            val personName: String,
+            val progress: Int,
+            val total: Int,
+            val facesFound: Int,
+            val facesDetected: Int = 0
+        ) : ScanningState()
+        data class Complete(
+            val personName: String,
+            val facesFound: Int,
+            val imagesScanned: Int,
+            val totalFacesDetected: Int = 0
+        ) : ScanningState()
+    }
 
     init {
         loadPersons()
     }
 
-    private fun loadPersons() {
+    fun loadPersons() {
         viewModelScope.launch {
             try {
-                val persons = personDao.getAllPersons()
+                _uiState.value = InventoryUiState.Loading
-                val personsWithInfo = persons.map { person ->
-                    val faceModel = faceModelDao.getFaceModelByPersonId(person.id)
-                    val tagCount = faceModel?.let { model ->
-                        photoFaceTagDao.getImageIdsForFaceModel(model.id).size
-                    } ?: 0
-                    PersonWithModelInfo(person = person, faceModel = faceModel, taggedPhotoCount = tagCount)
-                }
-                _personsWithModels.value = personsWithInfo
-            } catch (e: Exception) {
-                _personsWithModels.value = emptyList()
-            }
-        }
-    }
 
-    fun deletePerson(personId: String) {
+                val persons = faceRecognitionRepository.getPersonsWithFaceModels()
-        viewModelScope.launch(Dispatchers.IO) {
+
-            try {
+                val personsWithStats = persons.mapNotNull { person ->
-                val faceModel = faceModelDao.getFaceModelByPersonId(personId)
+                    val stats = faceRecognitionRepository.getPersonFaceStats(person.id)
-                if (faceModel != null) {
+                    if (stats != null) {
-                    photoFaceTagDao.deleteTagsForFaceModel(faceModel.id)
+                        PersonWithStats(person, stats)
-                    faceModelDao.deleteFaceModelById(faceModel.id)
+                    } else {
-                }
+                        null
-                personDao.deleteById(personId)
-                loadPersons()
-            } catch (e: Exception) {}
-        }
                     }
+                }.sortedByDescending { it.stats.taggedPhotoCount }
 
-    fun scanForPerson(personId: String) {
+                _uiState.value = InventoryUiState.Success(personsWithStats)
-        viewModelScope.launch(Dispatchers.IO) {
-            try {
-                val person = personDao.getPersonById(personId) ?: return@launch
-                val faceModel = faceModelDao.getFaceModelByPersonId(personId) ?: return@launch
-
-                _scanningState.value = ScanningState.Scanning(person.name, 0, 0, 0, 0.0)
-
-                val imagesToScan = imageDao.getImagesWithFaces()
-                val alreadyTaggedImageIds = photoFaceTagDao.getImageIdsForFaceModel(faceModel.id).toSet()
-                val untaggedImages = imagesToScan.filter { it.imageId !in alreadyTaggedImageIds }
-                val totalToScan = untaggedImages.size
-
-                _scanningState.value = ScanningState.Scanning(person.name, 0, totalToScan, 0, 0.0)
-
-                if (totalToScan == 0) {
-                    _scanningState.value = ScanningState.Complete(person.name, 0)
-                    return@launch
-                }
-
-                val detectorOptions = FaceDetectorOptions.Builder()
-                    .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
-                    .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
-                    .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
-                    .setMinFaceSize(0.15f)
-                    .build()
-
-                val detector = FaceDetection.getClient(detectorOptions)
-                val modelEmbedding = faceModel.getEmbeddingArray()
-                val faceNetModel = FaceNetModel(context)
-                val trainingCount = faceModel.trainingImageCount
-                val baseThreshold = ThresholdStrategy.getLiberalThreshold(trainingCount)
-
-                val completed = AtomicInteger(0)
-                val facesFound = AtomicInteger(0)
-                val startTime = System.currentTimeMillis()
-                val batchMatches = mutableListOf<Triple<String, String, Float>>()
-
-                // ALL PARALLEL
-                withContext(Dispatchers.Default) {
-                    val jobs = untaggedImages.map { image ->
-                        async {
-                            semaphore.withPermit {
-                                processImage(image, detector, faceNetModel, modelEmbedding, trainingCount, baseThreshold, personId, faceModel.id, batchMatches, batchUpdateMutex, completed, facesFound, startTime, totalToScan, person.name)
-                            }
-                        }
-                    }
-                    jobs.awaitAll()
-                }
-
-                batchUpdateMutex.withLock {
-                    if (batchMatches.isNotEmpty()) {
-                        saveBatchMatches(batchMatches, faceModel.id)
-                        batchMatches.clear()
-                    }
-                }
-
-                detector.close()
-                faceNetModel.close()
-                _scanningState.value = ScanningState.Complete(person.name, facesFound.get())
-                loadPersons()
 
             } catch (e: Exception) {
-                _scanningState.value = ScanningState.Error(e.message ?: "Scanning failed")
+                _uiState.value = InventoryUiState.Error(
+                    e.message ?: "Failed to load persons"
+                )
             }
         }
     }
 
-    private suspend fun processImage(
+    fun deletePerson(personId: String, faceModelId: String) {
-        image: ImageEntity, detector: com.google.mlkit.vision.face.FaceDetector, faceNetModel: FaceNetModel,
+        viewModelScope.launch {
-        modelEmbedding: FloatArray, trainingCount: Int, baseThreshold: Float, personId: String, faceModelId: String,
-        batchMatches: MutableList<Triple<String, String, Float>>, batchUpdateMutex: Mutex,
-        completed: AtomicInteger, facesFound: AtomicInteger, startTime: Long, totalToScan: Int, personName: String
-    ) {
             try {
-            val uri = Uri.parse(image.imageUri)
+                faceRecognitionRepository.deleteFaceModel(faceModelId)
-
+                loadPersons()
-            // Get dimensions
+            } catch (e: Exception) {
-            val sizeOpts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+                _uiState.value = InventoryUiState.Error(
-            context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, sizeOpts) }
+                    "Failed to delete: ${e.message}"
-
+                )
-            // Load downsampled for detection (512px, RGB_565)
+            }
-            val detectionBitmap = loadDownsampled(uri, 512, Bitmap.Config.RGB_565) ?: return
+        }
-
-            val mlImage = InputImage.fromBitmap(detectionBitmap, 0)
-            val faces = com.google.android.gms.tasks.Tasks.await(detector.process(mlImage))
-
-            if (faces.isEmpty()) {
-                detectionBitmap.recycle()
-                return
     }
 
-            val scaleX = sizeOpts.outWidth.toFloat() / detectionBitmap.width
+    /**
-            val scaleY = sizeOpts.outHeight.toFloat() / detectionBitmap.height
+     * Scan library with SMART threshold selection
+     */
+    fun scanLibraryForPerson(personId: String, faceModelId: String) {
+        viewModelScope.launch {
+            try {
+                if (DebugFlags.ENABLE_FACE_RECOGNITION_LOGGING) {
+                    DiagnosticLogger.i("=== STARTING LIBRARY SCAN (ENHANCED) ===")
+                    DiagnosticLogger.i("PersonId: $personId")
+                    DiagnosticLogger.i("FaceModelId: $faceModelId")
+                }
 
-            val imageQuality = ThresholdStrategy.estimateImageQuality(sizeOpts.outWidth, sizeOpts.outHeight)
+                val currentState = _uiState.value
-            val detectionContext = ThresholdStrategy.estimateDetectionContext(faces.size)
+                val person = if (currentState is InventoryUiState.Success) {
-            val threshold = ThresholdStrategy.getOptimalThreshold(trainingCount, imageQuality, detectionContext).coerceAtMost(baseThreshold)
+                    currentState.persons.find { it.person.id == personId }?.person
+                } else null
 
-            for (face in faces) {
+                val personName = person?.name ?: "Unknown"
-                val scaledBounds = android.graphics.Rect(
+
-                    (face.boundingBox.left * scaleX).toInt(),
+                // Get face model to determine training count
-                    (face.boundingBox.top * scaleY).toInt(),
+                val faceModel = faceRecognitionRepository.getFaceModelById(faceModelId)
-                    (face.boundingBox.right * scaleX).toInt(),
+                val trainingCount = faceModel?.trainingImageCount ?: 15
-                    (face.boundingBox.bottom * scaleY).toInt()
+
+                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,
+                    facesDetected = 0
                 )
 
-                val faceBitmap = loadFaceRegion(uri, scaledBounds) ?: continue
+                var facesFound = 0
-                val faceEmbedding = faceNetModel.generateEmbedding(faceBitmap)
+                var totalFacesDetected = 0
-                val similarity = faceNetModel.calculateSimilarity(faceEmbedding, modelEmbedding)
-                faceBitmap.recycle()
 
-                if (similarity >= threshold) {
+                allImages.forEachIndexed { index, imageWithEverything ->
-                    batchUpdateMutex.withLock {
+                    val image = imageWithEverything.image
-                        batchMatches.add(Triple(personId, image.imageId, similarity))
+
-                        facesFound.incrementAndGet()
+                    DiagnosticLogger.d("--- Image ${index + 1}/$totalImages ---")
-                        if (batchMatches.size >= BATCH_DB_SIZE) {
+                    DiagnosticLogger.d("ImageId: ${image.imageId}")
-                            saveBatchMatches(batchMatches.toList(), faceModelId)
+
-                            batchMatches.clear()
+                    // Detect faces with ML Kit
+                    val detectedFaces = detectFacesInImage(image.imageUri)
+                    totalFacesDetected += detectedFaces.size
+
+                    DiagnosticLogger.d("Faces detected: ${detectedFaces.size}")
+
+                    if (detectedFaces.isNotEmpty()) {
+                        // 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 = scanThreshold
+                        )
+
+                        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
                     }
+
+                    _scanningState.value = ScanningState.Scanning(
+                        personId = personId,
+                        personName = personName,
+                        progress = index + 1,
+                        total = totalImages,
+                        facesFound = facesFound,
+                        facesDetected = totalFacesDetected
+                    )
                 }
-            detectionBitmap.recycle()
+
+                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,
+                    totalFacesDetected = totalFacesDetected
+                )
+
+                loadPersons()
+                delay(3000)
+                _scanningState.value = ScanningState.Idle
+
             } catch (e: Exception) {
-        } finally {
+                DiagnosticLogger.e("Scan failed", e)
-            val curr = completed.incrementAndGet()
+                _scanningState.value = ScanningState.Idle
-            val elapsed = (System.currentTimeMillis() - startTime) / 1000.0
+                _uiState.value = InventoryUiState.Error(
-            _scanningState.value = ScanningState.Scanning(personName, curr, totalToScan, facesFound.get(), if (elapsed > 0) curr / elapsed else 0.0)
+                    "Scan failed: ${e.message}"
+                )
+            }
         }
     }
 
-    private fun loadDownsampled(uri: Uri, maxDim: Int, format: Bitmap.Config): Bitmap? {
+    private suspend fun detectFacesInImage(imageUri: String): List<DetectedFace> = withContext(Dispatchers.Default) {
-        return try {
+        try {
-            val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+            val uri = Uri.parse(imageUri)
-            context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, opts) }
+            val inputStream = getApplication<Application>().contentResolver.openInputStream(uri)
+            val bitmap = BitmapFactory.decodeStream(inputStream)
+            inputStream?.close()
 
-            var sample = 1
+            if (bitmap == null) {
-            while (opts.outWidth / sample > maxDim || opts.outHeight / sample > maxDim) sample *= 2
+                DiagnosticLogger.w("Failed to load bitmap from: $imageUri")
-
+                return@withContext emptyList()
-            val finalOpts = BitmapFactory.Options().apply { inSampleSize = sample; inPreferredConfig = format }
-            context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, finalOpts) }
-        } catch (e: Exception) { null }
             }
 
-    private fun loadFaceRegion(uri: Uri, bounds: android.graphics.Rect): Bitmap? {
+            DiagnosticLogger.d("Bitmap: ${bitmap.width}x${bitmap.height}")
-        return try {
-            val full = context.contentResolver.openInputStream(uri)?.use {
-                BitmapFactory.decodeStream(it, null, BitmapFactory.Options().apply { inPreferredConfig = Bitmap.Config.ARGB_8888 })
-            } ?: return null
 
-            val safeLeft = bounds.left.coerceIn(0, full.width - 1)
+            val image = InputImage.fromBitmap(bitmap, 0)
-            val safeTop = bounds.top.coerceIn(0, full.height - 1)
+            val faces = faceDetector.process(image).await()
-            val safeWidth = bounds.width().coerceAtMost(full.width - safeLeft)
-            val safeHeight = bounds.height().coerceAtMost(full.height - safeTop)
 
-            val cropped = Bitmap.createBitmap(full, safeLeft, safeTop, safeWidth, safeHeight)
+            DiagnosticLogger.d("ML Kit found ${faces.size} faces")
-            full.recycle()
+
-            cropped
+            faces.mapNotNull { face ->
-        } catch (e: Exception) { null }
+                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) {
+                        Bitmap.createBitmap(bitmap, left, top, width, height)
+                    } else {
+                        null
+                    }
+                } catch (e: Exception) {
+                    DiagnosticLogger.e("Face crop failed", e)
+                    null
                 }
 
-    private suspend fun saveBatchMatches(matches: List<Triple<String, String, Float>>, faceModelId: String) {
+                if (croppedFace != null) {
-        val tags = matches.map { (_, imageId, confidence) ->
+                    DetectedFace(
-            PhotoFaceTagEntity.create(imageId, faceModelId, android.graphics.Rect(0, 0, 100, 100), confidence, FloatArray(128))
+                        croppedBitmap = croppedFace,
+                        boundingBox = boundingBox
+                    )
+                } else {
+                    null
                 }
-        photoFaceTagDao.insertTags(tags)
             }
 
-    fun resetScanningState() { _scanningState.value = ScanningState.Idle }
+        } catch (e: Exception) {
-    fun refresh() { loadPersons() }
+            DiagnosticLogger.e("Face detection failed: $imageUri", e)
+            emptyList()
+        }
+    }
+
+    /**
+     * 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)
+
+    override fun onCleared() {
+        super.onCleared()
+        faceDetector.close()
+    }
 }
-
-sealed class ScanningState {
-    object Idle : ScanningState()
-    data class Scanning(val personName: String, val completed: Int, val total: Int, val facesFound: Int, val speed: Double) : ScanningState()
-    data class Complete(val personName: String, val facesFound: Int) : ScanningState()
-    data class Error(val message: String) : ScanningState()
-}
-
-data class PersonWithModelInfo(val person: PersonEntity, val faceModel: FaceModelEntity?, val taggedPhotoCount: Int)

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

@@ -40,38 +40,31 @@ sealed class AppDestinations(
         description = "Browse smart albums"
     )
 
-    data object Collections : AppDestinations(
-        route = AppRoutes.COLLECTIONS,
-        icon = Icons.Default.Collections,
-        label = "Collections",
-        description = "Your photo collections"
-    )
-
     // ImageDetail is not in drawer (internal navigation only)
 
     // ==================
     // FACE RECOGNITION
     // ==================
 
-    data object Discover : AppDestinations(
-        route = AppRoutes.DISCOVER,
-        icon = Icons.Default.AutoAwesome,
-        label = "Discover",
-        description = "Find people in your photos"
-    )
-
     data object Inventory : AppDestinations(
         route = AppRoutes.INVENTORY,
         icon = Icons.Default.Face,
         label = "People",
-        description = "Manage recognized people"
+        description = "Trained face models"
     )
 
     data object Train : AppDestinations(
         route = AppRoutes.TRAIN,
         icon = Icons.Default.ModelTraining,
-        label = "Train Model",
+        label = "Train",
-        description = "Create a new person model"
+        description = "Train new person"
+    )
+
+    data object Models : AppDestinations(
+        route = AppRoutes.MODELS,
+        icon = Icons.Default.SmartToy,
+        label = "Models",
+        description = "AI model management"
     )
 
     // ==================
@@ -85,8 +78,8 @@ sealed class AppDestinations(
         description = "Manage photo tags"
     )
 
-    data object UTILITIES : AppDestinations(
+    data object Upload : AppDestinations(
-        route = AppRoutes.UTILITIES,
+        route = AppRoutes.UPLOAD,
         icon = Icons.Default.UploadFile,
         label = "Upload",
         description = "Add new photos"
@@ -111,21 +104,20 @@ sealed class AppDestinations(
 // Photo browsing section
 val photoDestinations = listOf(
     AppDestinations.Search,
-    AppDestinations.Explore,
+    AppDestinations.Explore
-    AppDestinations.Collections
 )
 
 // Face recognition section
 val faceRecognitionDestinations = listOf(
-    AppDestinations.Discover,  // ✨ NEW: Auto-cluster discovery
     AppDestinations.Inventory,
-    AppDestinations.Train
+    AppDestinations.Train,
+    AppDestinations.Models
 )
 
 // Organization section
 val organizationDestinations = listOf(
     AppDestinations.Tags,
-    AppDestinations.UTILITIES
+    AppDestinations.Upload
 )
 
 // Settings (separate, pinned to bottom)
@@ -144,12 +136,11 @@ fun getDestinationByRoute(route: String?): AppDestinations? {
     return when (route) {
         AppRoutes.SEARCH -> AppDestinations.Search
         AppRoutes.EXPLORE -> AppDestinations.Explore
-        AppRoutes.COLLECTIONS -> AppDestinations.Collections
-        AppRoutes.DISCOVER -> AppDestinations.Discover
         AppRoutes.INVENTORY -> AppDestinations.Inventory
         AppRoutes.TRAIN -> AppDestinations.Train
+        AppRoutes.MODELS -> AppDestinations.Models
         AppRoutes.TAGS -> AppDestinations.Tags
-        AppRoutes.UTILITIES -> AppDestinations.UTILITIES
+        AppRoutes.UPLOAD -> AppDestinations.Upload
         AppRoutes.SETTINGS -> AppDestinations.Settings
         else -> null
     }

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

@@ -7,38 +7,41 @@ import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavHostController
 import androidx.navigation.NavType
 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.album.AlbumViewModel
-import com.placeholder.sherpai2.ui.collections.CollectionsScreen
-import com.placeholder.sherpai2.ui.collections.CollectionsViewModel
-import com.placeholder.sherpai2.ui.discover.DiscoverPeopleScreen
 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.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.trainingprep.TrainingPhotoSelectorScreen
-import com.placeholder.sherpai2.ui.utilities.PhotoUtilitiesScreen
 import java.net.URLDecoder
 import java.net.URLEncoder
-import com.placeholder.sherpai2.ui.navigation.AppRoutes
 
 /**
- * AppNavHost - UPDATED with Discover People screen
+ * AppNavHost - Main navigation graph
+ * UPDATED: Added Explore and Tags screens
  *
- * NEW: Replaces placeholder "Models" screen with auto-clustering face discovery
+ * Complete flow:
+ * - Photo browsing (Search, Explore, Detail)
+ * - Face recognition (Inventory, Train)
+ * - Organization (Tags, Upload)
+ * - Settings
+ *
+ * Features:
+ * - URL encoding for safe navigation
+ * - Proper back stack management
+ * - State preservation
+ * - Beautiful placeholders
  */
 @Composable
 fun AppNavHost(
@@ -57,64 +60,37 @@ fun AppNavHost(
 
         /**
          * SEARCH SCREEN
+         * Main photo browser with face tag search
          */
         composable(AppRoutes.SEARCH) {
             val searchViewModel: SearchViewModel = hiltViewModel()
-            val collectionsViewModel: CollectionsViewModel = hiltViewModel()
-
             SearchScreen(
                 searchViewModel = searchViewModel,
                 onImageClick = { imageUri ->
-                    ImageListHolder.clear()
                     val encodedUri = URLEncoder.encode(imageUri, "UTF-8")
                     navController.navigate("${AppRoutes.IMAGE_DETAIL}/$encodedUri")
-                },
-                onAlbumClick = { tagValue ->
-                    navController.navigate("album/tag/$tagValue")
-                },
-                onSaveToCollection = { includedPeople, excludedPeople, includedTags, excludedTags, dateRange, photoCount ->
-                    collectionsViewModel.startSmartCollectionFromSearch(
-                        includedPeople = includedPeople,
-                        excludedPeople = excludedPeople,
-                        includedTags = includedTags,
-                        excludedTags = excludedTags,
-                        dateRange = dateRange,
-                        photoCount = photoCount
-                    )
                 }
             )
         }
 
         /**
          * EXPLORE SCREEN
+         * Browse smart albums (auto-generated from tags)
          */
         composable(AppRoutes.EXPLORE) {
             ExploreScreen(
                 onAlbumClick = { albumType, albumId ->
-                    navController.navigate("album/$albumType/$albumId")
+                    println("Album clicked: type=$albumType id=$albumId")
-                }
-            )
-        }
 
-        /**
+                    // Example future navigation
-         * COLLECTIONS SCREEN
+                    // navController.navigate("${AppRoutes.ALBUM}/$albumType/$albumId")
-         */
-        composable(AppRoutes.COLLECTIONS) {
-            val collectionsViewModel: CollectionsViewModel = hiltViewModel()
-
-            CollectionsScreen(
-                viewModel = collectionsViewModel,
-                onCollectionClick = { collectionId ->
-                    navController.navigate("album/collection/$collectionId")
-                },
-                onCreateClick = {
-                    navController.navigate(AppRoutes.SEARCH)
                 }
             )
         }
 
         /**
          * IMAGE DETAIL SCREEN
+         * Single photo view with metadata
          */
         composable(
             route = "${AppRoutes.IMAGE_DETAIL}/{imageUri}",
@@ -128,54 +104,9 @@ fun AppNavHost(
                 ?.let { URLDecoder.decode(it, "UTF-8") }
                 ?: error("imageUri missing from navigation")
 
-            val allImageUris = ImageListHolder.getImageList()
-
             ImageDetailScreen(
                 imageUri = imageUri,
-                onBack = {
+                onBack = { navController.popBackStack() }
-                    ImageListHolder.clear()
-                    navController.popBackStack()
-                },
-                navController = navController,
-                allImageUris = allImageUris
-            )
-        }
-
-        /**
-         * ALBUM VIEW SCREEN
-         */
-        composable(
-            route = "album/{albumType}/{albumId}",
-            arguments = listOf(
-                navArgument("albumType") {
-                    type = NavType.StringType
-                },
-                navArgument("albumId") {
-                    type = NavType.StringType
-                }
-            )
-        ) {
-            val albumViewModel: AlbumViewModel = hiltViewModel()
-            val uiState by albumViewModel.uiState.collectAsStateWithLifecycle()
-
-            AlbumViewScreen(
-                onBack = {
-                    navController.popBackStack()
-                },
-                onImageClick = { imageUri ->
-                    val allImageUris = if (uiState is com.placeholder.sherpai2.ui.album.AlbumUiState.Success) {
-                        (uiState as com.placeholder.sherpai2.ui.album.AlbumUiState.Success)
-                            .photos
-                            .map { it.image.imageUri }
-                    } else {
-                        emptyList()
-                    }
-
-                    ImageListHolder.setImageList(allImageUris)
-
-                    val encodedUri = URLEncoder.encode(imageUri, "UTF-8")
-                    navController.navigate("${AppRoutes.IMAGE_DETAIL}/$encodedUri")
-                }
             )
         }
 
@@ -183,42 +114,44 @@ fun AppNavHost(
         // FACE RECOGNITION SYSTEM
         // ==========================================
 
-        /**
-         * DISCOVER PEOPLE SCREEN - ✨ NEW!
-         *
-         * Auto-clustering face discovery with spoon-feed naming flow:
-         * 1. Auto-clusters all faces in library (2-5 min)
-         * 2. Shows beautiful grid of discovered people
-         * 3. User taps to name each person
-         * 4. Captures: name, DOB, sibling relationships
-         * 5. Triggers deep background scan with age tagging
-         *
-         * Replaces: Old "Models" placeholder screen
-         */
-        composable(AppRoutes.DISCOVER) {
-            DiscoverPeopleScreen()
-        }
-
         /**
          * PERSON INVENTORY SCREEN
+         * View all trained face models
+         *
+         * Features:
+         * - List all trained people
+         * - Show stats (training count, tagged photos, confidence)
+         * - Delete models
+         * - View photos containing each person
          */
         composable(AppRoutes.INVENTORY) {
             PersonInventoryScreen(
-                onNavigateToPersonDetail = { personId ->
+                onViewPersonPhotos = { personId ->
+                    // Navigate back to search
+                    // TODO: In future, add person filter to search screen
                     navController.navigate(AppRoutes.SEARCH)
                 }
             )
         }
 
         /**
-         * TRAINING FLOW - Manual training (still available)
+         * TRAINING FLOW
+         * Train new face recognition model
+         *
+         * Flow:
+         * 1. TrainingScreen (select images button)
+         * 2. ImageSelectorScreen (pick 15-50 photos)
+         * 3. ScanResultsScreen (validation + name input)
+         * 4. Training completes → navigate to Inventory
          */
         composable(AppRoutes.TRAIN) { entry ->
             val trainViewModel: TrainViewModel = hiltViewModel()
             val uiState by trainViewModel.uiState.collectAsState()
 
+            // Get images selected from ImageSelector
             val selectedUris = entry.savedStateHandle.get<List<Uri>>("selected_image_uris")
 
+            // Start scanning when new images are selected
             LaunchedEffect(selectedUris) {
                 if (selectedUris != null && uiState is ScanningState.Idle) {
                     trainViewModel.scanAndTagFaces(selectedUris)
@@ -228,17 +161,19 @@ fun AppNavHost(
 
             when (uiState) {
                 is ScanningState.Idle -> {
+                    // Show start screen with "Select Images" button
                     TrainingScreen(
                         onSelectImages = {
-                            // Navigate to custom photo selector (shows only faces!)
+                            navController.navigate(AppRoutes.IMAGE_SELECTOR)
-                            navController.navigate(AppRoutes.TRAINING_PHOTO_SELECTOR)
                         }
                     )
                 }
                 else -> {
+                    // Show validation results and training UI
                     ScanResultsScreen(
                         state = uiState,
                         onFinish = {
+                            // After training, go to inventory to see new person
                             navController.navigate(AppRoutes.INVENTORY) {
                                 popUpTo(AppRoutes.TRAIN) { inclusive = true }
                             }
@@ -249,15 +184,13 @@ fun AppNavHost(
         }
 
         /**
-         * TRAINING PHOTO SELECTOR - Custom gallery with face filtering
+         * IMAGE SELECTOR SCREEN
+         * Pick images for training (internal screen)
          */
-        composable(AppRoutes.TRAINING_PHOTO_SELECTOR) {
+        composable(AppRoutes.IMAGE_SELECTOR) {
-            TrainingPhotoSelectorScreen(
+            ImageSelectorScreen(
-                onBack = {
+                onImagesSelected = { uris ->
-                    navController.popBackStack()
+                    // Pass selected URIs back to Train screen
-                },
-                onPhotosSelected = { uris ->
-                    // Pass selected URIs back to training flow
                     navController.previousBackStackEntry
                         ?.savedStateHandle
                         ?.set("selected_image_uris", uris)
@@ -267,12 +200,13 @@ fun AppNavHost(
         }
 
         /**
-         * MODELS SCREEN - DEPRECATED, kept for backwards compat
+         * MODELS SCREEN
+         * AI model management (placeholder)
          */
         composable(AppRoutes.MODELS) {
             DummyScreen(
                 title = "AI Models",
-                subtitle = "Use 'Discover' instead"
+                subtitle = "Manage face recognition models"
             )
         }
 
@@ -282,16 +216,21 @@ fun AppNavHost(
 
         /**
          * TAGS SCREEN
+         * Manage photo tags with auto-tagging features
          */
         composable(AppRoutes.TAGS) {
             TagManagementScreen()
         }
 
         /**
-         * UTILITIES SCREEN
+         * UPLOAD SCREEN
+         * Import new photos (placeholder)
          */
-        composable(AppRoutes.UTILITIES) {
+        composable(AppRoutes.UPLOAD) {
-            PhotoUtilitiesScreen()
+            DummyScreen(
+                title = "Upload",
+                subtitle = "Add photos to your library"
+            )
         }
 
         // ==========================================
@@ -300,6 +239,7 @@ fun AppNavHost(
 
         /**
          * SETTINGS SCREEN
+         * App preferences (placeholder)
          */
         composable(AppRoutes.SETTINGS) {
             DummyScreen(

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

@@ -13,33 +13,24 @@ package com.placeholder.sherpai2.ui.navigation
 object AppRoutes {
     // Photo browsing
     const val SEARCH = "search"
-    const val EXPLORE = "explore"
+    const val EXPLORE = "explore"  // UPDATED: Changed from TOUR
     const val IMAGE_DETAIL = "IMAGE_DETAIL"
 
     // Face recognition
-    const val DISCOVER = "discover"  // ✨ NEW: Auto-cluster face discovery
     const val INVENTORY = "inv"
     const val TRAIN = "train"
-    const val MODELS = "models"  // DEPRECATED - kept for reference only
+    const val MODELS = "models"
 
     // Organization
     const val TAGS = "tags"
-    const val UTILITIES = "utilities"
+    const val UPLOAD = "upload"
 
     // Settings
     const val SETTINGS = "settings"
 
     // Internal training flow screens
-    const val IMAGE_SELECTOR = "Image Selection"  // DEPRECATED - kept for reference only
+    const val IMAGE_SELECTOR = "Image Selection"
-    const val TRAINING_PHOTO_SELECTOR = "training_photo_selector"  // Face-filtered gallery
     const val CROP_SCREEN = "CROP_SCREEN"
     const val TRAINING_SCREEN = "TRAINING_SCREEN"
     const val ScanResultsScreen = "First Scan Results"
-
-    // Album view
-    const val ALBUM_VIEW = "album/{albumType}/{albumId}"
-    fun albumRoute(albumType: String, albumId: String) = "album/$albumType/$albumId"
-
-    // Collections
-    const val COLLECTIONS = "collections"
 }

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

@@ -1,21 +0,0 @@
-package com.placeholder.sherpai2.ui.navigation
-
-/**
- * Simple holder for passing image lists between screens
- * Used for prev/next navigation in ImageDetailScreen
- */
-object ImageListHolder {
-    private var imageUris: List<String> = emptyList()
-
-    fun setImageList(uris: List<String>) {
-        imageUris = uris
-    }
-
-    fun getImageList(): List<String> {
-        return imageUris
-    }
-
-    fun clear() {
-        imageUris = emptyList()
-    }
-}

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

@@ -2,9 +2,7 @@ package com.placeholder.sherpai2.ui.presentation
 
 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.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
@@ -20,8 +18,8 @@ import androidx.compose.material.icons.filled.*
 import com.placeholder.sherpai2.ui.navigation.AppRoutes
 
 /**
- * SLIMMED DOWN AppDrawer - 280dp width, inline logo, cleaner sections
+ * Beautiful app drawer with sections, gradient header, and polish
- * UPDATED: Discover People feature with sparkle icon ✨
+ * UPDATED: Tour → Explore
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -30,17 +28,12 @@ fun AppDrawerContent(
     onDestinationClicked: (String) -> Unit
 ) {
     ModalDrawerSheet(
-        modifier = Modifier.width(280.dp), // SLIMMER (was 300dp)
+        modifier = Modifier.width(300.dp),
         drawerContainerColor = MaterialTheme.colorScheme.surface
     ) {
-        // SCROLLABLE Column - works on small phones!
+        Column(modifier = Modifier.fillMaxSize()) {
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .verticalScroll(rememberScrollState())
-        ) {
 
-            // ===== COMPACT HEADER - Icon + Text Inline =====
+            // ===== BEAUTIFUL GRADIENT HEADER =====
             Box(
                 modifier = Modifier
                     .fillMaxWidth()
@@ -52,64 +45,60 @@ fun AppDrawerContent(
                             )
                         )
                     )
-                    .padding(20.dp) // Reduced padding
+                    .padding(24.dp)
             ) {
-                Row(
+                Column(
-                    horizontalArrangement = Arrangement.spacedBy(12.dp),
+                    verticalArrangement = Arrangement.spacedBy(8.dp)
-                    verticalAlignment = Alignment.CenterVertically
                 ) {
-                    // App icon - smaller
+                    // App icon/logo area
                     Surface(
-                        modifier = Modifier.size(48.dp), // Smaller (was 56dp)
+                        modifier = Modifier.size(56.dp),
-                        shape = RoundedCornerShape(14.dp),
+                        shape = RoundedCornerShape(16.dp),
                         color = MaterialTheme.colorScheme.primary,
                         shadowElevation = 4.dp
                     ) {
                         Box(contentAlignment = Alignment.Center) {
                             Icon(
-                                Icons.Default.Terrain,  // Mountain theme!
+                                Icons.Default.Face,
                                 contentDescription = null,
-                                modifier = Modifier.size(28.dp),
+                                modifier = Modifier.size(32.dp),
                                 tint = MaterialTheme.colorScheme.onPrimary
                             )
                         }
                     }
 
-                    // Text next to icon
-                    Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
                     Text(
                         "SherpAI",
-                            style = MaterialTheme.typography.titleLarge, // Smaller (was headlineMedium)
+                        style = MaterialTheme.typography.headlineMedium,
                         fontWeight = FontWeight.Bold,
                         color = MaterialTheme.colorScheme.onSurface
                     )
 
                     Text(
-                            "Face Recognition",
+                        "Face Recognition System",
-                            style = MaterialTheme.typography.bodySmall, // Smaller
+                        style = MaterialTheme.typography.bodyMedium,
                         color = MaterialTheme.colorScheme.onSurfaceVariant
                     )
                 }
             }
-            }
 
-            Spacer(modifier = Modifier.height(4.dp)) // Reduced spacing
+            Spacer(modifier = Modifier.height(8.dp))
 
             // ===== NAVIGATION SECTIONS =====
             Column(
                 modifier = Modifier
                     .fillMaxWidth()
-                    .padding(horizontal = 8.dp), // Reduced padding
+                    .weight(1f)
-                verticalArrangement = Arrangement.spacedBy(2.dp) // Tighter spacing
+                    .padding(horizontal = 12.dp),
+                verticalArrangement = Arrangement.spacedBy(4.dp)
             ) {
 
                 // Photos Section
                 DrawerSection(title = "Photos")
 
                 val photoItems = listOf(
-                    DrawerItem(AppRoutes.SEARCH, "Search", Icons.Default.Search),
+                    DrawerItem(AppRoutes.SEARCH, "Search", Icons.Default.Search, "Find photos by tag or person"),
-                    DrawerItem(AppRoutes.EXPLORE, "Explore", Icons.Default.Explore),
+                    DrawerItem(AppRoutes.EXPLORE, "Explore", Icons.Default.Explore, "Browse smart albums")
-                    DrawerItem(AppRoutes.COLLECTIONS, "Collections", Icons.Default.Collections)
                 )
 
                 photoItems.forEach { item ->
@@ -120,15 +109,15 @@ fun AppDrawerContent(
                     )
                 }
 
-                Spacer(modifier = Modifier.height(4.dp))
+                Spacer(modifier = Modifier.height(8.dp))
 
                 // Face Recognition Section
                 DrawerSection(title = "Face Recognition")
 
                 val faceItems = listOf(
-                    DrawerItem(AppRoutes.DISCOVER, "Discover", Icons.Default.AutoAwesome), // ✨ UPDATED!
+                    DrawerItem(AppRoutes.INVENTORY, "People", Icons.Default.Face, "Trained face models"),
-                    DrawerItem(AppRoutes.INVENTORY, "People", Icons.Default.Face),
+                    DrawerItem(AppRoutes.TRAIN, "Train", Icons.Default.ModelTraining, "Train new person"),
-                    DrawerItem(AppRoutes.TRAIN, "Train Model", Icons.Default.ModelTraining)
+                    DrawerItem(AppRoutes.MODELS, "Models", Icons.Default.SmartToy, "AI model management")
                 )
 
                 faceItems.forEach { item ->
@@ -139,14 +128,14 @@ fun AppDrawerContent(
                     )
                 }
 
-                Spacer(modifier = Modifier.height(4.dp))
+                Spacer(modifier = Modifier.height(8.dp))
 
                 // Organization Section
                 DrawerSection(title = "Organization")
 
                 val orgItems = listOf(
-                    DrawerItem(AppRoutes.TAGS, "Tags", Icons.AutoMirrored.Filled.Label),
+                    DrawerItem(AppRoutes.TAGS, "Tags", Icons.AutoMirrored.Filled.Label, "Manage photo tags"),
-                    DrawerItem(AppRoutes.UTILITIES, "Utilities", Icons.Default.Build)
+                    DrawerItem(AppRoutes.UPLOAD, "Upload", Icons.Default.UploadFile, "Add new photos")
                 )
 
                 orgItems.forEach { item ->
@@ -157,11 +146,11 @@ fun AppDrawerContent(
                     )
                 }
 
-                Spacer(modifier = Modifier.height(8.dp))
+                Spacer(modifier = Modifier.weight(1f))
 
                 // Settings at bottom
                 HorizontalDivider(
-                    modifier = Modifier.padding(vertical = 6.dp),
+                    modifier = Modifier.padding(vertical = 8.dp),
                     color = MaterialTheme.colorScheme.outlineVariant
                 )
 
@@ -169,34 +158,35 @@ fun AppDrawerContent(
                     item = DrawerItem(
                         AppRoutes.SETTINGS,
                         "Settings",
-                        Icons.Default.Settings
+                        Icons.Default.Settings,
+                        "App preferences"
                     ),
                     selected = AppRoutes.SETTINGS == currentRoute,
                     onClick = { onDestinationClicked(AppRoutes.SETTINGS) }
                 )
 
-                Spacer(modifier = Modifier.height(16.dp))  // Bottom padding for scroll
+                Spacer(modifier = Modifier.height(8.dp))
             }
         }
     }
 }
 
 /**
- * Section header - more compact
+ * Section header in drawer
  */
 @Composable
 private fun DrawerSection(title: String) {
     Text(
         text = title,
-        style = MaterialTheme.typography.labelSmall, // Smaller
+        style = MaterialTheme.typography.labelMedium,
         fontWeight = FontWeight.Bold,
         color = MaterialTheme.colorScheme.primary,
-        modifier = Modifier.padding(horizontal = 16.dp, vertical = 6.dp) // Reduced padding
+        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
     )
 }
 
 /**
- * Navigation item - cleaner, no subtitle
+ * Individual navigation item with icon, label, and subtitle
  */
 @Composable
 private fun DrawerNavigationItem(
@@ -206,24 +196,33 @@ private fun DrawerNavigationItem(
 ) {
     NavigationDrawerItem(
         label = {
+            Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
                 Text(
                     text = item.label,
-                style = MaterialTheme.typography.bodyMedium, // Slightly smaller
+                    style = MaterialTheme.typography.bodyLarge,
                     fontWeight = if (selected) FontWeight.SemiBold else FontWeight.Normal
                 )
+                item.subtitle?.let {
+                    Text(
+                        text = it,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f)
+                    )
+                }
+            }
         },
         icon = {
             Icon(
                 item.icon,
                 contentDescription = item.label,
-                modifier = Modifier.size(22.dp) // Slightly smaller
+                modifier = Modifier.size(24.dp)
             )
         },
         selected = selected,
         onClick = onClick,
         modifier = Modifier
             .padding(NavigationDrawerItemDefaults.ItemPadding)
-            .clip(RoundedCornerShape(10.dp)), // Slightly smaller radius
+            .clip(RoundedCornerShape(12.dp)),
         colors = NavigationDrawerItemDefaults.colors(
             selectedContainerColor = MaterialTheme.colorScheme.primaryContainer,
             selectedIconColor = MaterialTheme.colorScheme.primary,
@@ -234,10 +233,11 @@ private fun DrawerNavigationItem(
 }
 
 /**
- * Simplified drawer item (no subtitle)
+ * Data class for drawer items
  */
 private data class DrawerItem(
     val route: String,
     val label: String,
-    val icon: androidx.compose.ui.graphics.vector.ImageVector
+    val icon: androidx.compose.ui.graphics.vector.ImageVector,
+    val subtitle: String? = null
 )

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

@@ -1,5 +1,10 @@
 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
@@ -15,7 +20,7 @@ import com.placeholder.sherpai2.ui.navigation.AppRoutes
 import kotlinx.coroutines.launch
 
 /**
- * Clean main screen - NO duplicate FABs, Collections support, Discover People
+ * Beautiful main screen with gradient header, dynamic actions, and polish
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -98,6 +103,15 @@ fun MainScreen() {
                                     )
                                 }
                             }
+                            AppRoutes.TAGS -> {
+                                IconButton(onClick = { /* TODO: Add tag */ }) {
+                                    Icon(
+                                        Icons.Default.Add,
+                                        contentDescription = "Add Tag",
+                                        tint = MaterialTheme.colorScheme.primary
+                                    )
+                                }
+                            }
                         }
                     },
                     colors = TopAppBarDefaults.topAppBarColors(
@@ -107,6 +121,49 @@ fun MainScreen() {
                         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.UPLOAD -> {
+                            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(
@@ -123,14 +180,12 @@ fun MainScreen() {
 private fun getScreenTitle(route: String): String {
     return when (route) {
         AppRoutes.SEARCH -> "Search"
-        AppRoutes.EXPLORE -> "Explore"
+        AppRoutes.EXPLORE -> "Explore"  // Will be renamed to EXPLORE
-        AppRoutes.COLLECTIONS -> "Collections"
-        AppRoutes.DISCOVER -> "Discover People" // ✨ NEW!
         AppRoutes.INVENTORY -> "People"
         AppRoutes.TRAIN -> "Train New Person"
-        AppRoutes.MODELS -> "AI Models" // Deprecated, but keep for backwards compat
+        AppRoutes.MODELS -> "AI Models"
         AppRoutes.TAGS -> "Tag Management"
-        AppRoutes.UTILITIES -> "Photo Util."
+        AppRoutes.UPLOAD -> "Upload Photos"
         AppRoutes.SETTINGS -> "Settings"
         else -> "SherpAI"
     }
@@ -143,12 +198,22 @@ private fun getScreenSubtitle(route: String): String? {
     return when (route) {
         AppRoutes.SEARCH -> "Find photos by tags, people, or date"
         AppRoutes.EXPLORE -> "Browse your collection"
-        AppRoutes.COLLECTIONS -> "Your photo collections"
-        AppRoutes.DISCOVER -> "Auto-find faces in your library" // ✨ NEW!
         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"
+        AppRoutes.UPLOAD -> "Add photos to your library"
         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.UPLOAD -> true
+        else -> false
+    }
+}

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

@@ -2,281 +2,234 @@ package com.placeholder.sherpai2.ui.search
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
-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.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.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import java.util.Calendar
 import javax.inject.Inject
 
-@OptIn(ExperimentalCoroutinesApi::class)
+/**
+ * SearchViewModel - COMPLETE REDESIGN
+ *
+ * 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 imageAggregateDao: ImageAggregateDao,
+    private val imageRepository: ImageRepository,
     private val faceRecognitionRepository: FaceRecognitionRepository,
-    private val personDao: PersonDao,
     private val tagDao: TagDao
 ) : ViewModel() {
 
+    // Search query with near-match support
     private val _searchQuery = MutableStateFlow("")
     val searchQuery: StateFlow<String> = _searchQuery.asStateFlow()
 
-    private val _includedPeople = MutableStateFlow<Set<String>>(emptySet())
+    // Active tag filters (quick chips)
-    val includedPeople: StateFlow<Set<String>> = _includedPeople.asStateFlow()
+    private val _activeTagFilters = MutableStateFlow<Set<String>>(emptySet())
-
+    val activeTagFilters: StateFlow<Set<String>> = _activeTagFilters.asStateFlow()
-    private val _excludedPeople = MutableStateFlow<Set<String>>(emptySet())
-    val excludedPeople: StateFlow<Set<String>> = _excludedPeople.asStateFlow()
-
-    private val _includedTags = MutableStateFlow<Set<String>>(emptySet())
-    val includedTags: StateFlow<Set<String>> = _includedTags.asStateFlow()
-
-    private val _excludedTags = MutableStateFlow<Set<String>>(emptySet())
-    val excludedTags: StateFlow<Set<String>> = _excludedTags.asStateFlow()
 
+    // Date range filter
     private val _dateRange = MutableStateFlow(DateRange.ALL_TIME)
     val dateRange: StateFlow<DateRange> = _dateRange.asStateFlow()
 
-    private val _faceFilter = MutableStateFlow(FaceFilter.ALL)
+    // Display mode (simple = names only, verbose = icons + percentages)
-    val faceFilter: StateFlow<FaceFilter> = _faceFilter.asStateFlow()
+    private val _displayMode = MutableStateFlow(DisplayMode.SIMPLE)
+    val displayMode: StateFlow<DisplayMode> = _displayMode.asStateFlow()
 
-    private val _availablePeople = MutableStateFlow<List<PersonEntity>>(emptyList())
+    // Available system tags for quick filters
-    val availablePeople: StateFlow<List<PersonEntity>> = _availablePeople.asStateFlow()
+    private val _systemTags = MutableStateFlow<List<TagEntity>>(emptyList())
-
+    val systemTags: StateFlow<List<TagEntity>> = _systemTags.asStateFlow()
-    private val _availableTags = MutableStateFlow<List<String>>(emptyList())
-    val availableTags: StateFlow<List<String>> = _availableTags.asStateFlow()
-
-    private val personCache = mutableMapOf<String, String>()
 
     init {
-        loadAvailableFilters()
+        loadSystemTags()
-        buildPersonCache()
-    }
-
-    private fun buildPersonCache() {
-        viewModelScope.launch {
-            val people = personDao.getAllPersons()
-            people.forEach { person ->
-                val stats = faceRecognitionRepository.getPersonFaceStats(person.id)
-                if (stats != null) {
-                    personCache[stats.faceModelId] = person.id
-                }
-            }
-        }
     }
 
+    /**
+     * Main search flow - combines query, tag filters, and date range
+     */
     fun searchImages(): Flow<List<ImageWithFaceTags>> {
         return combine(
             _searchQuery,
-            _includedPeople,
+            _activeTagFilters,
-            _excludedPeople,
+            _dateRange
-            _includedTags,
+        ) { query, tagFilters, dateRange ->
-            _excludedTags,
+            Triple(query, tagFilters, dateRange)
-            _dateRange,
+        }.flatMapLatest { (query, tagFilters, dateRange) ->
-            _faceFilter
+
-        ) { values: Array<*> ->
+            channelFlow {
-            @Suppress("UNCHECKED_CAST")
+                // Get matching tags FIRST (suspend call)
-            SearchCriteria(
+                val matchingTags = if (query.isNotBlank()) {
-                query = values[0] as String,
+                    findMatchingTags(query)
-                includedPeople = values[1] as Set<String>,
+                } else {
-                excludedPeople = values[2] as Set<String>,
+                    emptyList()
-                includedTags = values[3] as Set<String>,
+                }
-                excludedTags = values[4] as Set<String>,
+
-                dateRange = values[5] as DateRange,
+                // Get base images
-                faceFilter = values[6] as FaceFilter
+                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
                             )
-        }.flatMapLatest { criteria ->
-            imageAggregateDao.observeAllImagesWithEverything()
-                .map { imagesList ->
-                    imagesList.mapNotNull { imageWithEverything ->
-                        // Apply date filter
-                        if (!isInDateRange(imageWithEverything.image.capturedAt, criteria.dateRange)) {
-                            return@mapNotNull null
-                        }
-
-                        // Apply face filter - ONLY when cache is explicitly set
-                        when (criteria.faceFilter) {
-                            FaceFilter.HAS_FACES -> {
-                                // Only show images where hasFaces is EXPLICITLY true
-                                if (imageWithEverything.image.hasFaces != true) {
-                                    return@mapNotNull null
-                                }
-                            }
-                            FaceFilter.NO_FACES -> {
-                                // Only show images where hasFaces is EXPLICITLY false
-                                if (imageWithEverything.image.hasFaces != false) {
-                                    return@mapNotNull null
-                                }
-                            }
-                            FaceFilter.ALL -> {
-                                // Show all images (null, true, or false)
-                            }
-                        }
-
-                        val personIds = imageWithEverything.faceTags
-                            .mapNotNull { faceTag -> personCache[faceTag.faceModelId] }
-                            .toSet()
-
-                        val imageTags = imageWithEverything.tags
-                            .map { it.value }
-                            .toSet()
-
-                        val passesFilter = applyBooleanLogic(
-                            personIds = personIds,
-                            imageTags = imageTags,
-                            criteria = criteria
-                        )
-
-                        if (passesFilter) {
-                            val persons = personIds.mapNotNull { personId ->
-                                _availablePeople.value.find { it.id == personId }
-                            }
 
                             ImageWithFaceTags(
                                 image = imageWithEverything.image,
-                                faceTags = imageWithEverything.faceTags,
+                                faceTags = tagsWithPersons.map { it.first },
-                                persons = persons
+                                persons = tagsWithPersons.map { it.second }
                             )
-                        } else {
-                            null
                         }
-                    }.sortedByDescending { it.image.capturedAt }
+                        .sortedByDescending { it.image.capturedAt }
+
+                    send(filtered)
+                }
             }
         }
     }
 
-    private fun applyBooleanLogic(
+    /**
-        personIds: Set<String>,
+     * Near-match search: "low" matches "low_res", "gro" matches "group_photo"
-        imageTags: Set<String>,
+     */
-        criteria: SearchCriteria
+    private suspend fun findMatchingTags(query: String): List<TagEntity> {
-    ): Boolean {
+        val normalizedQuery = query.trim().lowercase()
-        val hasAllIncludedPeople = if (criteria.includedPeople.isNotEmpty()) {
-            criteria.includedPeople.all { it in personIds }
-        } else true
 
-        val hasNoExcludedPeople = if (criteria.excludedPeople.isNotEmpty()) {
+        // Get all system tags
-            criteria.excludedPeople.none { it in personIds }
+        val allTags = tagDao.getByType("SYSTEM")
-        } else true
 
-        val hasAllIncludedTags = if (criteria.includedTags.isNotEmpty()) {
+        // Find tags that contain the query or match it closely
-            criteria.includedTags.all { it in imageTags }
+        return allTags.filter { tag ->
-        } else true
+            val tagValue = tag.value.lowercase()
 
-        val hasNoExcludedTags = if (criteria.excludedTags.isNotEmpty()) {
+            // Exact match
-            criteria.excludedTags.none { it in imageTags }
+            tagValue == normalizedQuery ||
-        } else true
+                    // Contains match
-
+                    tagValue.contains(normalizedQuery) ||
-        val matchesTextSearch = if (criteria.query.isNotBlank()) {
+                    // Starts with match
-            val normalizedQuery = criteria.query.trim().lowercase()
+                    tagValue.startsWith(normalizedQuery) ||
-            imageTags.any { tag -> tag.lowercase().contains(normalizedQuery) }
+                    // Fuzzy match (remove underscores and compare)
-        } else true
+                    tagValue.replace("_", "").contains(normalizedQuery.replace("_", ""))
-
+        }.sortedBy { tag ->
-        return hasAllIncludedPeople && hasNoExcludedPeople &&
+            // Sort by relevance: exact > starts with > contains
-                hasAllIncludedTags && hasNoExcludedTags &&
+            when {
-                matchesTextSearch
+                tag.value.lowercase() == normalizedQuery -> 0
+                tag.value.lowercase().startsWith(normalizedQuery) -> 1
+                else -> 2
+            }
+        }
     }
 
-    private fun loadAvailableFilters() {
+    /**
+     * Load available system tags for quick filters
+     */
+    private fun loadSystemTags() {
         viewModelScope.launch {
-            val people = personDao.getAllPersons()
-            _availablePeople.value = people.sortedBy { it.name }
-
             val tags = tagDao.getByType("SYSTEM")
+
+            // Get usage counts for all tags
             val tagsWithUsage = tags.map { tag ->
                 tag to tagDao.getTagUsageCount(tag.tagId)
             }
-            _availableTags.value = tagsWithUsage
+
+            // Sort by most commonly used
+            val sortedTags = tagsWithUsage
                 .sortedByDescending { (_, usageCount) -> usageCount }
-                .take(30)
+                .take(12) // Show top 12 most used tags
-                .map { (tag, _) -> tag.value }
+                .map { (tag, _) -> tag }
+
+            _systemTags.value = sortedTags
         }
     }
 
-    fun includePerson(personId: String) {
+    /**
-        _includedPeople.value = _includedPeople.value + personId
+     * Update search query
-        _excludedPeople.value = _excludedPeople.value - personId
+     */
-    }
-
-    fun excludePerson(personId: String) {
-        _excludedPeople.value = _excludedPeople.value + personId
-        _includedPeople.value = _includedPeople.value - personId
-    }
-
-    fun removePersonFilter(personId: String) {
-        _includedPeople.value = _includedPeople.value - personId
-        _excludedPeople.value = _excludedPeople.value - personId
-    }
-
-    fun includeTag(tagValue: String) {
-        _includedTags.value = _includedTags.value + tagValue
-        _excludedTags.value = _excludedTags.value - tagValue
-    }
-
-    fun excludeTag(tagValue: String) {
-        _excludedTags.value = _excludedTags.value + tagValue
-        _includedTags.value = _includedTags.value - tagValue
-    }
-
-    fun removeTagFilter(tagValue: String) {
-        _includedTags.value = _includedTags.value - tagValue
-        _excludedTags.value = _excludedTags.value - tagValue
-    }
-
     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
     }
 
-    fun setFaceFilter(filter: FaceFilter) {
+    /**
-        _faceFilter.value = filter
+     * Toggle display mode (simple/verbose)
+     */
+    fun toggleDisplayMode() {
+        _displayMode.value = when (_displayMode.value) {
+            DisplayMode.SIMPLE -> DisplayMode.VERBOSE
+            DisplayMode.VERBOSE -> DisplayMode.SIMPLE
+        }
     }
 
-    fun clearAllFilters() {
+    /**
-        _searchQuery.value = ""
+     * Check if timestamp is in date range
-        _includedPeople.value = emptySet()
+     */
-        _excludedPeople.value = emptySet()
+    private fun isInDateRange(timestamp: Long, range: DateRange): Boolean {
-        _includedTags.value = emptySet()
+        return when (range) {
-        _excludedTags.value = emptySet()
-        _dateRange.value = DateRange.ALL_TIME
-        _faceFilter.value = FaceFilter.ALL
-    }
-
-    fun hasActiveFilters(): Boolean {
-        return _searchQuery.value.isNotBlank() ||
-                _includedPeople.value.isNotEmpty() ||
-                _excludedPeople.value.isNotEmpty() ||
-                _includedTags.value.isNotEmpty() ||
-                _excludedTags.value.isNotEmpty() ||
-                _dateRange.value != DateRange.ALL_TIME ||
-                _faceFilter.value != FaceFilter.ALL
-    }
-
-    fun getSearchSummary(): String {
-        val parts = mutableListOf<String>()
-        if (_includedPeople.value.isNotEmpty()) parts.add("WITH: ${_includedPeople.value.size} people")
-        if (_excludedPeople.value.isNotEmpty()) parts.add("WITHOUT: ${_excludedPeople.value.size} people")
-        if (_includedTags.value.isNotEmpty()) parts.add("HAS: ${_includedTags.value.size} tags")
-        if (_excludedTags.value.isNotEmpty()) parts.add("NOT: ${_excludedTags.value.size} tags")
-        if (_dateRange.value != DateRange.ALL_TIME) parts.add(_dateRange.value.displayName)
-        return parts.joinToString(" • ")
-    }
-
-    private fun isInDateRange(timestamp: Long, range: DateRange): Boolean = 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()
@@ -306,22 +259,18 @@ class SearchViewModel @Inject constructor(
     }
 }
 
-private data class SearchCriteria(
+/**
-    val query: String,
+ * Data class containing image with face recognition data
-    val includedPeople: Set<String>,
+ */
-    val excludedPeople: Set<String>,
-    val includedTags: Set<String>,
-    val excludedTags: Set<String>,
-    val dateRange: DateRange,
-    val faceFilter: FaceFilter
-)
-
 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"),
@@ -330,11 +279,10 @@ enum class DateRange(val displayName: String) {
     THIS_YEAR("This Year")
 }
 
-enum class FaceFilter(val displayName: String) {
+/**
-    ALL("All Photos"),
+ * Display modes for photo tags
-    HAS_FACES("Has Faces"),
+ */
-    NO_FACES("No Faces")
+enum class DisplayMode {
+    SIMPLE,    // Just person names
+    VERBOSE    // Names + icons + confidence percentages
 }
-
-@Deprecated("No longer used")
-enum class DisplayMode { SIMPLE, VERBOSE }

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

@@ -24,24 +24,9 @@ import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.placeholder.sherpai2.data.local.entity.TagWithUsage
 
-/**
- * CLEANED TagManagementScreen - No Scaffold wrapper
- *
- * Removed:
- * - Scaffold wrapper (line 38)
- * - Moved FAB inline as part of content
- *
- * Features:
- * - Tag list with usage counts
- * - Search functionality
- * - Scanning progress
- * - Delete tags
- * - System/User tag distinction
- */
 @Composable
 fun TagManagementScreen(
-    viewModel: TagManagementViewModel = hiltViewModel(),
+    viewModel: TagManagementViewModel = hiltViewModel()
-    modifier: Modifier = Modifier
 ) {
     val uiState by viewModel.uiState.collectAsState()
     val scanningState by viewModel.scanningState.collectAsState()
@@ -50,8 +35,105 @@ fun TagManagementScreen(
     var showScanMenu by remember { mutableStateOf(false) }
     var searchQuery by remember { mutableStateOf("") }
 
-    Box(modifier = modifier.fillMaxSize()) {
+    Scaffold(
-        Column(modifier = Modifier.fillMaxSize()) {
+        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)
 
@@ -84,30 +166,16 @@ fun TagManagementScreen(
                     }
                 }
                 is TagManagementViewModel.TagUiState.Success -> {
-                    if (state.tags.isEmpty()) {
-                        EmptyTagsView()
-                    } else {
                     TagList(
                         tags = state.tags,
                         onDeleteTag = { viewModel.deleteTag(it) }
                     )
                 }
-                }
                 is TagManagementViewModel.TagUiState.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
@@ -118,28 +186,6 @@ fun TagManagementScreen(
         }
     }
 
-        // FAB (inline, positioned over content)
-        ScanFAB(
-            showMenu = showScanMenu,
-            onToggleMenu = { showScanMenu = !showScanMenu },
-            onScanAll = {
-                viewModel.scanForAllTags()
-                showScanMenu = false
-            },
-            onScanBase = {
-                viewModel.scanForBaseTags()
-                showScanMenu = false
-            },
-            onScanRelationships = {
-                viewModel.scanForRelationshipTags()
-                showScanMenu = false
-            },
-            modifier = Modifier
-                .align(Alignment.BottomEnd)
-                .padding(16.dp)
-        )
-    }
-
     // Add Tag Dialog
     if (showAddTagDialog) {
         AddTagDialog(
@@ -150,77 +196,73 @@ fun TagManagementScreen(
             }
         )
     }
+
+    // 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
+            }
+        )
+    }
 }
 
-/**
- * Stats bar at top
- */
 @Composable
 private fun StatsBar(uiState: TagManagementViewModel.TagUiState) {
-    val (totalTags, totalPhotos) = when (uiState) {
+    if (uiState is TagManagementViewModel.TagUiState.Success) {
-        is TagManagementViewModel.TagUiState.Success -> {
+        Card(
-            val photoCount: Int = uiState.tags.sumOf { it.usageCount }
+            modifier = Modifier
-            uiState.tags.size to photoCount
+                .fillMaxWidth()
-        }
+                .padding(16.dp),
-        else -> 0 to 0
+            colors = CardDefaults.cardColors(
-    }
+                containerColor = MaterialTheme.colorScheme.primaryContainer
-
+            )
-    Surface(
-        modifier = Modifier.fillMaxWidth(),
-        color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
         ) {
             Row(
                 modifier = Modifier
                     .fillMaxWidth()
                     .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceEvenly
+                horizontalArrangement = Arrangement.SpaceAround
             ) {
-            StatItem(
+                StatItem("Total", uiState.totalTags.toString(), Icons.Default.Label)
-                icon = Icons.Default.Label,
+                StatItem("System", uiState.systemTags.toString(), Icons.Default.AutoAwesome)
-                value = totalTags.toString(),
+                StatItem("User", uiState.userTags.toString(), Icons.Default.PersonOutline)
-                label = "Tags"
+            }
-            )
-            VerticalDivider(
-                modifier = Modifier.height(48.dp),
-                color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
-            )
-            StatItem(
-                icon = Icons.Default.Photo,
-                value = totalPhotos.toString(),
-                label = "Tagged Photos"
-            )
         }
     }
 }
 
 @Composable
-private fun StatItem(icon: ImageVector, value: String, label: String) {
+private fun StatItem(label: String, value: String, icon: ImageVector) {
-    Column(
+    Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
         Icon(
-            icon,
+            imageVector = icon,
             contentDescription = null,
-            modifier = Modifier.size(24.dp),
+            tint = MaterialTheme.colorScheme.primary,
-            tint = MaterialTheme.colorScheme.primary
+            modifier = Modifier.size(24.dp)
         )
+        Spacer(modifier = Modifier.height(4.dp))
         Text(
-            value,
+            text = value,
             style = MaterialTheme.typography.headlineSmall,
             fontWeight = FontWeight.Bold
         )
         Text(
-            label,
+            text = label,
-            style = MaterialTheme.typography.labelMedium,
+            style = MaterialTheme.typography.bodySmall,
             color = MaterialTheme.colorScheme.onSurfaceVariant
         )
     }
 }
 
-/**
- * Search bar
- */
 @Composable
 private fun SearchBar(
     searchQuery: String,
@@ -231,9 +273,9 @@ private fun SearchBar(
         onValueChange = onSearchChange,
         modifier = Modifier
             .fillMaxWidth()
-            .padding(16.dp),
+            .padding(horizontal = 16.dp),
         placeholder = { Text("Search tags...") },
-        leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) },
+        leadingIcon = { Icon(Icons.Default.Search, "Search") },
         trailingIcon = {
             if (searchQuery.isNotEmpty()) {
                 IconButton(onClick = { onSearchChange("") }) {
@@ -241,124 +283,96 @@ private fun SearchBar(
                 }
             }
         },
-        singleLine = true,
+        singleLine = true
-        shape = RoundedCornerShape(16.dp)
     )
 }
 
-/**
- * Scanning progress indicator
- */
 @Composable
 private fun ScanningProgress(
     scanningState: TagManagementViewModel.TagScanningState,
     viewModel: TagManagementViewModel
 ) {
-    when (scanningState) {
-        is TagManagementViewModel.TagScanningState.Scanning -> {
     Card(
         modifier = Modifier
             .fillMaxWidth()
-                    .padding(horizontal = 16.dp, vertical = 8.dp),
+            .padding(16.dp),
         colors = CardDefaults.cardColors(
-                    containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f)
+            containerColor = MaterialTheme.colorScheme.secondaryContainer
         )
     ) {
         Column(
-                    modifier = Modifier.padding(16.dp),
+            modifier = Modifier
-                    verticalArrangement = Arrangement.spacedBy(8.dp)
+                .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(
-                            "Scanning: ${scanningState.scanType}",
+                            text = "Error: ${scanningState.message}",
-                            style = MaterialTheme.typography.titleSmall,
+                            style = MaterialTheme.typography.bodyMedium,
-                            fontWeight = FontWeight.SemiBold
+                            color = MaterialTheme.colorScheme.error
-                        )
-                        Text(
-                            "${scanningState.progress}/${scanningState.total}",
-                            style = MaterialTheme.typography.bodySmall
-                        )
-                    }
-                    LinearProgressIndicator(
-                        progress = {
-                            if (scanningState.total > 0) {
-                                scanningState.progress.toFloat() / scanningState.total.toFloat()
-                            } else {
-                                0f
-                            }
-                        },
-                        modifier = Modifier.fillMaxWidth()
-                    )
-                    Text(
-                        "Tags applied: ${scanningState.tagsApplied}",
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.primary
-                    )
-                    if (scanningState.currentImage.isNotEmpty()) {
-                        Text(
-                            "Current: ${scanningState.currentImage}",
-                            style = MaterialTheme.typography.labelSmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
                         )
+                        IconButton(onClick = { viewModel.resetScanningState() }) {
+                            Icon(Icons.Default.Close, "Close")
                         }
                     }
                 }
-        }
+                else -> { /* Idle - don't show */ }
-        is TagManagementViewModel.TagScanningState.Complete -> {
-            Card(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 16.dp, vertical = 8.dp),
-                colors = CardDefaults.cardColors(
-                    containerColor = MaterialTheme.colorScheme.primaryContainer
-                )
-            ) {
-                Row(
-                    modifier = Modifier.padding(16.dp),
-                    horizontalArrangement = Arrangement.spacedBy(12.dp),
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Icon(
-                        Icons.Default.CheckCircle,
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.primary
-                    )
-                    Column {
-                        Text(
-                            "Scan Complete!",
-                            style = MaterialTheme.typography.titleSmall,
-                            fontWeight = FontWeight.Bold
-                        )
-                        Text(
-                            "Processed: ${scanningState.imagesProcessed} images",
-                            style = MaterialTheme.typography.bodySmall
-                        )
-                        Text(
-                            "Applied: ${scanningState.tagsApplied} tags",
-                            style = MaterialTheme.typography.bodySmall
-                        )
-                        if (scanningState.newTagsCreated > 0) {
-                            Text(
-                                "Created: ${scanningState.newTagsCreated} new tags",
-                                style = MaterialTheme.typography.bodySmall,
-                                color = MaterialTheme.colorScheme.primary
-                            )
             }
         }
     }
-            }
-        }
-        else -> {}
-    }
 }
 
-/**
- * Tag list
- */
 @Composable
 private fun TagList(
     tags: List<TagWithUsage>,
@@ -369,238 +383,114 @@ private fun TagList(
         contentPadding = PaddingValues(16.dp),
         verticalArrangement = Arrangement.spacedBy(8.dp)
     ) {
-        items(tags) { tagWithUsage ->
+        items(tags, key = { it.tagId }) { tag ->
-            TagCard(
+            TagListItem(tag, onDeleteTag)
-                tagWithUsage = tagWithUsage,
-                onDelete = { onDeleteTag(tagWithUsage.tagId) }
-            )
         }
     }
 }
 
-/**
- * Individual tag card
- */
 @Composable
-private fun TagCard(
+private fun TagListItem(
-    tagWithUsage: TagWithUsage,
+    tag: TagWithUsage,
-    onDelete: () -> Unit
+    onDeleteTag: (String) -> Unit
 ) {
-    val isSystemTag = tagWithUsage.type == "SYSTEM"
+    var showDeleteConfirm by remember { mutableStateOf(false) }
 
     Card(
         modifier = Modifier.fillMaxWidth(),
-        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
+        onClick = { /* TODO: Navigate to images with this tag */ }
     ) {
         Row(
-            modifier = Modifier.padding(16.dp),
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
             horizontalArrangement = Arrangement.SpaceBetween,
             verticalAlignment = Alignment.CenterVertically
         ) {
             Row(
-                modifier = Modifier.weight(1f),
                 horizontalArrangement = Arrangement.spacedBy(12.dp),
                 verticalAlignment = Alignment.CenterVertically
             ) {
-                // Tag icon
+                // Tag type icon
-                Surface(
-                    modifier = Modifier.size(40.dp),
-                    shape = RoundedCornerShape(8.dp),
-                    color = if (isSystemTag)
-                        MaterialTheme.colorScheme.primaryContainer
-                    else
-                        MaterialTheme.colorScheme.secondaryContainer
-                ) {
-                    Box(contentAlignment = Alignment.Center) {
                 Icon(
-                            if (isSystemTag) Icons.Default.AutoAwesome else Icons.Default.Label,
+                    imageVector = if (tag.type == "SYSTEM") Icons.Default.AutoAwesome else Icons.Default.Label,
                     contentDescription = null,
-                            modifier = Modifier.size(20.dp),
+                    tint = if (tag.type == "SYSTEM")
-                            tint = if (isSystemTag)
+                        MaterialTheme.colorScheme.secondary
-                                MaterialTheme.colorScheme.onPrimaryContainer
                     else
-                                MaterialTheme.colorScheme.onSecondaryContainer
+                        MaterialTheme.colorScheme.primary
                 )
-                    }
-                }
 
-                // Tag info
                 Column {
-                    Row(
-                        horizontalArrangement = Arrangement.spacedBy(8.dp),
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
                     Text(
-                            text = tagWithUsage.value,
+                        text = tag.value,
                         style = MaterialTheme.typography.titleMedium,
-                            fontWeight = FontWeight.SemiBold
+                        fontWeight = FontWeight.Medium
                     )
-                        if (isSystemTag) {
-                            Surface(
-                                shape = RoundedCornerShape(4.dp),
-                                color = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
-                            ) {
                     Text(
-                                    "SYSTEM",
+                        text = if (tag.type == "SYSTEM") "System tag" else "User tag",
-                                    modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
-                                    style = MaterialTheme.typography.labelSmall,
-                                    color = MaterialTheme.colorScheme.primary
-                                )
-                            }
-                        }
-                    }
-                    Text(
-                        text = "${tagWithUsage.usageCount} ${if (tagWithUsage.usageCount == 1) "photo" else "photos"}",
                         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 (!isSystemTag) {
+                if (tag.type == "GENERIC") {
-                IconButton(onClick = onDelete) {
+                    IconButton(onClick = { showDeleteConfirm = true }) {
                         Icon(
                             Icons.Default.Delete,
-                        contentDescription = "Delete",
+                            contentDescription = "Delete tag",
                             tint = MaterialTheme.colorScheme.error
                         )
                     }
                 }
             }
         }
-}
-
-/**
- * Empty state
- */
-@Composable
-private fun EmptyTagsView() {
-    Box(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(32.dp),
-        contentAlignment = Alignment.Center
-    ) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            Icon(
-                Icons.Default.LabelOff,
-                contentDescription = null,
-                modifier = Modifier.size(64.dp),
-                tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
-            )
-            Text(
-                "No Tags Yet",
-                style = MaterialTheme.typography.titleLarge,
-                fontWeight = FontWeight.Bold
-            )
-            Text(
-                "Scan your photos to generate tags automatically",
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = androidx.compose.ui.text.style.TextAlign.Center
-            )
-        }
-    }
-}
-
-/**
- * Floating Action Button with scan menu
- */
-@Composable
-private fun ScanFAB(
-    showMenu: Boolean,
-    onToggleMenu: () -> Unit,
-    onScanAll: () -> Unit,
-    onScanBase: () -> Unit,
-    onScanRelationships: () -> Unit,
-    modifier: Modifier = Modifier
-) {
-    Column(
-        modifier = modifier,
-        horizontalAlignment = Alignment.End,
-        verticalArrangement = Arrangement.spacedBy(8.dp)
-    ) {
-        // Menu options
-        AnimatedVisibility(visible = showMenu) {
-            Column(
-                horizontalAlignment = Alignment.End,
-                verticalArrangement = Arrangement.spacedBy(8.dp)
-            ) {
-                SmallFAB(
-                    icon = Icons.Default.AutoFixHigh,
-                    text = "Scan All",
-                    onClick = onScanAll
-                )
-                SmallFAB(
-                    icon = Icons.Default.PhotoCamera,
-                    text = "Base Tags",
-                    onClick = onScanBase
-                )
-                SmallFAB(
-                    icon = Icons.Default.People,
-                    text = "Relationships",
-                    onClick = onScanRelationships
-                )
-            }
     }
 
-        // Main FAB
+    if (showDeleteConfirm) {
-        ExtendedFloatingActionButton(
+        AlertDialog(
-            onClick = onToggleMenu,
+            onDismissRequest = { showDeleteConfirm = false },
-            icon = {
+            title = { Text("Delete Tag?") },
-                Icon(
+            text = { Text("Are you sure you want to delete '${tag.value}'? This will remove it from ${tag.usageCount} images.") },
-                    if (showMenu) Icons.Default.Close else Icons.Default.AutoFixHigh,
+            confirmButton = {
-                    "Scan"
+                TextButton(
-                )
+                    onClick = {
+                        onDeleteTag(tag.tagId)
+                        showDeleteConfirm = false
+                    }
+                ) {
+                    Text("Delete", color = MaterialTheme.colorScheme.error)
+                }
             },
-            text = { Text(if (showMenu) "Close" else "Scan Tags") },
+            dismissButton = {
-            containerColor = MaterialTheme.colorScheme.primaryContainer,
+                TextButton(onClick = { showDeleteConfirm = false }) {
-            contentColor = MaterialTheme.colorScheme.onPrimaryContainer
+                    Text("Cancel")
+                }
+            }
         )
     }
 }
 
-@Composable
-private fun SmallFAB(
-    icon: ImageVector,
-    text: String,
-    onClick: () -> Unit
-) {
-    Row(
-        verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.spacedBy(8.dp)
-    ) {
-        Surface(
-            shape = RoundedCornerShape(8.dp),
-            color = MaterialTheme.colorScheme.surface,
-            shadowElevation = 2.dp
-        ) {
-            Text(
-                text,
-                modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp),
-                style = MaterialTheme.typography.bodySmall,
-                fontWeight = FontWeight.Medium
-            )
-        }
-
-        FloatingActionButton(
-            onClick = onClick,
-            modifier = Modifier.size(48.dp),
-            containerColor = MaterialTheme.colorScheme.secondaryContainer,
-            contentColor = MaterialTheme.colorScheme.onSecondaryContainer
-        ) {
-            Icon(icon, contentDescription = text, modifier = Modifier.size(20.dp))
-        }
-    }
-}
-
-/**
- * Add tag dialog
- */
 @Composable
 private fun AddTagDialog(
     onDismiss: () -> Unit,
@@ -610,19 +500,18 @@ private fun AddTagDialog(
 
     AlertDialog(
         onDismissRequest = onDismiss,
-        icon = { Icon(Icons.Default.Add, contentDescription = null) },
+        title = { Text("Add New Tag") },
-        title = { Text("Add Custom Tag") },
         text = {
             OutlinedTextField(
                 value = tagName,
                 onValueChange = { tagName = it },
-                label = { Text("Tag Name") },
+                label = { Text("Tag name") },
                 singleLine = true,
                 modifier = Modifier.fillMaxWidth()
             )
         },
         confirmButton = {
-            Button(
+            TextButton(
                 onClick = { onConfirm(tagName) },
                 enabled = tagName.isNotBlank()
             ) {
@@ -636,3 +525,100 @@ private fun AddTagDialog(
         }
     )
 }
+
+@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/trainingprep/Beautifulpersoninfodialog.kt

@@ -1,197 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import android.os.Build
-import android.view.View
-import android.view.autofill.AutofillManager
-import androidx.annotation.RequiresApi
-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.compose.ui.platform.LocalView
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.Dialog
-import androidx.compose.ui.window.DialogProperties
-import java.text.SimpleDateFormat
-import java.util.*
-
-@RequiresApi(Build.VERSION_CODES.O)
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun BeautifulPersonInfoDialog(
-    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) }
-
-    // ✅ Disable autofill for this dialog
-    val view = LocalView.current
-    DisposableEffect(Unit) {
-        val autofillManager = view.context.getSystemService(AutofillManager::class.java)
-        view.importantForAutofill = View.IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS
-        onDispose {
-            view.importantForAutofill = View.IMPORTANT_FOR_AUTOFILL_AUTO
-        }
-    }
-
-    val relationships = listOf(
-        "Family" to "👨‍👩‍👧‍👦",
-        "Friend" to "🤝",
-        "Partner" to "❤️",
-        "Parent" to "👪",
-        "Sibling" to "👫",
-        "Colleague" to "💼"
-    )
-
-    Dialog(
-        onDismissRequest = onDismiss,
-        properties = DialogProperties(usePlatformDefaultWidth = false)
-    ) {
-        Card(
-            modifier = Modifier.fillMaxWidth(0.92f).fillMaxHeight(0.85f),
-            shape = RoundedCornerShape(28.dp),
-            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
-            elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
-        ) {
-            Column(modifier = Modifier.fillMaxSize()) {
-                Row(
-                    modifier = Modifier.fillMaxWidth().padding(24.dp),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Row(horizontalArrangement = Arrangement.spacedBy(16.dp), verticalAlignment = Alignment.CenterVertically) {
-                        Surface(shape = RoundedCornerShape(16.dp), color = MaterialTheme.colorScheme.primaryContainer, modifier = Modifier.size(64.dp)) {
-                            Box(contentAlignment = Alignment.Center) {
-                                Icon(Icons.Default.Person, contentDescription = null, modifier = Modifier.size(36.dp), tint = MaterialTheme.colorScheme.primary)
-                            }
-                        }
-
-                        Column {
-                            Text("Person Details", style = MaterialTheme.typography.headlineMedium, fontWeight = FontWeight.Bold)
-                            Text("Help us organize your photos", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
-                        }
-                    }
-
-                    IconButton(onClick = onDismiss) {
-                        Icon(Icons.Default.Close, contentDescription = "Close", modifier = Modifier.size(24.dp))
-                    }
-                }
-
-                HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
-
-                Column(modifier = Modifier.weight(1f).verticalScroll(rememberScrollState()).padding(24.dp), verticalArrangement = Arrangement.spacedBy(24.dp)) {
-                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                        Text("Name *", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.primary)
-                        OutlinedTextField(
-                            value = name,
-                            onValueChange = { name = it },
-                            placeholder = { Text("e.g., John Doe") },
-                            leadingIcon = { Icon(Icons.Default.Face, contentDescription = null) },
-                            modifier = Modifier.fillMaxWidth(),
-                            singleLine = true,
-                            shape = RoundedCornerShape(16.dp),
-                            keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
-                                capitalization = KeyboardCapitalization.Words,
-                                autoCorrect = false
-                            )
-                        )
-                    }
-
-                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                        Text("Birthday", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.primary)
-                        OutlinedTextField(
-                            value = dateOfBirth?.let { SimpleDateFormat("MMM d, yyyy", Locale.getDefault()).format(Date(it)) } ?: "",
-                            onValueChange = {},
-                            readOnly = true,
-                            placeholder = { Text("Select birthday") },
-                            leadingIcon = { Icon(Icons.Default.Cake, contentDescription = null) },
-                            trailingIcon = {
-                                IconButton(onClick = { showDatePicker = true }) {
-                                    Icon(Icons.Default.CalendarToday, contentDescription = "Select date")
-                                }
-                            },
-                            modifier = Modifier.fillMaxWidth(),
-                            singleLine = true,
-                            shape = RoundedCornerShape(16.dp)
-                        )
-                    }
-
-                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                        Text("Relationship", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.primary)
-
-                        var expanded by remember { mutableStateOf(false) }
-
-                        ExposedDropdownMenuBox(expanded = expanded, onExpandedChange = { expanded = it }) {
-                            OutlinedTextField(
-                                value = selectedRelationship,
-                                onValueChange = {},
-                                readOnly = true,
-                                leadingIcon = { Icon(Icons.Default.People, contentDescription = null) },
-                                trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
-                                modifier = Modifier.fillMaxWidth().menuAnchor(),
-                                singleLine = true,
-                                shape = RoundedCornerShape(16.dp),
-                                colors = ExposedDropdownMenuDefaults.outlinedTextFieldColors()
-                            )
-
-                            ExposedDropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
-                                relationships.forEach { (relationship, emoji) ->
-                                    DropdownMenuItem(text = { Text("$emoji $relationship") }, onClick = { selectedRelationship = relationship; expanded = false })
-                                }
-                            }
-                        }
-                    }
-
-                    Card(colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.3f)), shape = RoundedCornerShape(12.dp)) {
-                        Row(modifier = Modifier.padding(16.dp), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
-                            Icon(Icons.Default.Lock, contentDescription = null, tint = MaterialTheme.colorScheme.tertiary, modifier = Modifier.size(20.dp))
-                            Text("All information stays private on your device", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onTertiaryContainer)
-                        }
-                    }
-                }
-
-                HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
-
-                Row(modifier = Modifier.fillMaxWidth().padding(24.dp), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
-                    OutlinedButton(onClick = onDismiss, modifier = Modifier.weight(1f).height(56.dp), shape = RoundedCornerShape(16.dp)) {
-                        Text("Cancel", style = MaterialTheme.typography.titleMedium)
-                    }
-
-                    Button(
-                        onClick = { onConfirm(name.trim(), dateOfBirth, selectedRelationship) },
-                        enabled = name.trim().isNotEmpty(),
-                        modifier = Modifier.weight(1f).height(56.dp),
-                        shape = RoundedCornerShape(16.dp)
-                    ) {
-                        Icon(Icons.Default.Check, contentDescription = null, modifier = Modifier.size(20.dp))
-                        Spacer(Modifier.width(8.dp))
-                        Text("Continue", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
-                    }
-                }
-            }
-        }
-    }
-
-    if (showDatePicker) {
-        val datePickerState = rememberDatePickerState(initialSelectedDateMillis = dateOfBirth ?: System.currentTimeMillis())
-
-        DatePickerDialog(
-            onDismissRequest = { showDatePicker = false },
-            confirmButton = { TextButton(onClick = { dateOfBirth = datePickerState.selectedDateMillis; showDatePicker = false }) { Text("OK") } },
-            dismissButton = { TextButton(onClick = { showDatePicker = false }) { Text("Cancel") } }
-        ) {
-            DatePicker(state = datePickerState)
-        }
-    }
-}

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

@@ -1,360 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import android.net.Uri
-import androidx.compose.foundation.BorderStroke
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.LazyRow
-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.Color
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import coil.compose.AsyncImage
-
-/**
- * DuplicateImageHighlighter - Enhanced duplicate detection UI
- *
- * FEATURES:
- * - Visual highlighting of duplicate groups
- * - Shows thumbnail previews of duplicates
- * - One-click "Remove Duplicate" button
- * - Keeps best image automatically
- * - Warning badge with count
- *
- * GENTLE UX:
- * - Non-intrusive warning color (amber, not red)
- * - Clear visual grouping
- * - Simple action ("Remove" vs "Keep")
- * - Automatic selection of which to remove
- */
-@Composable
-fun DuplicateImageHighlighter(
-    duplicateGroups: List<DuplicateImageDetector.DuplicateGroup>,
-    allImageUris: List<Uri>,
-    onRemoveDuplicate: (Uri) -> Unit,
-    modifier: Modifier = Modifier
-) {
-    if (duplicateGroups.isEmpty()) return
-
-    Column(
-        modifier = modifier
-            .fillMaxWidth()
-            .padding(vertical = 8.dp),
-        verticalArrangement = Arrangement.spacedBy(12.dp)
-    ) {
-        // Header with count
-        Row(
-            modifier = Modifier.fillMaxWidth(),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Row(
-                horizontalArrangement = Arrangement.spacedBy(8.dp),
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Icon(
-                    Icons.Default.Warning,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.tertiary,  // Amber, not red
-                    modifier = Modifier.size(20.dp)
-                )
-                Text(
-                    "${duplicateGroups.size} duplicate ${if (duplicateGroups.size == 1) "group" else "groups"} found",
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
-                )
-            }
-
-            // Total duplicates badge
-            Surface(
-                shape = RoundedCornerShape(12.dp),
-                color = MaterialTheme.colorScheme.tertiaryContainer
-            ) {
-                Text(
-                    "${duplicateGroups.sumOf { it.images.size - 1 }} to remove",
-                    modifier = Modifier.padding(horizontal = 12.dp, vertical = 4.dp),
-                    style = MaterialTheme.typography.labelMedium,
-                    color = MaterialTheme.colorScheme.onTertiaryContainer,
-                    fontWeight = FontWeight.Bold
-                )
-            }
-        }
-
-        // Each duplicate group
-        duplicateGroups.forEachIndexed { groupIndex, group ->
-            DuplicateGroupCard(
-                groupIndex = groupIndex + 1,
-                duplicateGroup = group,
-                onRemove = onRemoveDuplicate
-            )
-        }
-    }
-}
-
-/**
- * Card showing one duplicate group with thumbnails
- */
-@Composable
-private fun DuplicateGroupCard(
-    groupIndex: Int,
-    duplicateGroup: DuplicateImageDetector.DuplicateGroup,
-    onRemove: (Uri) -> Unit
-) {
-    var expanded by remember { mutableStateOf(false) }
-
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.3f)
-        ),
-        border = BorderStroke(1.dp, MaterialTheme.colorScheme.tertiary.copy(alpha = 0.3f)),
-        shape = RoundedCornerShape(12.dp)
-    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(12.dp),
-            verticalArrangement = Arrangement.spacedBy(12.dp)
-        ) {
-            // Header row
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Row(
-                    horizontalArrangement = Arrangement.spacedBy(8.dp),
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    // Group number badge
-                    Surface(
-                        shape = RoundedCornerShape(8.dp),
-                        color = MaterialTheme.colorScheme.tertiary
-                    ) {
-                        Text(
-                            "#$groupIndex",
-                            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
-                            style = MaterialTheme.typography.labelMedium,
-                            color = MaterialTheme.colorScheme.onTertiary,
-                            fontWeight = FontWeight.Bold
-                        )
-                    }
-
-                    Text(
-                        "${duplicateGroup.images.size} identical images",
-                        style = MaterialTheme.typography.bodyMedium,
-                        fontWeight = FontWeight.SemiBold
-                    )
-                }
-
-                // Expand/collapse button
-                IconButton(
-                    onClick = { expanded = !expanded },
-                    modifier = Modifier.size(32.dp)
-                ) {
-                    Icon(
-                        if (expanded) Icons.Default.ExpandLess else Icons.Default.ExpandMore,
-                        contentDescription = if (expanded) "Collapse" else "Expand"
-                    )
-                }
-            }
-
-            // Thumbnail row (always visible)
-            LazyRow(
-                horizontalArrangement = Arrangement.spacedBy(8.dp)
-            ) {
-                items(duplicateGroup.images.take(3)) { uri ->
-                    DuplicateThumbnail(
-                        uri = uri,
-                        similarity = duplicateGroup.similarity
-                    )
-                }
-
-                if (duplicateGroup.images.size > 3) {
-                    item {
-                        Surface(
-                            modifier = Modifier
-                                .size(80.dp),
-                            shape = RoundedCornerShape(8.dp),
-                            color = MaterialTheme.colorScheme.surfaceVariant
-                        ) {
-                            Box(contentAlignment = Alignment.Center) {
-                                Text(
-                                    "+${duplicateGroup.images.size - 3}",
-                                    style = MaterialTheme.typography.titleMedium,
-                                    fontWeight = FontWeight.Bold
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Action buttons
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.spacedBy(8.dp)
-            ) {
-                // Keep first, remove rest
-                Button(
-                    onClick = {
-                        // Remove all but the first image
-                        duplicateGroup.images.drop(1).forEach { uri ->
-                            onRemove(uri)
-                        }
-                    },
-                    modifier = Modifier.weight(1f),
-                    colors = ButtonDefaults.buttonColors(
-                        containerColor = MaterialTheme.colorScheme.tertiary
-                    )
-                ) {
-                    Icon(
-                        Icons.Default.DeleteSweep,
-                        contentDescription = null,
-                        modifier = Modifier.size(18.dp)
-                    )
-                    Spacer(Modifier.width(6.dp))
-                    Text("Remove ${duplicateGroup.images.size - 1} Duplicates")
-                }
-            }
-
-            // Expanded info (optional)
-            if (expanded) {
-                HorizontalDivider(color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f))
-
-                Column(
-                    verticalArrangement = Arrangement.spacedBy(8.dp)
-                ) {
-                    Text(
-                        "Individual actions:",
-                        style = MaterialTheme.typography.labelMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-
-                    duplicateGroup.images.forEachIndexed { index, uri ->
-                        Row(
-                            modifier = Modifier.fillMaxWidth(),
-                            horizontalArrangement = Arrangement.SpaceBetween,
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-                            Row(
-                                horizontalArrangement = Arrangement.spacedBy(8.dp),
-                                verticalAlignment = Alignment.CenterVertically,
-                                modifier = Modifier.weight(1f)
-                            ) {
-                                AsyncImage(
-                                    model = uri,
-                                    contentDescription = null,
-                                    modifier = Modifier
-                                        .size(40.dp)
-                                        .background(
-                                            MaterialTheme.colorScheme.surfaceVariant,
-                                            RoundedCornerShape(6.dp)
-                                        ),
-                                    contentScale = ContentScale.Crop
-                                )
-
-                                Text(
-                                    uri.lastPathSegment?.take(20) ?: "Image ${index + 1}",
-                                    style = MaterialTheme.typography.bodySmall,
-                                    modifier = Modifier.weight(1f)
-                                )
-                            }
-
-                            if (index == 0) {
-                                // First image - will be kept
-                                Surface(
-                                    shape = RoundedCornerShape(8.dp),
-                                    color = MaterialTheme.colorScheme.primaryContainer
-                                ) {
-                                    Row(
-                                        modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
-                                        horizontalArrangement = Arrangement.spacedBy(4.dp),
-                                        verticalAlignment = Alignment.CenterVertically
-                                    ) {
-                                        Icon(
-                                            Icons.Default.CheckCircle,
-                                            contentDescription = null,
-                                            modifier = Modifier.size(14.dp),
-                                            tint = MaterialTheme.colorScheme.primary
-                                        )
-                                        Text(
-                                            "Keep",
-                                            style = MaterialTheme.typography.labelSmall,
-                                            color = MaterialTheme.colorScheme.primary,
-                                            fontWeight = FontWeight.Bold
-                                        )
-                                    }
-                                }
-                            } else {
-                                // Duplicate - will be removed
-                                TextButton(
-                                    onClick = { onRemove(uri) },
-                                    colors = ButtonDefaults.textButtonColors(
-                                        contentColor = MaterialTheme.colorScheme.error
-                                    )
-                                ) {
-                                    Icon(
-                                        Icons.Default.Delete,
-                                        contentDescription = null,
-                                        modifier = Modifier.size(16.dp)
-                                    )
-                                    Spacer(Modifier.width(4.dp))
-                                    Text("Remove", style = MaterialTheme.typography.labelMedium)
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/**
- * Thumbnail with similarity badge
- */
-@Composable
-private fun DuplicateThumbnail(
-    uri: Uri,
-    similarity: Double
-) {
-    Box {
-        AsyncImage(
-            model = uri,
-            contentDescription = null,
-            modifier = Modifier
-                .size(80.dp)
-                .background(
-                    MaterialTheme.colorScheme.surfaceVariant,
-                    RoundedCornerShape(8.dp)
-                ),
-            contentScale = ContentScale.Crop
-        )
-
-        // Similarity badge
-        Surface(
-            modifier = Modifier
-                .align(Alignment.BottomEnd)
-                .padding(4.dp),
-            shape = RoundedCornerShape(4.dp),
-            color = MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.9f)
-        ) {
-            Text(
-                "${(similarity * 100).toInt()}%",
-                modifier = Modifier.padding(horizontal = 4.dp, vertical = 2.dp),
-                style = MaterialTheme.typography.labelSmall,
-                color = MaterialTheme.colorScheme.onTertiaryContainer,
-                fontWeight = FontWeight.Bold
-            )
-        }
-    }
-}

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

@@ -5,105 +5,65 @@ import android.graphics.BitmapFactory
 import android.graphics.Rect
 import android.net.Uri
 import androidx.compose.foundation.BorderStroke
-import androidx.compose.foundation.Image
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 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.material.icons.filled.CheckCircle
+import androidx.compose.material.icons.filled.Close
 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.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
-import com.google.mlkit.vision.common.InputImage
+import coil.compose.AsyncImage
-import com.google.mlkit.vision.face.FaceDetection
-import androidx.compose.ui.graphics.Color
-import com.google.mlkit.vision.face.FaceDetectorOptions
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.tasks.await
 import kotlinx.coroutines.withContext
 
 /**
- * MINIMAL FacePickerDialog - Optimized for batch processing 30-50 photos
+ * Dialog for selecting a face from multiple detected faces
- *
- * REMOVED CLUTTER:
- * - "Preview (tap to select)" header
- * - "Face will be used for training" info box
- * - "Face #" labels covering previews
- * - Original image preview
- *
- * IMPROVED:
- * - Larger face previews (1:1 aspect ratio)
- * - Clean checkmark overlay only
- * - Minimal text
- * - Fast workflow
  */
 @Composable
 fun FacePickerDialog(
     result: FaceDetectionHelper.FaceDetectionResult,
     onDismiss: () -> Unit,
-    onFaceSelected: (Int, Bitmap) -> Unit
+    onFaceSelected: (Int, Bitmap) -> Unit // faceIndex, croppedFaceBitmap
 ) {
     val context = LocalContext.current
-    var selectedFaceIndex by remember { mutableStateOf(0) }
+    var selectedFaceIndex by remember { mutableStateOf<Int?>(null) }
     var croppedFaces by remember { mutableStateOf<List<Bitmap>>(emptyList()) }
     var isLoading by remember { mutableStateOf(true) }
-    var errorMessage by remember { mutableStateOf<String?>(null) }
 
-    // Load and crop all faces - RE-DETECT to get accurate bounds
+    // Load and crop all faces
     LaunchedEffect(result) {
         isLoading = true
-        errorMessage = null
-
-        try {
         croppedFaces = withContext(Dispatchers.IO) {
-                // Load the FULL resolution bitmap (no downsampling)
+            val bitmap = loadBitmapFromUri(context, result.uri)
-                val fullBitmap = loadFullResolutionBitmap(context, result.uri)
+            bitmap?.let { bmp ->
-
+                result.faceBounds.map { bounds ->
-                if (fullBitmap == null) {
+                    cropFaceFromBitmap(bmp, bounds)
-                    errorMessage = "Failed to load image"
-                    return@withContext emptyList()
                 }
-
+            } ?: emptyList()
-                // Re-detect faces on the full resolution bitmap to get accurate bounds
-                val accurateFaceBounds = detectFacesOnBitmap(fullBitmap)
-
-                if (accurateFaceBounds.isEmpty()) {
-                    // Fallback: try to use the original bounds with scaling
-                    val scaledBounds = result.faceBounds.map { originalBounds ->
-                        cropFaceFromBitmap(fullBitmap, originalBounds)
         }
-                    fullBitmap.recycle()
-                    return@withContext scaledBounds
-                }
-
-                // Crop faces using accurate bounds
-                val croppedList = accurateFaceBounds.map { bounds ->
-                    cropFaceFromBitmap(fullBitmap, bounds)
-                }
-
-                // CRITICAL: Recycle AFTER all cropping is done
-                fullBitmap.recycle()
-
-                croppedList
-            }
-
-            if (croppedFaces.isEmpty() && errorMessage == null) {
-                errorMessage = "No faces found in full resolution image"
-            }
-
-        } catch (e: Exception) {
-            errorMessage = "Error processing faces: ${e.message}"
-        } finally {
         isLoading = false
+        // Auto-select the first (largest) face
+        if (croppedFaces.isNotEmpty()) {
+            selectedFaceIndex = 0
         }
     }
 
@@ -113,62 +73,96 @@ fun FacePickerDialog(
     ) {
         Card(
             modifier = Modifier
-                .fillMaxWidth(0.92f)
+                .fillMaxWidth(0.95f)
-                .wrapContentHeight(),
+                .fillMaxHeight(0.9f),
-            shape = RoundedCornerShape(20.dp),
+            shape = RoundedCornerShape(16.dp)
-            colors = CardDefaults.cardColors(
-                containerColor = MaterialTheme.colorScheme.surface
-            )
         ) {
             Column(
                 modifier = Modifier
-                    .fillMaxWidth()
+                    .fillMaxSize()
                     .padding(20.dp),
                 verticalArrangement = Arrangement.spacedBy(16.dp)
             ) {
-                // Minimal header - just close button
+                // Header
                 Row(
                     modifier = Modifier.fillMaxWidth(),
                     horizontalArrangement = Arrangement.SpaceBetween,
                     verticalAlignment = Alignment.CenterVertically
                 ) {
+                    Column {
                         Text(
-                        text = "${result.faceCount} faces",
+                            text = "Pick a Face",
-                        style = MaterialTheme.typography.titleLarge,
+                            style = MaterialTheme.typography.headlineSmall,
                             fontWeight = FontWeight.Bold
                         )
+                        Text(
+                            text = "${result.faceCount} faces detected",
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
 
                     IconButton(onClick = onDismiss) {
-                        Icon(Icons.Default.Close, contentDescription = "Close")
+                        Icon(Icons.Default.Close, "Close")
                     }
                 }
 
+                // Instruction
+                Text(
+                    text = "Tap a face below to select it for training:",
+                    style = MaterialTheme.typography.bodyMedium
+                )
+
                 if (isLoading) {
-                    // Loading state - minimal
+                    // Loading state
                     Box(
                         modifier = Modifier
                             .fillMaxWidth()
-                            .height(180.dp),
+                            .weight(1f),
                         contentAlignment = Alignment.Center
                     ) {
                         CircularProgressIndicator()
                     }
-                } else if (errorMessage != null) {
-                    // Error state - minimal
-                    Text(
-                        text = errorMessage!!,
-                        color = MaterialTheme.colorScheme.error,
-                        style = MaterialTheme.typography.bodyMedium
-                    )
                 } else {
-                    // CLEAN face grid - NO labels, NO text
+                    // Original image with face boxes overlay
+                    Card(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f),
+                        colors = CardDefaults.cardColors(
+                            containerColor = MaterialTheme.colorScheme.surfaceVariant
+                        )
+                    ) {
+                        Box(
+                            modifier = Modifier.fillMaxSize(),
+                            contentAlignment = Alignment.Center
+                        ) {
+                            FaceOverlayImage(
+                                imageUri = result.uri,
+                                faceBounds = result.faceBounds,
+                                selectedFaceIndex = selectedFaceIndex,
+                                onFaceClick = { index ->
+                                    selectedFaceIndex = index
+                                }
+                            )
+                        }
+                    }
+
+                    // Face previews grid
+                    Text(
+                        text = "Preview (tap to select):",
+                        style = MaterialTheme.typography.bodyMedium,
+                        fontWeight = FontWeight.SemiBold
+                    )
+
                     Row(
                         modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.spacedBy(10.dp)
+                        horizontalArrangement = Arrangement.spacedBy(12.dp)
                     ) {
                         croppedFaces.forEachIndexed { index, faceBitmap ->
-                            CleanFaceCard(
+                            FacePreviewCard(
                                 faceBitmap = faceBitmap,
+                                index = index,
                                 isSelected = selectedFaceIndex == index,
                                 onClick = { selectedFaceIndex = index },
                                 modifier = Modifier.weight(1f)
@@ -177,34 +171,32 @@ fun FacePickerDialog(
                     }
                 }
 
-                // Action buttons - minimal
+                // Action buttons
                 Row(
                     modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(10.dp)
+                    horizontalArrangement = Arrangement.spacedBy(12.dp)
                 ) {
-                    TextButton(
+                    OutlinedButton(
                         onClick = onDismiss,
                         modifier = Modifier.weight(1f)
                     ) {
-                        Text("Skip")
+                        Text("Cancel")
                     }
 
                     Button(
                         onClick = {
-                            if (selectedFaceIndex < croppedFaces.size) {
+                            selectedFaceIndex?.let { index ->
-                                onFaceSelected(selectedFaceIndex, croppedFaces[selectedFaceIndex])
+                                if (index < croppedFaces.size) {
+                                    onFaceSelected(index, croppedFaces[index])
+                                }
                             }
                         },
-                        enabled = !isLoading && croppedFaces.isNotEmpty(),
+                        modifier = Modifier.weight(1f),
-                        modifier = Modifier.weight(1f)
+                        enabled = selectedFaceIndex != null && !isLoading
                     ) {
-                        Icon(
+                        Icon(Icons.Default.CheckCircle, contentDescription = null)
-                            Icons.Default.Check,
+                        Spacer(modifier = Modifier.width(8.dp))
-                            contentDescription = null,
+                        Text("Use This Face")
-                            modifier = Modifier.size(18.dp)
-                        )
-                        Spacer(modifier = Modifier.width(6.dp))
-                        Text("Use")
                     }
                 }
             }
@@ -213,75 +205,204 @@ fun FacePickerDialog(
 }
 
 /**
- * ULTRA-CLEAN face card - NO TEXT, just image + checkmark
+ * Image with interactive face boxes overlay
- *
- * CHANGES:
- * - 1:1 aspect ratio (bigger!)
- * - NO "Face #" label
- * - Checkmark in corner only
- * - Minimal border
  */
 @Composable
-private fun CleanFaceCard(
+private fun FaceOverlayImage(
+    imageUri: Uri,
+    faceBounds: List<Rect>,
+    selectedFaceIndex: Int?,
+    onFaceClick: (Int) -> Unit
+) {
+    var imageSize by remember { mutableStateOf(Size.Zero) }
+    var imageBounds by remember { mutableStateOf(Rect()) }
+
+    Box(
+        modifier = Modifier.fillMaxSize()
+    ) {
+        // Original image
+        AsyncImage(
+            model = imageUri,
+            contentDescription = "Original image",
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(8.dp),
+            contentScale = ContentScale.Fit,
+            onSuccess = { state ->
+                val drawable = state.result.drawable
+                imageBounds = Rect(0, 0, drawable.intrinsicWidth, drawable.intrinsicHeight)
+            }
+        )
+
+        // Face boxes overlay
+        Canvas(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(8.dp)
+        ) {
+            if (imageBounds.width() > 0 && imageBounds.height() > 0) {
+                // Calculate scale to fit image in canvas
+                val scaleX = size.width / imageBounds.width()
+                val scaleY = size.height / imageBounds.height()
+                val scale = minOf(scaleX, scaleY)
+
+                // Calculate offset to center image
+                val scaledWidth = imageBounds.width() * scale
+                val scaledHeight = imageBounds.height() * scale
+                val offsetX = (size.width - scaledWidth) / 2
+                val offsetY = (size.height - scaledHeight) / 2
+
+                faceBounds.forEachIndexed { index, bounds ->
+                    val isSelected = selectedFaceIndex == index
+
+                    // Scale and position the face box
+                    val left = bounds.left * scale + offsetX
+                    val top = bounds.top * scale + offsetY
+                    val width = bounds.width() * scale
+                    val height = bounds.height() * scale
+
+                    // Draw box
+                    drawRect(
+                        color = if (isSelected) Color(0xFF4CAF50) else Color(0xFF2196F3),
+                        topLeft = Offset(left, top),
+                        size = Size(width, height),
+                        style = Stroke(width = if (isSelected) 6f else 4f)
+                    )
+
+                    // Draw semi-transparent fill for selected
+                    if (isSelected) {
+                        drawRect(
+                            color = Color(0xFF4CAF50).copy(alpha = 0.2f),
+                            topLeft = Offset(left, top),
+                            size = Size(width, height)
+                        )
+                    }
+
+                    // Draw face number label
+                    drawCircle(
+                        color = if (isSelected) Color(0xFF4CAF50) else Color(0xFF2196F3),
+                        radius = 20f * scale,
+                        center = Offset(left + 20f * scale, top + 20f * scale)
+                    )
+                }
+            }
+        }
+
+        // Clickable areas for each face
+        faceBounds.forEachIndexed { index, bounds ->
+            if (imageBounds.width() > 0 && imageBounds.height() > 0) {
+                val scaleX = imageSize.width / imageBounds.width()
+                val scaleY = imageSize.height / imageBounds.height()
+                val scale = minOf(scaleX, scaleY)
+
+                val scaledWidth = imageBounds.width() * scale
+                val scaledHeight = imageBounds.height() * scale
+                val offsetX = (imageSize.width - scaledWidth) / 2
+                val offsetY = (imageSize.height - scaledHeight) / 2
+
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .clickable { onFaceClick(index) }
+                )
+            }
+        }
+    }
+
+    // Update image size
+    BoxWithConstraints {
+        LaunchedEffect(constraints) {
+            imageSize = Size(constraints.maxWidth.toFloat(), constraints.maxHeight.toFloat())
+        }
+    }
+}
+
+/**
+ * Individual face preview card
+ */
+@Composable
+private fun FacePreviewCard(
     faceBitmap: Bitmap,
+    index: Int,
     isSelected: Boolean,
     onClick: () -> Unit,
     modifier: Modifier = Modifier
 ) {
     Card(
         modifier = modifier
-            .aspectRatio(1f) // SQUARE = bigger previews!
+            .aspectRatio(1f)
             .clickable(onClick = onClick),
         colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.surfaceVariant
+            containerColor = if (isSelected)
+                MaterialTheme.colorScheme.primaryContainer
+            else
+                MaterialTheme.colorScheme.surface
         ),
         border = if (isSelected)
             BorderStroke(3.dp, MaterialTheme.colorScheme.primary)
         else
-            BorderStroke(1.dp, MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)),
+            BorderStroke(1.dp, MaterialTheme.colorScheme.outline)
-        shape = RoundedCornerShape(12.dp),
-        elevation = CardDefaults.cardElevation(
-            defaultElevation = if (isSelected) 4.dp else 1.dp
-        )
     ) {
-        Box(modifier = Modifier.fillMaxSize()) {
+        Box(
-            // Face image - FULL SIZE
+            modifier = Modifier.fillMaxSize()
-            Image(
+        ) {
+            androidx.compose.foundation.Image(
                 bitmap = faceBitmap.asImageBitmap(),
-                contentDescription = null,
+                contentDescription = "Face ${index + 1}",
                 modifier = Modifier.fillMaxSize(),
                 contentScale = ContentScale.Crop
             )
 
-            // Checkmark in corner - ONLY if selected
+            // Selected checkmark (only show when selected)
             if (isSelected) {
                 Surface(
                     modifier = Modifier
-                        .align(Alignment.TopEnd)
+                        .align(Alignment.Center),
-                        .padding(6.dp)
-                        .size(32.dp),
                     shape = CircleShape,
-                    color = MaterialTheme.colorScheme.primary,
+                    color = MaterialTheme.colorScheme.primary.copy(alpha = 0.9f)
-                    shadowElevation = 4.dp
                 ) {
                     Icon(
                         Icons.Default.CheckCircle,
                         contentDescription = "Selected",
                         modifier = Modifier
-                            .padding(6.dp)
+                            .padding(12.dp)
-                            .size(20.dp),
+                            .size(32.dp),
                         tint = MaterialTheme.colorScheme.onPrimary
                     )
                 }
             }
+
+            // Face number badge (always in top-right, small)
+            Surface(
+                modifier = Modifier
+                    .align(Alignment.TopEnd)
+                    .padding(4.dp),
+                shape = CircleShape,
+                color = if (isSelected)
+                    MaterialTheme.colorScheme.primary
+                else
+                    MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.9f),
+                shadowElevation = 2.dp
+            ) {
+                Text(
+                    text = "${index + 1}",
+                    modifier = Modifier.padding(6.dp),
+                    style = MaterialTheme.typography.labelSmall,
+                    fontWeight = FontWeight.Bold,
+                    color = if (isSelected)
+                        MaterialTheme.colorScheme.onPrimary
+                    else
+                        MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
         }
     }
 }
 
 /**
- * Load full resolution bitmap WITHOUT downsampling
+ * Helper function to load bitmap from URI
  */
-private suspend fun loadFullResolutionBitmap(
+private suspend fun loadBitmapFromUri(
     context: android.content.Context,
     uri: Uri
 ): Bitmap? = withContext(Dispatchers.IO) {
@@ -296,33 +417,7 @@ private suspend fun loadFullResolutionBitmap(
 }
 
 /**
- * Re-detect faces on full resolution bitmap to get accurate bounds
+ * Helper function to crop face from bitmap
- */
-private suspend fun detectFacesOnBitmap(bitmap: Bitmap): List<Rect> = withContext(Dispatchers.Default) {
-    try {
-        val options = FaceDetectorOptions.Builder()
-            .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
-            .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
-            .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
-            .setMinFaceSize(0.10f)
-            .build()
-
-        val detector = FaceDetection.getClient(options)
-        val image = InputImage.fromBitmap(bitmap, 0)
-        val faces = detector.process(image).await()
-
-        // Sort by size (largest first)
-        faces.sortedByDescending { face ->
-            face.boundingBox.width() * face.boundingBox.height()
-        }.map { it.boundingBox }
-
-    } catch (e: Exception) {
-        emptyList()
-    }
-}
-
-/**
- * Crop face from bitmap with padding
  */
 private fun cropFaceFromBitmap(bitmap: Bitmap, faceBounds: Rect): Bitmap {
     // Add 20% padding around the face

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

@@ -8,29 +8,19 @@ 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
 
 /**
- * FIXED FaceDetectionHelper with parallel processing
+ * Helper class for detecting faces in images using ML Kit Face Detection
- *
- * 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) // ACCURATE for quality
+        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
         .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
         .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
-        .setMinFaceSize(0.15f)
+        .setMinFaceSize(0.15f) // Detect faces that are at least 15% of image
         .build()
 
     private val detector = FaceDetection.getClient(faceDetectorOptions)
@@ -40,7 +30,7 @@ class FaceDetectionHelper(private val context: Context) {
         val hasFace: Boolean,
         val faceCount: Int,
         val faceBounds: List<Rect> = emptyList(),
-        val croppedFaceBitmap: Bitmap? = null, // Only largest face
+        val croppedFaceBitmap: Bitmap? = null,
         val errorMessage: String? = null
     )
 
@@ -48,12 +38,10 @@ class FaceDetectionHelper(private val context: Context) {
      * Detect faces in a single image
      */
     suspend fun detectFacesInImage(uri: Uri): FaceDetectionResult {
-        return withContext(Dispatchers.IO) {
+        return try {
-            var bitmap: Bitmap? = null
+            val bitmap = loadBitmap(uri)
-            try {
-                bitmap = loadBitmap(uri)
             if (bitmap == null) {
-                    return@withContext FaceDetectionResult(
+                return FaceDetectionResult(
                     uri = uri,
                     hasFace = false,
                     faceCount = 0,
@@ -64,14 +52,9 @@ class FaceDetectionHelper(private val context: Context) {
             val inputImage = InputImage.fromBitmap(bitmap, 0)
             val faces = detector.process(inputImage).await()
 
-                // Sort by face size (area) to get the largest face
+            val croppedFace = if (faces.isNotEmpty()) {
-                val sortedFaces = faces.sortedByDescending { face ->
+                // Crop the first detected face with some padding
-                    face.boundingBox.width() * face.boundingBox.height()
+                cropFaceFromBitmap(bitmap, faces[0].boundingBox)
-                }
-
-                val croppedFace = if (sortedFaces.isNotEmpty()) {
-                    // Crop the LARGEST detected face (most likely the subject)
-                    cropFaceFromBitmap(bitmap, sortedFaces[0].boundingBox)
             } else null
 
             FaceDetectionResult(
@@ -88,37 +71,15 @@ 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()
-            }
         }
     }
 
     /**
-     * PARALLEL face detection in multiple images - 10x FASTER!
+     * Detect faces in multiple images
-     *
-     * @param onProgress Callback with (current, total)
      */
-    suspend fun detectFacesInImages(
+    suspend fun detectFacesInImages(uris: List<Uri>): List<FaceDetectionResult> {
-        uris: List<Uri>,
+        return uris.map { uri ->
-        onProgress: ((Int, Int) -> Unit)? = null
+            detectFacesInImage(uri)
-    ): 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()
         }
     }
 
@@ -141,35 +102,13 @@ class FaceDetectionHelper(private val context: Context) {
     }
 
     /**
-     * Load bitmap from URI with downsampling for memory efficiency
+     * Load bitmap from URI
      */
     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

@@ -4,58 +4,45 @@ 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.rememberScrollState
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
 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.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.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import kotlinx.coroutines.launch
 
 /**
- * OPTIMIZED ImageSelectorScreen
+ * Enhanced ImageSelectorScreen
  *
- * 🎯 NEW FEATURE: Filter to only show face-tagged images!
+ * Changes:
- * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ * - NO LIMIT on photo count (was 10)
- * - Uses face detection cache to pre-filter
+ * - Recommends 20-30 photos
- * - Shows "Only photos with faces" toggle
+ * - Real-time progress feedback
- * - Dramatically faster photo selection
+ * - Quality indicators
- * - Better training quality (no manual filtering needed)
+ * - Training tips
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ImageSelectorScreen(
     onImagesSelected: (List<Uri>) -> Unit
 ) {
-    // Inject ImageDao via Hilt ViewModel pattern
-    val viewModel: ImageSelectorViewModel = hiltViewModel()
-    val faceTaggedUris by viewModel.faceTaggedImageUris.collectAsStateWithLifecycle()
-
     var selectedImages by remember { mutableStateOf<List<Uri>>(emptyList()) }
-    var onlyShowFaceImages by remember { mutableStateOf(true) }  // Default: smart filtering
-    val scrollState = rememberScrollState()
 
     val photoPicker = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.GetMultipleContents()
     ) { uris ->
         if (uris.isNotEmpty()) {
-            // Filter to only face-tagged images if toggle is on
+            selectedImages = uris
-            selectedImages = if (onlyShowFaceImages && faceTaggedUris.isNotEmpty()) {
-                uris.filter { it.toString() in faceTaggedUris }
-            } else {
-                uris
-            }
         }
     }
 
@@ -73,59 +60,10 @@ fun ImageSelectorScreen(
             modifier = Modifier
                 .fillMaxSize()
                 .padding(paddingValues)
-                .verticalScroll(scrollState)
                 .padding(16.dp),
             verticalArrangement = Arrangement.spacedBy(16.dp)
         ) {
 
-            // Smart filtering card
-            if (faceTaggedUris.isNotEmpty()) {
-                Card(
-                    modifier = Modifier.fillMaxWidth(),
-                    colors = CardDefaults.cardColors(
-                        containerColor = MaterialTheme.colorScheme.tertiaryContainer
-                    ),
-                    shape = RoundedCornerShape(16.dp)
-                ) {
-                    Row(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(16.dp),
-                        horizontalArrangement = Arrangement.SpaceBetween,
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Column(modifier = Modifier.weight(1f)) {
-                            Row(
-                                horizontalArrangement = Arrangement.spacedBy(8.dp),
-                                verticalAlignment = Alignment.CenterVertically
-                            ) {
-                                Icon(
-                                    Icons.Default.AutoFixHigh,
-                                    contentDescription = null,
-                                    tint = MaterialTheme.colorScheme.tertiary
-                                )
-                                Text(
-                                    "Smart Filtering",
-                                    style = MaterialTheme.typography.titleMedium,
-                                    fontWeight = FontWeight.Bold
-                                )
-                            }
-                            Spacer(Modifier.height(4.dp))
-                            Text(
-                                "Only show photos with detected faces (${faceTaggedUris.size} available)",
-                                style = MaterialTheme.typography.bodySmall,
-                                color = MaterialTheme.colorScheme.onTertiaryContainer.copy(alpha = 0.8f)
-                            )
-                        }
-
-                        Switch(
-                            checked = onlyShowFaceImages,
-                            onCheckedChange = { onlyShowFaceImages = it }
-                        )
-                    }
-                }
-            }
-
             // Gradient header with tips
             Card(
                 modifier = Modifier.fillMaxWidth(),
@@ -186,6 +124,8 @@ fun ImageSelectorScreen(
                 ProgressCard(selectedImages.size)
             }
 
+            Spacer(Modifier.weight(1f))
+
             // Select photos button
             Button(
                 onClick = { photoPicker.launch("image/*") },
@@ -260,9 +200,6 @@ fun ImageSelectorScreen(
                     }
                 }
             }
-
-            // Bottom spacing to ensure last item is visible
-            Spacer(Modifier.height(32.dp))
         }
     }
 }

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

@@ -1,42 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-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 javax.inject.Inject
-
-/**
- * ImageSelectorViewModel
- *
- * Provides face-tagged image URIs for smart filtering
- * during training photo selection
- */
-@HiltViewModel
-class ImageSelectorViewModel @Inject constructor(
-    private val imageDao: ImageDao
-) : ViewModel() {
-
-    private val _faceTaggedImageUris = MutableStateFlow<List<String>>(emptyList())
-    val faceTaggedImageUris: StateFlow<List<String>> = _faceTaggedImageUris.asStateFlow()
-
-    init {
-        loadFaceTaggedImages()
-    }
-
-    private fun loadFaceTaggedImages() {
-        viewModelScope.launch {
-            try {
-                val imagesWithFaces = imageDao.getImagesWithFaces()
-                _faceTaggedImageUris.value = imagesWithFaces.map { it.imageUri }
-            } catch (e: Exception) {
-                // If cache not available, just use empty list (filter disabled)
-                _faceTaggedImageUris.value = emptyList()
-            }
-        }
-    }
-}

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

@@ -1,231 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-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.text.font.FontWeight
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.Dialog
-
-/**
- * IMPROVED NameInputDialog - Better centered, cleaner layout
- *
- * Fixes:
- * - Centered dialog with proper constraints
- * - Better spacing and padding
- * - Clearer visual hierarchy
- * - Improved error state handling
- */
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun ImprovedNameInputDialog(
-    onDismiss: () -> Unit,
-    onConfirm: (String) -> Unit,
-    trainingState: TrainingState
-) {
-    var personName by remember { mutableStateOf("") }
-    val isError = trainingState is TrainingState.Error
-    val isProcessing = trainingState is TrainingState.Processing
-
-    Dialog(
-        onDismissRequest = {
-            if (!isProcessing) {
-                onDismiss()
-            }
-        }
-    ) {
-        Card(
-            modifier = Modifier
-                .fillMaxWidth(0.9f) // 90% of screen width
-                .wrapContentHeight(),
-            shape = RoundedCornerShape(24.dp),
-            colors = CardDefaults.cardColors(
-                containerColor = MaterialTheme.colorScheme.surface
-            ),
-            elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
-        ) {
-            Column(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(24.dp),
-                verticalArrangement = Arrangement.spacedBy(20.dp),
-                horizontalAlignment = Alignment.CenterHorizontally
-            ) {
-                // Icon
-                Surface(
-                    shape = RoundedCornerShape(16.dp),
-                    color = if (isError) {
-                        MaterialTheme.colorScheme.errorContainer
-                    } else {
-                        MaterialTheme.colorScheme.primaryContainer
-                    },
-                    modifier = Modifier.size(72.dp)
-                ) {
-                    Box(contentAlignment = Alignment.Center) {
-                        Icon(
-                            if (isError) Icons.Default.Warning else Icons.Default.Face,
-                            contentDescription = null,
-                            modifier = Modifier.size(40.dp),
-                            tint = if (isError) {
-                                MaterialTheme.colorScheme.error
-                            } else {
-                                MaterialTheme.colorScheme.primary
-                            }
-                        )
-                    }
-                }
-
-                // Title
-                Text(
-                    text = if (isError) "Training Error" else "Who is this?",
-                    style = MaterialTheme.typography.headlineSmall,
-                    fontWeight = FontWeight.Bold,
-                    color = MaterialTheme.colorScheme.onSurface
-                )
-
-                // Error message or description
-                if (isError) {
-                    val error = trainingState as TrainingState.Error
-                    Card(
-                        colors = CardDefaults.cardColors(
-                            containerColor = MaterialTheme.colorScheme.errorContainer
-                        ),
-                        shape = RoundedCornerShape(12.dp)
-                    ) {
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(16.dp),
-                            horizontalArrangement = Arrangement.spacedBy(12.dp),
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-                            Icon(
-                                Icons.Default.Error,
-                                contentDescription = null,
-                                tint = MaterialTheme.colorScheme.error
-                            )
-                            Text(
-                                text = error.message,
-                                style = MaterialTheme.typography.bodyMedium,
-                                color = MaterialTheme.colorScheme.onErrorContainer
-                            )
-                        }
-                    }
-                } else {
-                    Text(
-                        text = "Enter the name of the person in these training images. This will help you find their photos later.",
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-
-                // Name input field
-                OutlinedTextField(
-                    value = personName,
-                    onValueChange = { personName = it },
-                    label = { Text("Person's Name") },
-                    placeholder = { Text("e.g., John Doe") },
-                    singleLine = true,
-                    enabled = !isProcessing,
-                    keyboardOptions = KeyboardOptions(
-                        capitalization = KeyboardCapitalization.Words,
-                        imeAction = ImeAction.Done
-                    ),
-                    keyboardActions = KeyboardActions(
-                        onDone = {
-                            if (personName.isNotBlank() && !isProcessing) {
-                                onConfirm(personName.trim())
-                            }
-                        }
-                    ),
-                    modifier = Modifier.fillMaxWidth(),
-                    shape = RoundedCornerShape(12.dp),
-                    colors = OutlinedTextFieldDefaults.colors(
-                        focusedBorderColor = MaterialTheme.colorScheme.primary,
-                        unfocusedBorderColor = MaterialTheme.colorScheme.outline
-                    )
-                )
-
-                // Action buttons
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(12.dp)
-                ) {
-                    // Cancel button
-                    if (!isProcessing) {
-                        OutlinedButton(
-                            onClick = onDismiss,
-                            modifier = Modifier.weight(1f),
-                            shape = RoundedCornerShape(12.dp),
-                            contentPadding = PaddingValues(vertical = 14.dp)
-                        ) {
-                            Text("Cancel")
-                        }
-                    }
-
-                    // Confirm button
-                    Button(
-                        onClick = { onConfirm(personName.trim()) },
-                        enabled = personName.isNotBlank() && !isProcessing,
-                        modifier = Modifier.weight(if (isProcessing) 1f else 1f),
-                        shape = RoundedCornerShape(12.dp),
-                        contentPadding = PaddingValues(vertical = 14.dp),
-                        colors = ButtonDefaults.buttonColors(
-                            containerColor = if (isError) {
-                                MaterialTheme.colorScheme.error
-                            } else {
-                                MaterialTheme.colorScheme.primary
-                            }
-                        )
-                    ) {
-                        if (isProcessing) {
-                            CircularProgressIndicator(
-                                modifier = Modifier.size(20.dp),
-                                strokeWidth = 2.dp,
-                                color = MaterialTheme.colorScheme.onPrimary
-                            )
-                            Spacer(modifier = Modifier.width(12.dp))
-                            Text("Training...")
-                        } else {
-                            Icon(
-                                if (isError) Icons.Default.Refresh else Icons.Default.Check,
-                                contentDescription = null,
-                                modifier = Modifier.size(20.dp)
-                            )
-                            Spacer(modifier = Modifier.width(8.dp))
-                            Text(if (isError) "Try Again" else "Start Training")
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/**
- * Alternative: Use this version in ScanResultsScreen.kt
- *
- * Replace the existing NameInputDialog function (lines 154-257) with:
- *
- * @Composable
- * private fun NameInputDialog(
- *     onDismiss: () -> Unit,
- *     onConfirm: (String) -> Unit,
- *     trainingState: TrainingState
- * ) {
- *     ImprovedNameInputDialog(
- *         onDismiss = onDismiss,
- *         onConfirm = onConfirm,
- *         trainingState = trainingState
- *     )
- * }
- */

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

@@ -13,6 +13,8 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
 import androidx.compose.material3.*
@@ -24,12 +26,13 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.asImageBitmap
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import coil.compose.AsyncImage
 
-
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ScanResultsScreen(
@@ -38,23 +41,33 @@ fun ScanResultsScreen(
     trainViewModel: TrainViewModel = hiltViewModel()
 ) {
     var showFacePickerDialog by remember { mutableStateOf<FaceDetectionHelper.FaceDetectionResult?>(null) }
+    var showNameInputDialog by remember { mutableStateOf(false) }
+
+    // Observe training state
     val trainingState by trainViewModel.trainingState.collectAsState()
 
+    // Handle training state changes
     LaunchedEffect(trainingState) {
         when (trainingState) {
             is TrainingState.Success -> {
+                // Training completed successfully
+                val success = trainingState as TrainingState.Success
+                // You can show a success message or navigate away
+                // For now, we'll just reset and finish
                 trainViewModel.resetTrainingState()
                 onFinish()
             }
-            is TrainingState.Error -> {}
+            is TrainingState.Error -> {
-            else -> {}
+                // Error will be shown in dialog, no action needed here
+            }
+            else -> { /* Idle or Processing */ }
         }
     }
 
     Scaffold(
         topBar = {
             TopAppBar(
-                title = { Text("Train New Person") },
+                title = { Text("Training Image Analysis") },
                 colors = TopAppBarDefaults.topAppBarColors(
                     containerColor = MaterialTheme.colorScheme.primaryContainer
                 )
@@ -67,21 +80,23 @@ fun ScanResultsScreen(
                 .padding(paddingValues)
         ) {
             when (state) {
-                is ScanningState.Idle -> {}
+                is ScanningState.Idle -> {
+                    // Should not happen
+                }
 
                 is ScanningState.Processing -> {
-                    ProcessingView(progress = state.progress, total = state.total)
+                    ProcessingView(
+                        progress = state.progress,
+                        total = state.total
+                    )
                 }
 
                 is ScanningState.Success -> {
                     ImprovedResultsView(
                         result = state.sanityCheckResult,
                         onContinue = {
-                            // PersonInfo already captured in TrainingScreen!
+                            // Show name input dialog instead of immediately finishing
-                            // Just start training with stored info
+                            showNameInputDialog = true
-                            trainViewModel.createFaceModel(
-                                trainViewModel.getPersonInfo()?.name ?: "Unknown"
-                            )
                         },
                         onRetry = onFinish,
                         onReplaceImage = { oldUri, newUri ->
@@ -89,22 +104,26 @@ fun ScanResultsScreen(
                         },
                         onSelectFaceFromMultiple = { result ->
                             showFacePickerDialog = result
-                        },
+                        }
-                        trainViewModel = trainViewModel
                     )
                 }
 
                 is ScanningState.Error -> {
-                    ErrorView(message = state.message, onRetry = onFinish)
+                    ErrorView(
+                        message = state.message,
+                        onRetry = onFinish
+                    )
                 }
             }
 
+            // Show training overlay if processing
             if (trainingState is TrainingState.Processing) {
                 TrainingOverlay(trainingState = trainingState as TrainingState.Processing)
             }
         }
     }
 
+    // Face Picker Dialog
     showFacePickerDialog?.let { result ->
         FacePickerDialog(
             result = result,
@@ -115,32 +134,181 @@ fun ScanResultsScreen(
             }
         )
     }
+
+    // Name Input Dialog
+    if (showNameInputDialog) {
+        NameInputDialog(
+            onDismiss = { showNameInputDialog = false },
+            onConfirm = { name ->
+                showNameInputDialog = false
+                trainViewModel.createFaceModel(name)
+            },
+            trainingState = trainingState
+        )
+    }
 }
 
+/**
+ * Dialog for entering person's name before training
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun NameInputDialog(
+    onDismiss: () -> Unit,
+    onConfirm: (String) -> Unit,
+    trainingState: TrainingState
+) {
+    var personName by remember { mutableStateOf("") }
+    val isError = trainingState is TrainingState.Error
+
+    AlertDialog(
+        onDismissRequest = {
+            if (trainingState !is TrainingState.Processing) {
+                onDismiss()
+            }
+        },
+        title = {
+            Text(
+                text = if (isError) "Training Error" else "Who is this?",
+                style = MaterialTheme.typography.headlineSmall
+            )
+        },
+        text = {
+            Column(
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
+                if (isError) {
+                    // Show error message
+                    val error = trainingState as TrainingState.Error
+                    Surface(
+                        color = MaterialTheme.colorScheme.errorContainer,
+                        shape = RoundedCornerShape(8.dp)
+                    ) {
+                        Row(
+                            modifier = Modifier.padding(12.dp),
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                            verticalAlignment = Alignment.CenterVertically
+                        ) {
+                            Icon(
+                                Icons.Default.Warning,
+                                contentDescription = null,
+                                tint = MaterialTheme.colorScheme.error
+                            )
+                            Text(
+                                text = error.message,
+                                style = MaterialTheme.typography.bodyMedium,
+                                color = MaterialTheme.colorScheme.onErrorContainer
+                            )
+                        }
+                    }
+                } else {
+                    Text(
+                        text = "Enter the name of the person in these training images. This will help you find their photos later.",
+                        style = MaterialTheme.typography.bodyMedium
+                    )
+                }
+
+                OutlinedTextField(
+                    value = personName,
+                    onValueChange = { personName = it },
+                    label = { Text("Person's Name") },
+                    placeholder = { Text("e.g., John Doe") },
+                    singleLine = true,
+                    enabled = trainingState !is TrainingState.Processing,
+                    keyboardOptions = KeyboardOptions(
+                        capitalization = KeyboardCapitalization.Words,
+                        imeAction = ImeAction.Done
+                    ),
+                    keyboardActions = KeyboardActions(
+                        onDone = {
+                            if (personName.isNotBlank()) {
+                                onConfirm(personName.trim())
+                            }
+                        }
+                    ),
+                    modifier = Modifier.fillMaxWidth()
+                )
+            }
+        },
+        confirmButton = {
+            Button(
+                onClick = { onConfirm(personName.trim()) },
+                enabled = personName.isNotBlank() && trainingState !is TrainingState.Processing
+            ) {
+                if (trainingState is TrainingState.Processing) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(16.dp),
+                        strokeWidth = 2.dp,
+                        color = MaterialTheme.colorScheme.onPrimary
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                }
+                Text(if (isError) "Try Again" else "Start Training")
+            }
+        },
+        dismissButton = {
+            if (trainingState !is TrainingState.Processing) {
+                TextButton(onClick = onDismiss) {
+                    Text("Cancel")
+                }
+            }
+        }
+    )
+}
+
+/**
+ * Overlay shown during training process
+ */
 @Composable
 private fun TrainingOverlay(trainingState: TrainingState.Processing) {
     Box(
-        modifier = Modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.7f)),
+        modifier = Modifier
+            .fillMaxSize()
+            .background(Color.Black.copy(alpha = 0.7f)),
         contentAlignment = Alignment.Center
     ) {
         Card(
-            modifier = Modifier.padding(32.dp).fillMaxWidth(0.9f),
+            modifier = Modifier
-            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface)
+                .padding(32.dp)
+                .fillMaxWidth(0.9f),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.surface
+            )
         ) {
             Column(
                 modifier = Modifier.padding(24.dp),
                 horizontalAlignment = Alignment.CenterHorizontally,
                 verticalArrangement = Arrangement.spacedBy(16.dp)
             ) {
-                CircularProgressIndicator(modifier = Modifier.size(64.dp), strokeWidth = 6.dp)
+                CircularProgressIndicator(
-                Text("Creating Face Model", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
+                    modifier = Modifier.size(64.dp),
-                Text(trainingState.stage, style = MaterialTheme.typography.bodyMedium, textAlign = TextAlign.Center, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    strokeWidth = 6.dp
+                )
+
+                Text(
+                    text = "Creating Face Model",
+                    style = MaterialTheme.typography.titleLarge,
+                    fontWeight = FontWeight.Bold
+                )
+
+                Text(
+                    text = trainingState.stage,
+                    style = MaterialTheme.typography.bodyMedium,
+                    textAlign = TextAlign.Center,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+
                 if (trainingState.total > 0) {
                     LinearProgressIndicator(
                         progress = { (trainingState.progress.toFloat() / trainingState.total.toFloat()).coerceIn(0f, 1f) },
                         modifier = Modifier.fillMaxWidth()
                     )
-                    Text("${trainingState.progress} / ${trainingState.total}", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+
+                    Text(
+                        text = "${trainingState.progress} / ${trainingState.total}",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
                 }
             }
         }
@@ -154,18 +322,31 @@ private fun ProcessingView(progress: Int, total: Int) {
         horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.Center
     ) {
-        CircularProgressIndicator(modifier = Modifier.size(64.dp), strokeWidth = 6.dp)
+        CircularProgressIndicator(
+            modifier = Modifier.size(64.dp),
+            strokeWidth = 6.dp
+        )
         Spacer(modifier = Modifier.height(24.dp))
-        Text("Analyzing images...", style = MaterialTheme.typography.titleMedium)
+        Text(
+            text = "Analyzing images...",
+            style = MaterialTheme.typography.titleMedium
+        )
         Spacer(modifier = Modifier.height(8.dp))
-        Text("Detecting faces and checking for duplicates", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        Text(
+            text = "Detecting faces and checking for duplicates",
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
         if (total > 0) {
             Spacer(modifier = Modifier.height(16.dp))
             LinearProgressIndicator(
                 progress = { (progress.toFloat() / total.toFloat()).coerceIn(0f, 1f) },
                 modifier = Modifier.width(200.dp)
             )
-            Text("$progress / $total", style = MaterialTheme.typography.bodySmall)
+            Text(
+                text = "$progress / $total",
+                style = MaterialTheme.typography.bodySmall
+            )
         }
     }
 }
@@ -176,24 +357,32 @@ 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(),
         contentPadding = PaddingValues(16.dp),
         verticalArrangement = Arrangement.spacedBy(16.dp)
     ) {
+        // Welcome Header
         item {
             Card(
                 modifier = Modifier.fillMaxWidth(),
-                colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.secondaryContainer)
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.secondaryContainer
+                )
             ) {
-                Column(modifier = Modifier.padding(16.dp)) {
+                Column(
-                    Text("Analysis Complete!", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold)
+                    modifier = Modifier.padding(16.dp)
+                ) {
+                    Text(
+                        text = "Analysis Complete!",
+                        style = MaterialTheme.typography.headlineSmall,
+                        fontWeight = FontWeight.Bold
+                    )
                     Spacer(modifier = Modifier.height(4.dp))
                     Text(
-                        "Review your images below. Tap 'Pick Face' on group photos to choose which person to train on, or 'Replace' to swap out any image.",
+                        text = "Review your images below. Tap 'Pick Face' on group photos to choose which person to train on, or 'Replace' to swap out any image.",
                         style = MaterialTheme.typography.bodyMedium,
                         color = MaterialTheme.colorScheme.onSecondaryContainer.copy(alpha = 0.8f)
                     )
@@ -201,6 +390,7 @@ private fun ImprovedResultsView(
             }
         }
 
+        // Progress Summary
         item {
             ProgressSummaryCard(
                 totalImages = result.faceDetectionResults.size,
@@ -210,28 +400,38 @@ private fun ImprovedResultsView(
             )
         }
 
+        // Image List Header
         item {
-            Text("Your Images (${result.faceDetectionResults.size})", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
+            Text(
+                text = "Your Images (${result.faceDetectionResults.size})",
+                style = MaterialTheme.typography.titleLarge,
+                fontWeight = FontWeight.Bold
+            )
         }
 
+        // Image List with Actions
         itemsIndexed(result.faceDetectionResults) { index, imageResult ->
             ImageResultCard(
                 index = index + 1,
                 result = imageResult,
-                onReplace = { newUri -> onReplaceImage(imageResult.uri, newUri) },
+                onReplace = { newUri ->
-                onSelectFace = if (imageResult.faceCount > 1) { { onSelectFaceFromMultiple(imageResult) } } else null,
+                    onReplaceImage(imageResult.uri, newUri)
-                trainViewModel = trainViewModel,
+                },
-                isExcluded = trainViewModel.isImageExcluded(imageResult.uri)
+                onSelectFace = if (imageResult.faceCount > 1) {
+                    { onSelectFaceFromMultiple(imageResult) }
+                } else null
             )
         }
 
+        // Validation Issues (if any)
         if (result.validationErrors.isNotEmpty()) {
             item {
                 Spacer(modifier = Modifier.height(8.dp))
-                ValidationIssuesCard(errors = result.validationErrors, trainViewModel = trainViewModel)
+                ValidationIssuesCard(errors = result.validationErrors)
             }
         }
 
+        // Action Button
         item {
             Spacer(modifier = Modifier.height(8.dp))
             Button(
@@ -239,10 +439,16 @@ private fun ImprovedResultsView(
                 modifier = Modifier.fillMaxWidth(),
                 enabled = result.isValid,
                 colors = ButtonDefaults.buttonColors(
-                    containerColor = if (result.isValid) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error.copy(alpha = 0.5f)
+                    containerColor = if (result.isValid)
+                        MaterialTheme.colorScheme.primary
+                    else
+                        MaterialTheme.colorScheme.error.copy(alpha = 0.5f)
                 )
             ) {
-                Icon(if (result.isValid) Icons.Default.CheckCircle else Icons.Default.Warning, contentDescription = null)
+                Icon(
+                    if (result.isValid) Icons.Default.CheckCircle else Icons.Default.Warning,
+                    contentDescription = null
+                )
                 Spacer(modifier = Modifier.width(8.dp))
                 Text(
                     if (result.isValid)
@@ -259,11 +465,19 @@ private fun ImprovedResultsView(
                     color = MaterialTheme.colorScheme.tertiaryContainer,
                     shape = RoundedCornerShape(8.dp)
                 ) {
-                    Row(modifier = Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
+                    Row(
-                        Icon(Icons.Default.Info, contentDescription = null, tint = MaterialTheme.colorScheme.onTertiaryContainer, modifier = Modifier.size(20.dp))
+                        modifier = Modifier.padding(12.dp),
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Icon(
+                            Icons.Default.Info,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.onTertiaryContainer,
+                            modifier = Modifier.size(20.dp)
+                        )
                         Spacer(modifier = Modifier.width(8.dp))
                         Text(
-                            "Tip: Use 'Replace' to swap problematic images, or 'Pick Face' to choose from group photos",
+                            text = "Tip: Use 'Replace' to swap problematic images, or 'Pick Face' to choose from group photos",
                             style = MaterialTheme.typography.bodySmall,
                             color = MaterialTheme.colorScheme.onTertiaryContainer
                         )
@@ -275,30 +489,74 @@ private fun ImprovedResultsView(
 }
 
 @Composable
-private fun ProgressSummaryCard(totalImages: Int, validImages: Int, requiredImages: Int, isValid: Boolean) {
+private fun ProgressSummaryCard(
+    totalImages: Int,
+    validImages: Int,
+    requiredImages: Int,
+    isValid: Boolean
+) {
     Card(
         modifier = Modifier.fillMaxWidth(),
         colors = CardDefaults.cardColors(
-            containerColor = if (isValid) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f) else MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
+            containerColor = if (isValid)
+                MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f)
+            else
+                MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
         )
     ) {
-        Column(modifier = Modifier.padding(16.dp)) {
+        Column(
-            Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
+            modifier = Modifier.padding(16.dp)
-                Text("Progress", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = "Progress",
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold
+                )
+
                 Icon(
                     imageVector = if (isValid) Icons.Default.CheckCircle else Icons.Default.Warning,
                     contentDescription = null,
-                    tint = if (isValid) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error,
+                    tint = if (isValid)
+                        MaterialTheme.colorScheme.primary
+                    else
+                        MaterialTheme.colorScheme.error,
                     modifier = Modifier.size(32.dp)
                 )
             }
+
             Spacer(modifier = Modifier.height(12.dp))
-            Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceEvenly) {
+
-                StatItem("Total", totalImages.toString(), MaterialTheme.colorScheme.onSurface)
+            Row(
-                StatItem("Valid", validImages.toString(), if (validImages >= requiredImages) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error)
+                modifier = Modifier.fillMaxWidth(),
-                StatItem("Need", requiredImages.toString(), MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f))
+                horizontalArrangement = Arrangement.SpaceEvenly
+            ) {
+                StatItem(
+                    label = "Total",
+                    value = totalImages.toString(),
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+                StatItem(
+                    label = "Valid",
+                    value = validImages.toString(),
+                    color = if (validImages >= requiredImages)
+                        MaterialTheme.colorScheme.primary
+                    else
+                        MaterialTheme.colorScheme.error
+                )
+                StatItem(
+                    label = "Need",
+                    value = requiredImages.toString(),
+                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
+                )
             }
+
             Spacer(modifier = Modifier.height(12.dp))
+
             LinearProgressIndicator(
                 progress = { (validImages.toFloat() / requiredImages.toFloat()).coerceIn(0f, 1f) },
                 modifier = Modifier.fillMaxWidth(),
@@ -311,8 +569,17 @@ private fun ProgressSummaryCard(totalImages: Int, validImages: Int, requiredImag
 @Composable
 private fun StatItem(label: String, value: String, color: Color) {
     Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        Text(value, style = MaterialTheme.typography.headlineMedium, fontWeight = FontWeight.Bold, color = color)
+        Text(
-        Text(label, style = MaterialTheme.typography.bodySmall, color = color.copy(alpha = 0.7f))
+            text = value,
+            style = MaterialTheme.typography.headlineMedium,
+            fontWeight = FontWeight.Bold,
+            color = color
+        )
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = color.copy(alpha = 0.7f)
+        )
     }
 }
 
@@ -321,14 +588,15 @@ 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()) { uri -> uri?.let { onReplace(it) } }
+    val photoPickerLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.PickVisualMedia()
+    ) { uri ->
+        uri?.let { onReplace(it) }
+    }
 
     val status = when {
-        isExcluded -> ImageStatus.EXCLUDED
         result.errorMessage != null -> ImageStatus.ERROR
         !result.hasFace -> ImageStatus.NO_FACE
         result.faceCount > 1 -> ImageStatus.MULTIPLE_FACES
@@ -342,60 +610,86 @@ 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)
             }
         )
     ) {
-        Row(modifier = Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            // Image Number Badge
             Box(
-                modifier = Modifier.size(40.dp).background(
+                modifier = Modifier
+                    .size(40.dp)
+                    .background(
                         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
                     ),
                 contentAlignment = Alignment.Center
             ) {
-                Text(index.toString(), style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold, color = Color.White)
+                Text(
+                    text = index.toString(),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold,
+                    color = Color.White
+                )
             }
 
+            // Thumbnail
             if (result.croppedFaceBitmap != null) {
                 Image(
                     bitmap = result.croppedFaceBitmap.asImageBitmap(),
                     contentDescription = "Face",
-                    modifier = Modifier.size(64.dp).clip(RoundedCornerShape(8.dp)).border(
+                    modifier = Modifier
-                        BorderStroke(2.dp, when (status) {
+                        .size(64.dp)
+                        .clip(RoundedCornerShape(8.dp))
+                        .border(
+                            BorderStroke(
+                                2.dp,
+                                when (status) {
                                     ImageStatus.VALID -> MaterialTheme.colorScheme.primary
                                     ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
-                            ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.outline
                                     else -> MaterialTheme.colorScheme.error
-                        }),
+                                }
+                            ),
                             RoundedCornerShape(8.dp)
                         ),
                     contentScale = ContentScale.Crop
                 )
             } else {
-                AsyncImage(model = result.uri, contentDescription = "Original image", modifier = Modifier.size(64.dp).clip(RoundedCornerShape(8.dp)), contentScale = ContentScale.Crop)
+                AsyncImage(
+                    model = result.uri,
+                    contentDescription = "Original image",
+                    modifier = Modifier
+                        .size(64.dp)
+                        .clip(RoundedCornerShape(8.dp)),
+                    contentScale = ContentScale.Crop
+                )
             }
 
-            Column(modifier = Modifier.weight(1f)) {
+            // Status and Info
+            Column(
+                modifier = Modifier.weight(1f)
+            ) {
                 Row(verticalAlignment = Alignment.CenterVertically) {
                     Icon(
                         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)
@@ -406,72 +700,95 @@ 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,
                         fontWeight = FontWeight.SemiBold
                     )
                 }
-                Text(result.uri.lastPathSegment ?: "Unknown", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1)
+
+                Text(
+                    text = result.uri.lastPathSegment ?: "Unknown",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1
+                )
             }
 
-            Column(horizontalAlignment = Alignment.End, verticalArrangement = Arrangement.spacedBy(4.dp)) {
+            // Action Buttons
-                if (onSelectFace != null && !isExcluded) {
+            Column(
+                horizontalAlignment = Alignment.End,
+                verticalArrangement = Arrangement.spacedBy(4.dp)
+            ) {
+                // Select Face button (for multiple faces)
+                if (onSelectFace != null) {
                     OutlinedButton(
                         onClick = onSelectFace,
                         modifier = Modifier.height(32.dp),
                         contentPadding = PaddingValues(horizontal = 12.dp, vertical = 0.dp),
-                        colors = ButtonDefaults.outlinedButtonColors(contentColor = MaterialTheme.colorScheme.tertiary),
+                        colors = ButtonDefaults.outlinedButtonColors(
+                            contentColor = MaterialTheme.colorScheme.tertiary
+                        ),
                         border = BorderStroke(1.dp, MaterialTheme.colorScheme.tertiary)
                     ) {
-                        Icon(Icons.Default.Face, contentDescription = null, modifier = Modifier.size(16.dp))
+                        Icon(
+                            Icons.Default.Face,
+                            contentDescription = null,
+                            modifier = Modifier.size(16.dp)
+                        )
                         Spacer(modifier = Modifier.width(4.dp))
                         Text("Pick Face", style = MaterialTheme.typography.bodySmall)
                     }
                 }
 
-                if (!isExcluded) {
+                // Replace button
                 OutlinedButton(
-                        onClick = { photoPickerLauncher.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly)) },
+                    onClick = {
+                        photoPickerLauncher.launch(
+                            PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly)
+                        )
+                    },
                     modifier = Modifier.height(32.dp),
                     contentPadding = PaddingValues(horizontal = 12.dp, vertical = 0.dp)
                 ) {
-                        Icon(Icons.Default.Refresh, contentDescription = null, modifier = Modifier.size(16.dp))
+                    Icon(
+                        Icons.Default.Refresh,
+                        contentDescription = null,
+                        modifier = Modifier.size(16.dp)
+                    )
                     Spacer(modifier = Modifier.width(4.dp))
                     Text("Replace", style = MaterialTheme.typography.bodySmall)
                 }
             }
-
-                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)
-                }
-            }
         }
     }
 }
 
 @Composable
-private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationError>, trainViewModel: TrainViewModel) {
+private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationError>) {
     Card(
         modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f))
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
+        )
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp)
         ) {
-        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                Icon(Icons.Default.Warning, contentDescription = null, tint = MaterialTheme.colorScheme.error)
+                Icon(
+                    Icons.Default.Warning,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.error
+                )
                 Spacer(modifier = Modifier.width(8.dp))
-                Text("Issues Found (${errors.size})", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold, color = MaterialTheme.colorScheme.error)
+                Text(
+                    text = "Issues Found (${errors.size})",
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold,
+                    color = MaterialTheme.colorScheme.error
+                )
             }
 
             HorizontalDivider(color = MaterialTheme.colorScheme.error.copy(alpha = 0.3f))
@@ -479,41 +796,35 @@ private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationEr
             errors.forEach { error ->
                 when (error) {
                     is TrainingSanityChecker.ValidationError.NoFaceDetected -> {
-                        Text("• ${error.uris.size} image(s) without detected faces - use Replace button", style = MaterialTheme.typography.bodyMedium)
+                        Text(
+                            text = "• ${error.uris.size} image(s) without detected faces - use Replace button",
+                            style = MaterialTheme.typography.bodyMedium
+                        )
                     }
                     is TrainingSanityChecker.ValidationError.MultipleFacesDetected -> {
-                        Text("• ${error.uri.lastPathSegment} has ${error.faceCount} faces - use Pick Face button", style = MaterialTheme.typography.bodyMedium)
+                        Text(
+                            text = "• ${error.uri.lastPathSegment} has ${error.faceCount} faces - use Pick Face button",
+                            style = MaterialTheme.typography.bodyMedium
+                        )
                     }
                     is TrainingSanityChecker.ValidationError.DuplicateImages -> {
-                        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        Text(
-                            Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
+                            text = "• ${error.groups.size} duplicate image group(s) - replace duplicates",
-                                Text("• ${error.groups.size} duplicate group(s) found", style = MaterialTheme.typography.bodyMedium, modifier = Modifier.weight(1f))
+                            style = MaterialTheme.typography.bodyMedium
-
+                        )
-                                Button(
-                                    onClick = {
-                                        error.groups.forEach { group ->
-                                            group.images.drop(1).forEach { uri ->
-                                                trainViewModel.excludeImage(uri)
-                                            }
-                                        }
-                                    },
-                                    colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.tertiary),
-                                    modifier = Modifier.height(36.dp)
-                                ) {
-                                    Icon(Icons.Default.DeleteSweep, contentDescription = null, modifier = Modifier.size(16.dp))
-                                    Spacer(Modifier.width(4.dp))
-                                    Text("Drop All", style = MaterialTheme.typography.labelMedium)
-                                }
-                            }
-
-                            Text("${error.groups.sumOf { it.images.size - 1 }} duplicate images will be excluded", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f))
-                        }
                     }
                     is TrainingSanityChecker.ValidationError.InsufficientImages -> {
-                        Text("• Need ${error.required} valid images, currently have ${error.available}", style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.Bold)
+                        Text(
+                            text = "• Need ${error.required} valid images, currently have ${error.available}",
+                            style = MaterialTheme.typography.bodyMedium,
+                            fontWeight = FontWeight.Bold
+                        )
                     }
                     is TrainingSanityChecker.ValidationError.ImageLoadError -> {
-                        Text("• Failed to load ${error.uri.lastPathSegment} - use Replace button", style = MaterialTheme.typography.bodyMedium)
+                        Text(
+                            text = "• Failed to load ${error.uri.lastPathSegment} - use Replace button",
+                            style = MaterialTheme.typography.bodyMedium
+                        )
                     }
                 }
             }
@@ -522,13 +833,35 @@ private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationEr
 }
 
 @Composable
-private fun ErrorView(message: String, onRetry: () -> Unit) {
+private fun ErrorView(
-    Column(modifier = Modifier.fillMaxSize().padding(16.dp), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.Center) {
+    message: String,
-        Icon(imageVector = Icons.Default.Close, contentDescription = null, modifier = Modifier.size(64.dp), tint = MaterialTheme.colorScheme.error)
+    onRetry: () -> Unit
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(16.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center
+    ) {
+        Icon(
+            imageVector = Icons.Default.Close,
+            contentDescription = null,
+            modifier = Modifier.size(64.dp),
+            tint = MaterialTheme.colorScheme.error
+        )
         Spacer(modifier = Modifier.height(16.dp))
-        Text("Error", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
+        Text(
+            text = "Error",
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold
+        )
         Spacer(modifier = Modifier.height(8.dp))
-        Text(message, style = MaterialTheme.typography.bodyMedium, textAlign = TextAlign.Center)
+        Text(
+            text = message,
+            style = MaterialTheme.typography.bodyMedium,
+            textAlign = TextAlign.Center
+        )
         Spacer(modifier = Modifier.height(24.dp))
         Button(onClick = onRetry) {
             Icon(Icons.Default.Refresh, contentDescription = null)
@@ -542,6 +875,5 @@ private enum class ImageStatus {
     VALID,
     MULTIPLE_FACES,
     NO_FACE,
-    ERROR,
+    ERROR
-    EXCLUDED
 }

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

@@ -44,9 +44,6 @@ data class PersonInfo(
     val relationship: String
 )
 
-/**
- * FIXED TrainViewModel with proper exclude functionality and efficient replace
- */
 @HiltViewModel
 class TrainViewModel @Inject constructor(
     application: Application,
@@ -69,9 +66,6 @@ class TrainViewModel @Inject constructor(
     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
@@ -84,44 +78,6 @@ class TrainViewModel @Inject constructor(
         personInfo = PersonInfo(name, dateOfBirth, relationship)
     }
 
-    /**
-     * Get stored person info
-     */
-    fun getPersonInfo(): PersonInfo? = personInfo
-
-    /**
-     * 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
      */
@@ -133,7 +89,7 @@ class TrainViewModel @Inject constructor(
         }
 
         val validImages = currentState.sanityCheckResult.validImagesWithFaces
-        if (validImages.size < 15) {
+        if (validImages.size < 15) {  // Updated minimum
             _trainingState.value = TrainingState.Error(
                 "Need at least 15 valid images, have ${validImages.size}"
             )
@@ -148,14 +104,16 @@ class TrainViewModel @Inject constructor(
                     total = validImages.size
                 )
 
+                // Create person with captured info
                 val person = PersonEntity.create(
                     name = personName,
                     dateOfBirth = personInfo?.dateOfBirth,
                     relationship = personInfo?.relationship
                 )
 
+                // Create person with face model
                 val personId = faceRecognitionRepository.createPersonWithFaceModel(
-                    person = person,
+                    person = person,  // Pass full PersonEntity now
                     validImages = validImages,
                     onProgress = { current, total ->
                         _trainingState.value = TrainingState.Processing(
@@ -187,61 +145,25 @@ class TrainViewModel @Inject constructor(
     fun scanAndTagFaces(imageUris: List<Uri>) {
         currentImageUris = imageUris
         manualFaceSelections.clear()
-        excludedImages.clear()
         performScan(imageUris)
     }
 
-    /**
-     * 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
-
-                // Clean up old selections/exclusions
                 manualFaceSelections.remove(oldUri)
-                excludedImages.remove(oldUri)
+                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"
-                )
             }
         }
     }
 
-    /**
-     * 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
 
         val currentState = _uiState.value
         if (currentState is ScanningState.Success) {
@@ -250,9 +172,6 @@ class TrainViewModel @Inject constructor(
         }
     }
 
-    /**
-     * Perform full scan with exclusions and progress tracking
-     */
     private fun performScan(imageUris: List<Uri>) {
         viewModelScope.launch {
             try {
@@ -260,13 +179,9 @@ class TrainViewModel @Inject constructor(
 
                 val result = sanityChecker.performSanityChecks(
                     imageUris = imageUris,
-                    minImagesRequired = 15,
+                    minImagesRequired = 15,  // Updated minimum
                     allowMultipleFaces = true,
-                    duplicateSimilarityThreshold = 0.95,
+                    duplicateSimilarityThreshold = 0.95
-                    excludedImages = excludedImages,
-                    onProgress = { stage, current, total ->
-                        _uiState.value = ScanningState.Processing(current, total)
-                    }
                 )
 
                 val finalResult = applyManualSelections(result)
@@ -280,14 +195,11 @@ class TrainViewModel @Inject constructor(
         }
     }
 
-    /**
-     * Apply manual selections with exclusion filtering
-     */
     private fun applyManualSelections(
         result: TrainingSanityChecker.SanityCheckResult
     ): TrainingSanityChecker.SanityCheckResult {
 
-        if (manualFaceSelections.isEmpty() && excludedImages.isEmpty()) {
+        if (manualFaceSelections.isEmpty()) {
             return result
         }
 
@@ -304,36 +216,26 @@ class TrainViewModel @Inject constructor(
         }
 
         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 }
-            .map { faceResult ->
+            .map { result ->
                 TrainingSanityChecker.ValidTrainingImage(
-                    uri = faceResult.uri,
+                    uri = result.uri,
-                    croppedFaceBitmap = faceResult.croppedFaceBitmap!!,
+                    croppedFaceBitmap = result.croppedFaceBitmap!!,
-                    faceCount = faceResult.faceCount
+                    faceCount = result.faceCount
                 )
             }
 
         val updatedErrors = result.validationErrors.toMutableList()
 
-        // Remove errors for manually selected faces or excluded images
         updatedErrors.removeAll { error ->
-            when (error) {
+            error is TrainingSanityChecker.ValidationError.MultipleFacesDetected &&
-                is TrainingSanityChecker.ValidationError.MultipleFacesDetected ->
+                    manualFaceSelections.containsKey(error.uri)
-                    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
-            }
         }
 
-        // Update insufficient images error
+        if (updatedValidImages.size < 15) {  // Updated minimum
-        if (updatedValidImages.size < 15) {
             if (updatedErrors.none { it is TrainingSanityChecker.ValidationError.InsufficientImages }) {
                 updatedErrors.add(
                     TrainingSanityChecker.ValidationError.InsufficientImages(
@@ -352,8 +254,7 @@ class TrainViewModel @Inject constructor(
             isValid = isValid,
             faceDetectionResults = updatedFaceResults,
             validationErrors = updatedErrors,
-            validImagesWithFaces = updatedValidImages,
+            validImagesWithFaces = updatedValidImages
-            excludedImages = excludedImages
         )
     }
 
@@ -366,7 +267,6 @@ class TrainViewModel @Inject constructor(
         _trainingState.value = TrainingState.Idle
         currentImageUris = emptyList()
         manualFaceSelections.clear()
-        excludedImages.clear()
         personInfo = null
     }
 
@@ -403,8 +303,7 @@ private fun TrainingSanityChecker.SanityCheckResult.copy(
     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,
@@ -412,7 +311,6 @@ 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,5 +1,6 @@
 package com.placeholder.sherpai2.ui.trainingprep
 
+import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
@@ -12,58 +13,97 @@ 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.text.style.TextAlign
 import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+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,
-    modifier: Modifier = Modifier,
+    modifier: Modifier = Modifier
-    trainViewModel: TrainViewModel = hiltViewModel()
 ) {
     var showInfoDialog by remember { mutableStateOf(false) }
 
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text("Train New Person") },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.primaryContainer
+                )
+            )
+        }
+    ) { paddingValues ->
         Column(
             modifier = modifier
                 .fillMaxSize()
+                .padding(paddingValues)
                 .verticalScroll(rememberScrollState())
                 .padding(20.dp),
             verticalArrangement = Arrangement.spacedBy(20.dp)
         ) {
-        // ✅ TIGHTENED Hero section
-        CompactHeroCard()
 
+            // Hero section with gradient
+            HeroCard()
+
+            // How it works section
             HowItWorksSection()
 
+            // Requirements section
             RequirementsCard()
 
             Spacer(Modifier.weight(1f))
 
-        // Main CTA
+            // Main CTA button
             Button(
                 onClick = { showInfoDialog = true },
-            modifier = Modifier.fillMaxWidth().height(60.dp),
+                modifier = Modifier
-            colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.primary),
+                    .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))
+                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)
+                Text(
+                    "Start Training",
+                    style = MaterialTheme.typography.titleLarge,
+                    fontWeight = FontWeight.Bold
+                )
             }
 
             Spacer(Modifier.height(8.dp))
         }
+    }
 
-    // ✅ PersonInfo dialog BEFORE photo selection (CORRECT!)
+    // Person info dialog
     if (showInfoDialog) {
-        BeautifulPersonInfoDialog(
+        PersonInfoDialog(
             onDismiss = { showInfoDialog = false },
             onConfirm = { name, dob, relationship ->
                 showInfoDialog = false
-                trainViewModel.setPersonInfo(name, dob, relationship)
+                // TODO: Store this info before photo selection
+                // For now, just proceed to photo selection
                 onSelectImages()
             }
         )
@@ -71,54 +111,58 @@ fun TrainingScreen(
 }
 
 @Composable
-private fun CompactHeroCard() {
+private fun HeroCard() {
     Card(
         modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primaryContainer),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.primaryContainer
+        ),
         shape = RoundedCornerShape(20.dp)
     ) {
-        Row(
+        Box(
             modifier = Modifier
                 .fillMaxWidth()
                 .background(
-                    Brush.horizontalGradient(
+                    Brush.verticalGradient(
                         colors = listOf(
                             MaterialTheme.colorScheme.primaryContainer,
                             MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.7f)
                         )
                     )
                 )
-                .padding(20.dp),
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-            verticalAlignment = Alignment.CenterVertically
         ) {
-            // Compact icon
+            Column(
+                modifier = Modifier.padding(24.dp),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
                 Surface(
-                shape = RoundedCornerShape(16.dp),
+                    shape = RoundedCornerShape(20.dp),
                     color = MaterialTheme.colorScheme.primary,
-                shadowElevation = 6.dp,
+                    shadowElevation = 8.dp,
-                modifier = Modifier.size(56.dp)
+                    modifier = Modifier.size(80.dp)
                 ) {
                     Box(contentAlignment = Alignment.Center) {
                         Icon(
                             Icons.Default.Face,
                             contentDescription = null,
-                        modifier = Modifier.size(32.dp),
+                            modifier = Modifier.size(48.dp),
                             tint = MaterialTheme.colorScheme.onPrimary
                         )
                     }
                 }
 
-            // Text inline
-            Column(modifier = Modifier.weight(1f)) {
                 Text(
-                    "Face Recognition",
+                    "Face Recognition Training",
-                    style = MaterialTheme.typography.titleLarge,
+                    style = MaterialTheme.typography.headlineMedium,
-                    fontWeight = FontWeight.Bold
+                    fontWeight = FontWeight.Bold,
+                    textAlign = TextAlign.Center
                 )
+
                 Text(
-                    "Train AI to find someone in your photos",
+                    "Train the AI to recognize someone in your photos",
-                    style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyLarge,
+                    textAlign = TextAlign.Center,
                     color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
                 )
             }
@@ -129,43 +173,100 @@ private fun CompactHeroCard() {
 @Composable
 private fun HowItWorksSection() {
     Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
-        Text("How It Works", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
+        Text(
+            "How It Works",
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold
+        )
 
-        StepCard(1, Icons.Default.Info, "Enter Person Details", "Name, birthday, and relationship")
+        StepCard(
-        StepCard(2, Icons.Default.PhotoLibrary, "Select Training Photos", "Choose 20-30 photos of the person")
+            number = 1,
-        StepCard(3, Icons.Default.SmartToy, "AI Training", "We'll create a recognition model")
+            icon = Icons.Default.Info,
-        StepCard(4, Icons.Default.AutoFixHigh, "Auto-Tag Photos", "Find this person across your library")
+            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: ImageVector, title: String, description: String) {
+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.copy(alpha = 0.5f)),
+        colors = CardDefaults.cardColors(
-        shape = RoundedCornerShape(16.dp)
+            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(
-                modifier = Modifier.size(48.dp),
                 shape = RoundedCornerShape(12.dp),
-                color = MaterialTheme.colorScheme.primary
+                color = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(48.dp)
             ) {
                 Box(contentAlignment = Alignment.Center) {
-                    Text("$number", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold, color = MaterialTheme.colorScheme.onPrimary)
+                    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) {
+                Row(
-                    Icon(icon, contentDescription = null, modifier = Modifier.size(20.dp), tint = MaterialTheme.colorScheme.primary)
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
-                    Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)
+                    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
+                    )
                 }
-                Text(description, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                Spacer(Modifier.height(4.dp))
+                Text(
+                    description,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
             }
         }
     }
@@ -175,31 +276,241 @@ private fun StepCard(number: Int, icon: ImageVector, title: String, description:
 private fun RequirementsCard() {
     Card(
         modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.3f)),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.secondaryContainer
+        ),
         shape = RoundedCornerShape(16.dp)
     ) {
-        Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+        Column(
-            Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {
+            modifier = Modifier.padding(20.dp),
-                Icon(Icons.Default.CheckCircle, contentDescription = null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(24.dp))
+            verticalArrangement = Arrangement.spacedBy(12.dp)
-                Text("Best Results", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
+        ) {
+            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(Icons.Default.PhotoCamera, "20-30 photos minimum")
+            RequirementItem("20-30 photos of the person", true)
-            RequirementItem(Icons.Default.Face, "Clear, well-lit face photos")
+            RequirementItem("Different angles and lighting", true)
-            RequirementItem(Icons.Default.Diversity1, "Variety of angles & expressions")
+            RequirementItem("Clear face visibility", true)
-            RequirementItem(Icons.Default.HighQuality, "Good quality images")
+            RequirementItem("Mix of expressions", true)
+            RequirementItem("2-3 minutes of your time", true)
         }
     }
 }
 
 @Composable
-private fun RequirementItem(icon: ImageVector, text: String) {
+private fun RequirementItem(text: String, isMet: Boolean) {
     Row(
-        horizontalArrangement = Arrangement.spacedBy(12.dp),
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
-        verticalAlignment = Alignment.CenterVertically,
+        verticalAlignment = Alignment.CenterVertically
-        modifier = Modifier.padding(vertical = 4.dp)
     ) {
-        Icon(icon, contentDescription = null, modifier = Modifier.size(20.dp), tint = MaterialTheme.colorScheme.onSecondaryContainer)
+        Icon(
-        Text(text, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSecondaryContainer)
+            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/Trainingphotoselectorscreen.kt

@@ -1,353 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.foundation.BorderStroke
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.background
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.grid.*
-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.Color
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import coil.compose.AsyncImage
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-
-/**
- * TrainingPhotoSelectorScreen - Smart photo selector for face training
- *
- * SOLVES THE PROBLEM:
- * - User has 10,000 photos total
- * - Only ~500 have faces (hasFaces=true)
- * - Shows ONLY photos with faces
- * - Multi-select mode for quick selection
- * - Face count badges on each photo
- * - Minimum 15 photos enforced
- *
- * REUSES:
- * - Existing ImageDao.getImagesWithFaces()
- * - Existing face detection cache
- * - Proven album grid layout
- */
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
-@Composable
-fun TrainingPhotoSelectorScreen(
-    onBack: () -> Unit,
-    onPhotosSelected: (List<android.net.Uri>) -> Unit,
-    viewModel: TrainingPhotoSelectorViewModel = hiltViewModel()
-) {
-    val photos by viewModel.photosWithFaces.collectAsStateWithLifecycle()
-    val selectedPhotos by viewModel.selectedPhotos.collectAsStateWithLifecycle()
-    val isLoading by viewModel.isLoading.collectAsStateWithLifecycle()
-
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = {
-                    Column {
-                        Text(
-                            if (selectedPhotos.isEmpty()) {
-                                "Select Training Photos"
-                            } else {
-                                "${selectedPhotos.size} selected"
-                            },
-                            style = MaterialTheme.typography.titleLarge,
-                            fontWeight = FontWeight.Bold
-                        )
-                        Text(
-                            "Showing ${photos.size} photos with faces",
-                            style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
-                        )
-                    }
-                },
-                navigationIcon = {
-                    IconButton(onClick = onBack) {
-                        Icon(Icons.Default.ArrowBack, "Back")
-                    }
-                },
-                actions = {
-                    if (selectedPhotos.isNotEmpty()) {
-                        TextButton(onClick = { viewModel.clearSelection() }) {
-                            Text("Clear")
-                        }
-                    }
-                },
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.primaryContainer
-                )
-            )
-        },
-        bottomBar = {
-            AnimatedVisibility(visible = selectedPhotos.isNotEmpty()) {
-                SelectionBottomBar(
-                    selectedCount = selectedPhotos.size,
-                    onClear = { viewModel.clearSelection() },
-                    onContinue = {
-                        val uris = selectedPhotos.map { android.net.Uri.parse(it.imageUri) }
-                        onPhotosSelected(uris)
-                    }
-                )
-            }
-        }
-    ) { paddingValues ->
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(paddingValues)
-        ) {
-            when {
-                isLoading -> {
-                    Box(
-                        modifier = Modifier.fillMaxSize(),
-                        contentAlignment = Alignment.Center
-                    ) {
-                        CircularProgressIndicator()
-                    }
-                }
-                photos.isEmpty() -> {
-                    EmptyState(onBack)
-                }
-                else -> {
-                    PhotoGrid(
-                        photos = photos,
-                        selectedPhotos = selectedPhotos,
-                        onPhotoClick = { photo -> viewModel.toggleSelection(photo) }
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun SelectionBottomBar(
-    selectedCount: Int,
-    onClear: () -> Unit,
-    onContinue: () -> Unit
-) {
-    Surface(
-        modifier = Modifier.fillMaxWidth(),
-        color = MaterialTheme.colorScheme.primaryContainer,
-        shadowElevation = 8.dp
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Column {
-                Text(
-                    "$selectedCount photos selected",
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
-                )
-                Text(
-                    when {
-                        selectedCount < 15 -> "Need ${15 - selectedCount} more"
-                        selectedCount < 20 -> "Good start!"
-                        selectedCount < 30 -> "Great selection!"
-                        else -> "Excellent coverage!"
-                    },
-                    style = MaterialTheme.typography.bodySmall,
-                    color = when {
-                        selectedCount < 15 -> MaterialTheme.colorScheme.error
-                        else -> MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
-                    }
-                )
-            }
-
-            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-                OutlinedButton(onClick = onClear) {
-                    Text("Clear")
-                }
-
-                Button(
-                    onClick = onContinue,
-                    enabled = selectedCount >= 15
-                ) {
-                    Icon(
-                        Icons.Default.Check,
-                        contentDescription = null,
-                        modifier = Modifier.size(20.dp)
-                    )
-                    Spacer(Modifier.width(8.dp))
-                    Text("Continue")
-                }
-            }
-        }
-    }
-}
-
-@OptIn(ExperimentalFoundationApi::class)
-@Composable
-private fun PhotoGrid(
-    photos: List<ImageEntity>,
-    selectedPhotos: Set<ImageEntity>,
-    onPhotoClick: (ImageEntity) -> Unit
-) {
-    LazyVerticalGrid(
-        columns = GridCells.Fixed(3),
-        contentPadding = PaddingValues(
-            start = 4.dp,
-            end = 4.dp,
-            bottom = 100.dp // Space for bottom bar
-        ),
-        horizontalArrangement = Arrangement.spacedBy(4.dp),
-        verticalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
-        items(
-            items = photos,
-            key = { it.imageId }
-        ) { photo ->
-            PhotoThumbnail(
-                photo = photo,
-                isSelected = photo in selectedPhotos,
-                onClick = { onPhotoClick(photo) }
-            )
-        }
-    }
-}
-
-@OptIn(ExperimentalFoundationApi::class)
-@Composable
-private fun PhotoThumbnail(
-    photo: ImageEntity,
-    isSelected: Boolean,
-    onClick: () -> Unit
-) {
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .aspectRatio(1f)
-            .combinedClickable(onClick = onClick),
-        shape = RoundedCornerShape(4.dp),
-        border = if (isSelected) {
-            BorderStroke(4.dp, MaterialTheme.colorScheme.primary)
-        } else null
-    ) {
-        Box {
-            // Photo
-            AsyncImage(
-                model = photo.imageUri,
-                contentDescription = null,
-                modifier = Modifier.fillMaxSize(),
-                contentScale = ContentScale.Crop
-            )
-
-            // Face count badge (top-left)
-            if (photo.faceCount != null && photo.faceCount!! > 0) {
-                Surface(
-                    modifier = Modifier
-                        .align(Alignment.TopStart)
-                        .padding(4.dp),
-                    shape = CircleShape,
-                    color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.95f)
-                ) {
-                    Row(
-                        modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
-                        horizontalArrangement = Arrangement.spacedBy(2.dp),
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Icon(
-                            Icons.Default.Face,
-                            contentDescription = null,
-                            modifier = Modifier.size(12.dp),
-                            tint = MaterialTheme.colorScheme.onPrimaryContainer
-                        )
-                        Text(
-                            "${photo.faceCount}",
-                            style = MaterialTheme.typography.labelSmall,
-                            color = MaterialTheme.colorScheme.onPrimaryContainer,
-                            fontWeight = FontWeight.Bold
-                        )
-                    }
-                }
-            }
-
-            // Selection checkmark (top-right)
-            if (isSelected) {
-                Surface(
-                    modifier = Modifier
-                        .align(Alignment.TopEnd)
-                        .padding(4.dp)
-                        .size(28.dp),
-                    shape = CircleShape,
-                    color = MaterialTheme.colorScheme.primary,
-                    shadowElevation = 4.dp
-                ) {
-                    Box(contentAlignment = Alignment.Center) {
-                        Icon(
-                            Icons.Default.CheckCircle,
-                            contentDescription = "Selected",
-                            modifier = Modifier.size(20.dp),
-                            tint = MaterialTheme.colorScheme.onPrimary
-                        )
-                    }
-                }
-            }
-
-            // Dim overlay when selected
-            if (isSelected) {
-                Box(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .background(Color.Black.copy(alpha = 0.2f))
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun EmptyState(onBack: () -> Unit) {
-    Box(
-        modifier = Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center
-    ) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(16.dp),
-            modifier = Modifier.padding(32.dp)
-        ) {
-            Icon(
-                Icons.Default.SearchOff,
-                contentDescription = null,
-                modifier = Modifier.size(72.dp),
-                tint = MaterialTheme.colorScheme.outline
-            )
-
-            Text(
-                "No Photos with Faces Found",
-                style = MaterialTheme.typography.titleLarge,
-                fontWeight = FontWeight.Bold
-            )
-
-            Text(
-                "Make sure the face detection cache has scanned your library",
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant
-            )
-
-            Button(onClick = onBack) {
-                Icon(Icons.Default.ArrowBack, null)
-                Spacer(Modifier.width(8.dp))
-                Text("Go Back")
-            }
-        }
-    }
-}

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

@@ -1,116 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-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 javax.inject.Inject
-
-/**
- * TrainingPhotoSelectorViewModel - Smart photo selector for training
- *
- * KEY OPTIMIZATION:
- * - Only loads images with hasFaces=true from database
- * - Result: 10,000 photos → ~500 with faces
- * - User can quickly select 20-30 good ones
- * - Multi-select state management
- */
-@HiltViewModel
-class TrainingPhotoSelectorViewModel @Inject constructor(
-    private val imageDao: ImageDao
-) : ViewModel() {
-
-    // Photos with faces (hasFaces=true)
-    private val _photosWithFaces = MutableStateFlow<List<ImageEntity>>(emptyList())
-    val photosWithFaces: StateFlow<List<ImageEntity>> = _photosWithFaces.asStateFlow()
-
-    // Selected photos (multi-select)
-    private val _selectedPhotos = MutableStateFlow<Set<ImageEntity>>(emptySet())
-    val selectedPhotos: StateFlow<Set<ImageEntity>> = _selectedPhotos.asStateFlow()
-
-    // Loading state
-    private val _isLoading = MutableStateFlow(true)
-    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
-
-    init {
-        loadPhotosWithFaces()
-    }
-
-    /**
-     * Load ONLY photos with hasFaces=true
-     *
-     * Uses indexed query: SELECT * FROM images WHERE hasFaces = 1
-     * Fast! (~10ms for 10k photos)
-     */
-    private fun loadPhotosWithFaces() {
-        viewModelScope.launch {
-            try {
-                _isLoading.value = true
-
-                // ✅ CRITICAL: Only get images with faces!
-                val photos = imageDao.getImagesWithFaces()
-
-                // Sort by most faces first (better for training)
-                val sorted = photos.sortedByDescending { it.faceCount ?: 0 }
-
-                _photosWithFaces.value = sorted
-
-            } catch (e: Exception) {
-                // If face cache not populated, empty list
-                _photosWithFaces.value = emptyList()
-            } finally {
-                _isLoading.value = false
-            }
-        }
-    }
-
-    /**
-     * Toggle photo selection
-     */
-    fun toggleSelection(photo: ImageEntity) {
-        val current = _selectedPhotos.value.toMutableSet()
-        if (photo in current) {
-            current.remove(photo)
-        } else {
-            current.add(photo)
-        }
-        _selectedPhotos.value = current
-    }
-
-    /**
-     * Clear all selections
-     */
-    fun clearSelection() {
-        _selectedPhotos.value = emptySet()
-    }
-
-    /**
-     * Auto-select first N photos (quick start)
-     */
-    fun autoSelect(count: Int = 25) {
-        val photos = _photosWithFaces.value.take(count)
-        _selectedPhotos.value = photos.toSet()
-    }
-
-    /**
-     * Select photos with single face only (best for training)
-     */
-    fun selectSingleFacePhotos(count: Int = 25) {
-        val singleFacePhotos = _photosWithFaces.value
-            .filter { it.faceCount == 1 }
-            .take(count)
-        _selectedPhotos.value = singleFacePhotos.toSet()
-    }
-
-    /**
-     * Refresh data (call after face detection cache updates)
-     */
-    fun refresh() {
-        loadPhotosWithFaces()
-    }
-}

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

@@ -5,12 +5,7 @@ import android.graphics.Bitmap
 import android.net.Uri
 
 /**
- * ENHANCED TrainingSanityChecker
+ * Coordinates sanity checks for training images
- *
- * New features:
- * - Progress callbacks
- * - Exclude functionality
- * - Faster processing
  */
 class TrainingSanityChecker(private val context: Context) {
 
@@ -23,8 +18,7 @@ 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(
@@ -42,42 +36,30 @@ class TrainingSanityChecker(private val context: Context) {
     }
 
     /**
-     * Perform comprehensive sanity checks with PROGRESS tracking
+     * Perform comprehensive sanity checks on training images
      */
     suspend fun performSanityChecks(
         imageUris: List<Uri>,
-        minImagesRequired: Int = 15,
+        minImagesRequired: Int = 10,
         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>()
 
-        // Filter out excluded images
+        // Check minimum image count
-        val activeImages = imageUris.filter { it !in excludedImages }
+        if (imageUris.size < minImagesRequired) {
-
-        // Check minimum image count (AFTER exclusions)
-        if (activeImages.size < minImagesRequired) {
             validationErrors.add(
                 ValidationError.InsufficientImages(
                     required = minImagesRequired,
-                    available = activeImages.size
+                    available = imageUris.size
                 )
             )
         }
 
-        // Step 1: Detect faces in all images (WITH PROGRESS)
+        // Step 1: Detect faces in all images
-        onProgress?.invoke("Detecting faces...", 0, activeImages.size)
+        val faceDetectionResults = faceDetectionHelper.detectFacesInImages(imageUris)
-
-        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 }
@@ -116,10 +98,8 @@ 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 = activeImages,
+            uris = imageUris,
             similarityThreshold = duplicateSimilarityThreshold
         )
 
@@ -158,16 +138,13 @@ 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
         )
     }
 
@@ -179,20 +156,24 @@ class TrainingSanityChecker(private val context: Context) {
             when (error) {
                 is ValidationError.NoFaceDetected -> {
                     val count = error.uris.size
-                    "No face detected in $count image(s)"
+                    val images = error.uris.joinToString(", ") { it.lastPathSegment ?: "Unknown" }
+                    "No face detected in $count image(s): $images"
                 }
                 is ValidationError.MultipleFacesDetected -> {
                     "Multiple faces (${error.faceCount}) detected in: ${error.uri.lastPathSegment}"
                 }
                 is ValidationError.DuplicateImages -> {
                     val count = error.groups.size
-                    "Found $count duplicate group(s)"
+                    val details = error.groups.joinToString("\n") { group ->
+                        "  - ${group.images.size} duplicates: ${group.images.joinToString(", ") { it.lastPathSegment ?: "Unknown" }}"
+                    }
+                    "Found $count duplicate group(s):\n$details"
                 }
                 is ValidationError.InsufficientImages -> {
-                    "Need ${error.required} images, have ${error.available}"
+                    "Insufficient images: need ${error.required}, but only ${error.available} valid images available"
                 }
                 is ValidationError.ImageLoadError -> {
-                    "Failed to load image: ${error.uri.lastPathSegment}"
+                    "Failed to load image ${error.uri.lastPathSegment}: ${error.error}"
                 }
             }
         }

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

@@ -1,430 +0,0 @@
-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
-import com.placeholder.sherpai2.ui.utilities.stats.StatsScreen
-
-/**
- * CLEANED PhotoUtilitiesScreen - No duplicate header
- *
- * Removed:
- * - Scaffold wrapper (lines 36-74)
- * - TopAppBar (was creating banner)
- * - "Photo Utilities" title (MainScreen shows it)
- *
- * Features:
- * - Stats tab (photo statistics and analytics)
- * - Tools tab (scan, duplicates, bursts, quality)
- * - Clean TabRow navigation
- */
-@Composable
-fun PhotoUtilitiesScreen(
-    viewModel: PhotoUtilitiesViewModel = hiltViewModel(),
-    modifier: Modifier = Modifier
-) {
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    val scanProgress by viewModel.scanProgress.collectAsStateWithLifecycle()
-
-    var selectedTab by remember { mutableStateOf(0) }
-
-    Column(modifier = modifier.fillMaxSize()) {
-        // TabRow for Stats/Tools
-        TabRow(
-            selectedTabIndex = selectedTab,
-            containerColor = MaterialTheme.colorScheme.surface,
-            contentColor = MaterialTheme.colorScheme.primary
-        ) {
-            Tab(
-                selected = selectedTab == 0,
-                onClick = { selectedTab = 0 },
-                text = { Text("Stats") },
-                icon = { Icon(Icons.Default.BarChart, "Statistics") }
-            )
-            Tab(
-                selected = selectedTab == 1,
-                onClick = { selectedTab = 1 },
-                text = { Text("Tools") },
-                icon = { Icon(Icons.Default.Build, "Tools") }
-            )
-        }
-
-        // Tab content
-        when (selectedTab) {
-            0 -> {
-                // Stats tab
-                StatsScreen()
-            }
-            1 -> {
-                // Tools tab
-                ToolsTabContent(
-                    uiState = uiState,
-                    scanProgress = scanProgress,
-                    onScanPhotos = { viewModel.scanForPhotos() },
-                    onDetectDuplicates = { viewModel.detectDuplicates() },
-                    onDetectBursts = { viewModel.detectBursts() },
-                    onAnalyzeQuality = { viewModel.analyzeQuality() }
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun ToolsTabContent(
-    uiState: UtilitiesUiState,
-    scanProgress: ScanProgress?,
-    onScanPhotos: () -> Unit,
-    onDetectDuplicates: () -> Unit,
-    onDetectBursts: () -> Unit,
-    onAnalyzeQuality: () -> Unit,
-    modifier: Modifier = Modifier
-) {
-    LazyColumn(
-        modifier = modifier.fillMaxSize(),
-        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 = onScanPhotos
-            )
-        }
-
-        // 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 = onDetectDuplicates
-            )
-        }
-
-        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 = onDetectBursts
-            )
-        }
-
-        // 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 = onAnalyzeQuality
-            )
-        }
-
-        // 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 = 4.dp)
-    ) {
-        Icon(
-            icon,
-            contentDescription = null,
-            tint = MaterialTheme.colorScheme.primary,
-            modifier = Modifier.size(20.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),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
-        )
-    ) {
-        Column(
-            modifier = Modifier.padding(16.dp),
-            verticalArrangement = Arrangement.spacedBy(12.dp)
-        ) {
-            Row(
-                horizontalArrangement = Arrangement.spacedBy(12.dp),
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Surface(
-                    modifier = Modifier.size(48.dp),
-                    shape = RoundedCornerShape(12.dp),
-                    color = MaterialTheme.colorScheme.primaryContainer
-                ) {
-                    Box(contentAlignment = Alignment.Center) {
-                        Icon(
-                            icon,
-                            contentDescription = null,
-                            tint = MaterialTheme.colorScheme.onPrimaryContainer,
-                            modifier = Modifier.size(24.dp)
-                        )
-                    }
-                }
-
-                Column(modifier = Modifier.weight(1f)) {
-                    Text(
-                        text = title,
-                        style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.SemiBold
-                    )
-                    Text(
-                        text = description,
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                }
-            }
-
-            Button(
-                onClick = onClick,
-                modifier = Modifier.fillMaxWidth(),
-                enabled = enabled,
-                shape = RoundedCornerShape(12.dp)
-            ) {
-                Text(buttonText)
-            }
-        }
-    }
-}
-
-@Composable
-private fun ProgressCard(progress: ScanProgress) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
-        )
-    ) {
-        Column(
-            modifier = Modifier.padding(16.dp),
-            verticalArrangement = Arrangement.spacedBy(8.dp)
-        ) {
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Text(
-                    text = progress.message,
-                    style = MaterialTheme.typography.bodyMedium,
-                    fontWeight = FontWeight.Medium
-                )
-                Text(
-                    text = "${progress.current}/${progress.total}",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-
-            LinearProgressIndicator(
-                progress = { progress.current.toFloat() / progress.total.toFloat() },
-                modifier = Modifier.fillMaxWidth(),
-            )
-        }
-    }
-}
-
-@Composable
-private fun ResultCard(
-    title: String,
-    message: String,
-    icon: ImageVector,
-    iconTint: androidx.compose.ui.graphics.Color
-) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
-    ) {
-        Row(
-            modifier = Modifier.padding(16.dp),
-            horizontalArrangement = Arrangement.spacedBy(12.dp),
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Icon(
-                icon,
-                contentDescription = null,
-                tint = iconTint,
-                modifier = Modifier.size(32.dp)
-            )
-            Column {
-                Text(
-                    text = title,
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
-                )
-                Text(
-                    text = message,
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun InfoCard() {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.3f)
-        )
-    ) {
-        Row(
-            modifier = Modifier.padding(12.dp),
-            horizontalArrangement = Arrangement.spacedBy(8.dp),
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Icon(
-                Icons.Default.Info,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onSecondaryContainer,
-                modifier = Modifier.size(20.dp)
-            )
-            Text(
-                text = "These tools help you organize and maintain your photo collection",
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSecondaryContainer
-            )
-        }
-    }
-}

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

@@ -1,455 +0,0 @@
-package com.placeholder.sherpai2.ui.utilities
-
-import android.graphics.Bitmap
-import android.net.Uri
-import androidx.lifecycle.ViewModel
-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.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.tasks.await
-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)
-     * ALSO POPULATES FACE DETECTION CACHE for optimization
-     */
-    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)
-                        }
-                    }
-                }
-
-                // OPTIMIZATION: Populate face detection cache for burst photos
-                // Burst photos often contain people, so cache this for future scans
-                _scanProgress.value = ScanProgress("Caching face detection data...", 0, 0)
-
-                val faceDetector = FaceDetection.getClient(
-                    FaceDetectorOptions.Builder()
-                        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST)
-                        .setMinFaceSize(0.15f)
-                        .build()
-                )
-
-                var cached = 0
-                burstGroups.forEach { group ->
-                    group.images.forEach { imageEntity ->
-                        // Only populate cache if not already cached
-                        if (imageEntity.needsFaceDetection()) {
-                            try {
-                                val uri = Uri.parse(imageEntity.imageUri)
-                                val faceCount = detectFaceCountQuick(uri, faceDetector)
-
-                                imageDao.updateFaceDetectionCache(
-                                    imageId = imageEntity.imageId,
-                                    hasFaces = faceCount > 0,
-                                    faceCount = faceCount
-                                )
-                                cached++
-                            } catch (e: Exception) {
-                                // Skip on error
-                            }
-                        }
-                    }
-                }
-
-                faceDetector.close()
-
-                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
-                }
-            }
-        }
-    }
-
-    /**
-     * Quick face count detection (lightweight, doesn't extract faces)
-     * Used for populating cache during utility scans
-     */
-    private suspend fun detectFaceCountQuick(
-        uri: Uri,
-        detector: com.google.mlkit.vision.face.FaceDetector
-    ): Int = withContext(Dispatchers.IO) {
-        var bitmap: Bitmap? = null
-        try {
-            // Load bitmap at lower resolution for quick detection
-            val options = android.graphics.BitmapFactory.Options().apply {
-                inSampleSize = 4  // Quarter resolution for speed
-                inPreferredConfig = android.graphics.Bitmap.Config.RGB_565
-            }
-
-            bitmap = imageRepository.loadBitmap(uri, options)
-            if (bitmap == null) return@withContext 0
-
-            val image = InputImage.fromBitmap(bitmap, 0)
-            val faces = detector.process(image).await()
-            faces.size
-
-        } catch (e: Exception) {
-            0
-        } finally {
-            bitmap?.recycle()
-        }
-    }
-
-    /**
-     * 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/ui/utilities/stats/Statsscreen.kt

@@ -1,635 +0,0 @@
-package com.placeholder.sherpai2.ui.utilities.stats
-
-import androidx.compose.foundation.background
-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.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
-import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
-import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
-import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
-import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
-import com.patrykandpatrick.vico.compose.common.of
-import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
-import com.patrykandpatrick.vico.core.cartesian.data.columnSeries
-import com.patrykandpatrick.vico.core.cartesian.data.lineSeries
-import com.patrykandpatrick.vico.core.common.shape.Shape
-import java.text.SimpleDateFormat
-import java.util.*
-
-/**
- * StatsScreen - Beautiful statistics dashboard
- *
- * Features:
- * - Photo count timeline (with granularity toggle)
- * - Year-by-year breakdown
- * - System tag statistics
- * - Burst detection stats
- * - Usage patterns (day of week, time of day)
- * - Face recognition stats
- */
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun StatsScreen(
-    viewModel: StatsViewModel = hiltViewModel()
-) {
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    val granularity by viewModel.timelineGranularity.collectAsStateWithLifecycle()
-
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = {
-                    Column {
-                        Text(
-                            "Photo Statistics",
-                            style = MaterialTheme.typography.titleLarge,
-                            fontWeight = FontWeight.Bold
-                        )
-                        Text(
-                            "Your collection insights",
-                            style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
-                        )
-                    }
-                },
-                actions = {
-                    IconButton(onClick = { viewModel.refresh() }) {
-                        Icon(Icons.Default.Refresh, "Refresh")
-                    }
-                },
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f)
-                )
-            )
-        }
-    ) { paddingValues ->
-        when (val state = uiState) {
-            is StatsUiState.Loading -> {
-                Box(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .padding(paddingValues),
-                    contentAlignment = Alignment.Center
-                ) {
-                    CircularProgressIndicator()
-                }
-            }
-
-            is StatsUiState.Error -> {
-                Box(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .padding(paddingValues),
-                    contentAlignment = Alignment.Center
-                ) {
-                    Column(
-                        horizontalAlignment = Alignment.CenterHorizontally,
-                        verticalArrangement = Arrangement.spacedBy(16.dp)
-                    ) {
-                        Icon(
-                            Icons.Default.Error,
-                            contentDescription = null,
-                            modifier = Modifier.size(64.dp),
-                            tint = MaterialTheme.colorScheme.error
-                        )
-                        Text(
-                            state.message,
-                            style = MaterialTheme.typography.bodyLarge,
-                            color = MaterialTheme.colorScheme.error
-                        )
-                        Button(onClick = { viewModel.refresh() }) {
-                            Text("Retry")
-                        }
-                    }
-                }
-            }
-
-            is StatsUiState.Success -> {
-                StatsContent(
-                    state = state,
-                    granularity = granularity,
-                    onGranularityChange = { viewModel.setTimelineGranularity(it) },
-                    modifier = Modifier.padding(paddingValues)
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun StatsContent(
-    state: StatsUiState.Success,
-    granularity: TimelineGranularity,
-    onGranularityChange: (TimelineGranularity) -> Unit,
-    modifier: Modifier = Modifier
-) {
-    LazyColumn(
-        modifier = modifier.fillMaxSize(),
-        contentPadding = PaddingValues(16.dp),
-        verticalArrangement = Arrangement.spacedBy(16.dp)
-    ) {
-        // Overview stats cards
-        item {
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.spacedBy(12.dp)
-            ) {
-                StatCard(
-                    title = "Total Photos",
-                    value = state.totalPhotos.toString(),
-                    icon = Icons.Default.Photo,
-                    color = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.weight(1f)
-                )
-                StatCard(
-                    title = "Per Day",
-                    value = String.format("%.1f", state.averagePerDay),
-                    icon = Icons.Default.CalendarToday,
-                    color = MaterialTheme.colorScheme.tertiary,
-                    modifier = Modifier.weight(1f)
-                )
-            }
-        }
-
-        item {
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.spacedBy(12.dp)
-            ) {
-                StatCard(
-                    title = "People",
-                    value = state.personCount.toString(),
-                    icon = Icons.Default.Face,
-                    color = MaterialTheme.colorScheme.secondary,
-                    modifier = Modifier.weight(1f)
-                )
-                state.burstStats?.let { burst ->
-                    StatCard(
-                        title = "Burst Groups",
-                        value = burst.estimatedBurstGroups.toString(),
-                        icon = Icons.Default.BurstMode,
-                        color = MaterialTheme.colorScheme.error,
-                        modifier = Modifier.weight(1f)
-                    )
-                }
-            }
-        }
-
-        // Timeline chart
-        item {
-            SectionHeader("Photo Timeline")
-        }
-
-        item {
-            TimelineChart(
-                state = state,
-                granularity = granularity,
-                onGranularityChange = onGranularityChange
-            )
-        }
-
-        // Year breakdown
-        item {
-            Spacer(Modifier.height(8.dp))
-            SectionHeader("Photos by Year")
-        }
-
-        items(state.yearCounts) { yearCount ->
-            YearStatRow(
-                year = yearCount.year,
-                count = yearCount.count,
-                totalPhotos = state.totalPhotos
-            )
-        }
-
-        // System tags
-        if (state.systemTagStats.isNotEmpty()) {
-            item {
-                Spacer(Modifier.height(8.dp))
-                SectionHeader("System Tags")
-            }
-
-            items(state.systemTagStats) { tagStat ->
-                TagStatRow(tagStat)
-            }
-        }
-
-        // Usage patterns
-        if (state.dayOfWeekCounts.isNotEmpty()) {
-            item {
-                Spacer(Modifier.height(8.dp))
-                SectionHeader("When You Shoot")
-            }
-
-            item {
-                DayOfWeekChart(state.dayOfWeekCounts)
-            }
-        }
-
-        // Date range info
-        state.dateRange?.let { range ->
-            item {
-                Spacer(Modifier.height(8.dp))
-                DateRangeCard(range)
-            }
-        }
-    }
-}
-
-@Composable
-private fun SectionHeader(title: String) {
-    Text(
-        text = title,
-        style = MaterialTheme.typography.titleMedium,
-        fontWeight = FontWeight.Bold,
-        color = MaterialTheme.colorScheme.primary,
-        modifier = Modifier.padding(vertical = 8.dp)
-    )
-}
-
-@Composable
-private fun StatCard(
-    title: String,
-    value: String,
-    icon: ImageVector,
-    color: Color,
-    modifier: Modifier = Modifier
-) {
-    Card(
-        modifier = modifier,
-        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = color.copy(alpha = 0.1f)
-        )
-    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(8.dp)
-        ) {
-            Icon(
-                icon,
-                contentDescription = null,
-                modifier = Modifier.size(32.dp),
-                tint = color
-            )
-            Text(
-                value,
-                style = MaterialTheme.typography.headlineMedium,
-                fontWeight = FontWeight.Bold,
-                color = color
-            )
-            Text(
-                title,
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center
-            )
-        }
-    }
-}
-
-@Composable
-private fun TimelineChart(
-    state: StatsUiState.Success,
-    granularity: TimelineGranularity,
-    onGranularityChange: (TimelineGranularity) -> Unit
-) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
-    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            // Granularity selector
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.spacedBy(8.dp)
-            ) {
-                TimelineGranularity.entries.forEach { g ->
-                    FilterChip(
-                        selected = granularity == g,
-                        onClick = { onGranularityChange(g) },
-                        label = {
-                            Text(
-                                when (g) {
-                                    TimelineGranularity.DAILY -> "Daily"
-                                    TimelineGranularity.MONTHLY -> "Monthly"
-                                    TimelineGranularity.YEARLY -> "Yearly"
-                                }
-                            )
-                        }
-                    )
-                }
-            }
-
-            // Chart
-            val modelProducer = remember { CartesianChartModelProducer.build() }
-
-            LaunchedEffect(granularity, state) {
-                val data = when (granularity) {
-                    TimelineGranularity.DAILY -> state.dailyCounts.map { it.count.toFloat() }
-                    TimelineGranularity.MONTHLY -> state.monthlyCounts.map { it.count.toFloat() }
-                    TimelineGranularity.YEARLY -> state.yearCounts.reversed().map { it.count.toFloat() }
-                }
-
-                if (data.isNotEmpty()) {
-                    modelProducer.tryRunTransaction {
-                        lineSeries { series(data) }
-                    }
-                }
-            }
-
-            if (state.dailyCounts.isNotEmpty()) {
-                CartesianChartHost(
-                    chart = rememberCartesianChart(
-                        rememberLineCartesianLayer(),
-                        startAxis = rememberStartAxis(),
-                        bottomAxis = rememberBottomAxis()
-                    ),
-                    modelProducer = modelProducer,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .height(200.dp)
-                )
-            } else {
-                Text(
-                    "No data available",
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(32.dp),
-                    textAlign = TextAlign.Center,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun YearStatRow(
-    year: String,
-    count: Int,
-    totalPhotos: Int
-) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        elevation = CardDefaults.cardElevation(defaultElevation = 1.dp)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
-                Text(
-                    year,
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
-                )
-                val percentage = if (totalPhotos > 0) {
-                    (count.toFloat() / totalPhotos * 100).toInt()
-                } else 0
-                Text(
-                    "$percentage% of collection",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-
-            Surface(
-                shape = RoundedCornerShape(8.dp),
-                color = MaterialTheme.colorScheme.primaryContainer
-            ) {
-                Text(
-                    count.toString(),
-                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold,
-                    color = MaterialTheme.colorScheme.primary
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun TagStatRow(tagStat: com.placeholder.sherpai2.data.local.dao.TagStat) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        elevation = CardDefaults.cardElevation(defaultElevation = 1.dp)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Row(
-                horizontalArrangement = Arrangement.spacedBy(12.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.weight(1f)
-            ) {
-                Icon(
-                    getTagIcon(tagStat.tagValue),
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.primary,
-                    modifier = Modifier.size(24.dp)
-                )
-                Text(
-                    tagStat.tagValue.replace("_", " ").capitalize(),
-                    style = MaterialTheme.typography.bodyLarge
-                )
-            }
-
-            Surface(
-                shape = RoundedCornerShape(8.dp),
-                color = MaterialTheme.colorScheme.secondaryContainer
-            ) {
-                Text(
-                    tagStat.imageCount.toString(),
-                    modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
-                    style = MaterialTheme.typography.bodyMedium,
-                    fontWeight = FontWeight.Bold,
-                    color = MaterialTheme.colorScheme.secondary
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun DayOfWeekChart(counts: List<com.placeholder.sherpai2.data.local.dao.DayOfWeekCount>) {
-    Card(
-        modifier = Modifier.fillMaxWidth(),
-        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
-    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            verticalArrangement = Arrangement.spacedBy(8.dp)
-        ) {
-            val days = listOf("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat")
-            val maxCount = counts.maxOfOrNull { it.count } ?: 1
-
-            counts.forEach { dayCount ->
-                val dayName = days.getOrNull(dayCount.dayOfWeek) ?: "?"
-                val percentage = (dayCount.count.toFloat() / maxCount)
-
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(12.dp),
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text(
-                        dayName,
-                        modifier = Modifier.width(50.dp),
-                        style = MaterialTheme.typography.bodyMedium,
-                        fontWeight = FontWeight.Medium
-                    )
-
-                    Box(
-                        modifier = Modifier
-                            .weight(1f)
-                            .height(32.dp)
-                            .background(
-                                MaterialTheme.colorScheme.surfaceVariant,
-                                RoundedCornerShape(4.dp)
-                            )
-                    ) {
-                        Box(
-                            modifier = Modifier
-                                .fillMaxHeight()
-                                .fillMaxWidth(percentage)
-                                .background(
-                                    MaterialTheme.colorScheme.primary,
-                                    RoundedCornerShape(4.dp)
-                                )
-                        )
-                        Text(
-                            dayCount.count.toString(),
-                            modifier = Modifier
-                                .align(Alignment.CenterEnd)
-                                .padding(end = 8.dp),
-                            style = MaterialTheme.typography.bodySmall,
-                            fontWeight = FontWeight.Bold
-                        )
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun DateRangeCard(range: com.placeholder.sherpai2.data.local.dao.PhotoDateRange) {
-    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.DateRange,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.primary
-                )
-                Text(
-                    "Collection Date Range",
-                    style = MaterialTheme.typography.titleSmall,
-                    fontWeight = FontWeight.Bold
-                )
-            }
-
-            val dateFormat = SimpleDateFormat("MMM dd, yyyy", Locale.getDefault())
-            val earliest = dateFormat.format(Date(range.earliest))
-            val latest = dateFormat.format(Date(range.latest))
-
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween
-            ) {
-                Column {
-                    Text(
-                        "Earliest",
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                    Text(
-                        earliest,
-                        style = MaterialTheme.typography.bodyMedium,
-                        fontWeight = FontWeight.Medium
-                    )
-                }
-                Column(horizontalAlignment = Alignment.End) {
-                    Text(
-                        "Latest",
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                    )
-                    Text(
-                        latest,
-                        style = MaterialTheme.typography.bodyMedium,
-                        fontWeight = FontWeight.Medium
-                    )
-                }
-            }
-        }
-    }
-}
-
-private fun getTagIcon(tagValue: String): ImageVector {
-    return when (tagValue) {
-        "burst" -> Icons.Default.BurstMode
-        "duplicate" -> Icons.Default.FileCopy
-        "screenshot" -> Icons.Default.Screenshot
-        "blurry" -> Icons.Default.BlurOn
-        "low_quality" -> Icons.Default.LowPriority
-        else -> Icons.Default.LocalOffer
-    }
-}
-
-private fun String.capitalize(): String {
-    return this.split("_").joinToString(" ") { word ->
-        word.replaceFirstChar { it.uppercase() }
-    }
-}

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

@@ -1,127 +0,0 @@
-package com.placeholder.sherpai2.ui.utilities.stats
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.data.local.dao.*
-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 javax.inject.Inject
-
-/**
- * StatsViewModel - Photo collection statistics
- *
- * Features:
- * 1. Photo count timeline (daily/monthly/yearly)
- * 2. Year-by-year breakdown
- * 3. System tag statistics
- * 4. Burst detection stats
- * 5. Usage patterns (day of week, hour of day)
- */
-@HiltViewModel
-class StatsViewModel @Inject constructor(
-    private val imageDao: ImageDao,
-    private val tagDao: TagDao,
-    private val imageTagDao: ImageTagDao,
-    private val personDao: PersonDao,
-    private val photoFaceTagDao: PhotoFaceTagDao
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow<StatsUiState>(StatsUiState.Loading)
-    val uiState: StateFlow<StatsUiState> = _uiState.asStateFlow()
-
-    private val _timelineGranularity = MutableStateFlow(TimelineGranularity.MONTHLY)
-    val timelineGranularity: StateFlow<TimelineGranularity> = _timelineGranularity.asStateFlow()
-
-    init {
-        loadStats()
-    }
-
-    fun loadStats() {
-        viewModelScope.launch(Dispatchers.IO) {
-            try {
-                _uiState.value = StatsUiState.Loading
-
-                // Load all stats in parallel
-                val totalCount = imageDao.getImageCount()
-                val yearCounts = imageDao.getPhotoCountsByYear()
-                val monthlyCounts = imageDao.getPhotoCountsByMonth()
-                val dailyCounts = imageDao.getPhotoCountsByDate()
-                val systemTagStats = tagDao.getSystemTagStats()
-                val burstStats = imageTagDao.getBurstStats()
-                val dateRange = imageDao.getPhotoDateRange()
-                val avgPerDay = imageDao.getAveragePhotosPerDay()
-                val dayOfWeekCounts = imageDao.getPhotoCountsByDayOfWeek()
-                val hourCounts = imageDao.getPhotoCountsByHour()
-
-                // Face recognition stats
-                val personCount = personDao.getPersonCount()
-                val taggedFaceCount = photoFaceTagDao.getUnverifiedTagCount()
-
-                _uiState.value = StatsUiState.Success(
-                    totalPhotos = totalCount,
-                    yearCounts = yearCounts,
-                    monthlyCounts = monthlyCounts,
-                    dailyCounts = dailyCounts,
-                    systemTagStats = systemTagStats,
-                    burstStats = burstStats,
-                    dateRange = dateRange,
-                    averagePerDay = avgPerDay ?: 0f,
-                    dayOfWeekCounts = dayOfWeekCounts,
-                    hourCounts = hourCounts,
-                    personCount = personCount,
-                    taggedFaceCount = taggedFaceCount
-                )
-
-            } catch (e: Exception) {
-                _uiState.value = StatsUiState.Error(
-                    e.message ?: "Failed to load statistics"
-                )
-            }
-        }
-    }
-
-    fun setTimelineGranularity(granularity: TimelineGranularity) {
-        _timelineGranularity.value = granularity
-    }
-
-    fun refresh() {
-        loadStats()
-    }
-}
-
-/**
- * UI State for stats screen
- */
-sealed class StatsUiState {
-    object Loading : StatsUiState()
-
-    data class Success(
-        val totalPhotos: Int,
-        val yearCounts: List<YearCount>,
-        val monthlyCounts: List<MonthCount>,
-        val dailyCounts: List<DateCount>,
-        val systemTagStats: List<TagStat>,
-        val burstStats: BurstStats?,
-        val dateRange: PhotoDateRange?,
-        val averagePerDay: Float,
-        val dayOfWeekCounts: List<DayOfWeekCount>,
-        val hourCounts: List<HourCount>,
-        val personCount: Int,
-        val taggedFaceCount: Int
-    ) : StatsUiState()
-
-    data class Error(val message: String) : StatsUiState()
-}
-
-/**
- * Timeline granularity options
- */
-enum class TimelineGranularity {
-    DAILY,
-    MONTHLY,
-    YEARLY
-}

app/src/main/java/com/placeholder/sherpai2/workers/Cachepopulationworker.kt

@@ -1,148 +0,0 @@
-package com.placeholder.sherpai2.workers
-
-import android.content.Context
-import android.net.Uri
-import androidx.hilt.work.HiltWorker
-import androidx.work.*
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.ui.trainingprep.FaceDetectionHelper
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedInject
-import kotlinx.coroutines.*
-
-/**
- * CachePopulationWorker - Background face detection cache builder
- *
- * 🎯 Purpose: One-time scan to mark which photos contain faces
- * ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- * Strategy:
- * 1. Use ML Kit FAST detector (speed over accuracy)
- * 2. Scan ALL photos in library that need caching
- * 3. Store: hasFaces (boolean) + faceCount (int) + version
- * 4. Result: Future person scans only check ~30% of photos
- *
- * Performance:
- * • FAST detector: ~100-200ms per image
- * • 10,000 photos: ~5-10 minutes total
- * • Cache persists forever (until version upgrade)
- * • Saves 70% of work on every future scan
- *
- * Scheduling:
- * • Preferred: When device is idle + charging
- * • Alternative: User can force immediate run
- * • Batched processing: 50 images per batch
- * • Supports pause/resume via WorkManager
- */
-@HiltWorker
-class CachePopulationWorker @AssistedInject constructor(
-    @Assisted private val context: Context,
-    @Assisted workerParams: WorkerParameters,
-    private val imageDao: ImageDao
-) : CoroutineWorker(context, workerParams) {
-
-    companion object {
-        const val WORK_NAME = "face_cache_population"
-        const val KEY_PROGRESS_CURRENT = "progress_current"
-        const val KEY_PROGRESS_TOTAL = "progress_total"
-        const val KEY_CACHED_COUNT = "cached_count"
-
-        private const val BATCH_SIZE = 50  // Smaller batches for stability
-        private const val MAX_RETRIES = 3
-    }
-
-    private val faceDetectionHelper = FaceDetectionHelper(context)
-
-    override suspend fun doWork(): Result = withContext(Dispatchers.Default) {
-        try {
-            // Check if we should stop (work cancelled)
-            if (isStopped) {
-                return@withContext Result.failure()
-            }
-
-            // Get all images that need face detection caching
-            val needsCaching = imageDao.getImagesNeedingFaceDetection()
-
-            if (needsCaching.isEmpty()) {
-                // Already fully cached!
-                val totalImages = imageDao.getImageCount()
-                return@withContext Result.success(
-                    workDataOf(KEY_CACHED_COUNT to totalImages)
-                )
-            }
-
-            var processedCount = 0
-            var successCount = 0
-            val totalCount = needsCaching.size
-
-            try {
-                // Process in batches
-                needsCaching.chunked(BATCH_SIZE).forEach { batch ->
-                    // Check for cancellation
-                    if (isStopped) {
-                        return@forEach
-                    }
-
-                    // Process batch in parallel using FaceDetectionHelper
-                    val uris = batch.map { Uri.parse(it.imageUri) }
-                    val results = faceDetectionHelper.detectFacesInImages(uris) { current, total ->
-                        // Inner progress for this batch
-                    }
-
-                    // Update database with results
-                    results.zip(batch).forEach { (result, image) ->
-                        try {
-                            imageDao.updateFaceDetectionCache(
-                                imageId = image.imageId,
-                                hasFaces = result.hasFace,
-                                faceCount = result.faceCount,
-                                timestamp = System.currentTimeMillis(),
-                                version = ImageEntity.CURRENT_FACE_DETECTION_VERSION
-                            )
-                            successCount++
-                        } catch (e: Exception) {
-                            // Skip failed updates, continue with next
-                        }
-                    }
-
-                    processedCount += batch.size
-
-                    // Update progress
-                    setProgress(
-                        workDataOf(
-                            KEY_PROGRESS_CURRENT to processedCount,
-                            KEY_PROGRESS_TOTAL to totalCount
-                        )
-                    )
-
-                    // Give system a breather between batches
-                    delay(200)
-                }
-
-                // Success!
-                Result.success(
-                    workDataOf(
-                        KEY_CACHED_COUNT to successCount,
-                        KEY_PROGRESS_CURRENT to processedCount,
-                        KEY_PROGRESS_TOTAL to totalCount
-                    )
-                )
-            } finally {
-                // Clean up detector
-                faceDetectionHelper.cleanup()
-            }
-        } catch (e: Exception) {
-            // Clean up on error
-            faceDetectionHelper.cleanup()
-
-            // Handle failure
-            if (runAttemptCount < MAX_RETRIES) {
-                Result.retry()
-            } else {
-                Result.failure(
-                    workDataOf("error" to (e.message ?: "Unknown error"))
-                )
-            }
-        }
-    }
-}

app/src/main/java/com/placeholder/sherpai2/workers/Faceclusteringworker.kt

@@ -1,113 +0,0 @@
-package com.placeholder.sherpai2.workers
-
-import android.content.Context
-import androidx.hilt.work.HiltWorker
-import androidx.work.*
-import com.placeholder.sherpai2.domain.clustering.FaceClusteringService
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedInject
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-
-/**
- * FaceClusteringWorker - Background face clustering with persistence
- *
- * BENEFITS:
- * - Survives app restarts
- * - Runs even when app is backgrounded
- * - Progress updates via WorkManager Data
- * - Results saved to shared preferences
- *
- * USAGE:
- * val workRequest = OneTimeWorkRequestBuilder<FaceClusteringWorker>()
- *     .setConstraints(...)
- *     .build()
- * WorkManager.getInstance(context).enqueue(workRequest)
- */
-@HiltWorker
-class FaceClusteringWorker @AssistedInject constructor(
-    @Assisted private val context: Context,
-    @Assisted workerParams: WorkerParameters,
-    private val clusteringService: FaceClusteringService
-) : CoroutineWorker(context, workerParams) {
-
-    companion object {
-        const val WORK_NAME = "face_clustering_discovery"
-        const val KEY_PROGRESS_CURRENT = "progress_current"
-        const val KEY_PROGRESS_TOTAL = "progress_total"
-        const val KEY_PROGRESS_MESSAGE = "progress_message"
-        const val KEY_CLUSTER_COUNT = "cluster_count"
-        const val KEY_FACE_COUNT = "face_count"
-        const val KEY_RESULT_JSON = "result_json"
-    }
-
-    override suspend fun doWork(): Result = withContext(Dispatchers.Default) {
-        try {
-            // Check if we should stop (work cancelled)
-            if (isStopped) {
-                return@withContext Result.failure()
-            }
-
-            withContext(Dispatchers.Main) {
-                setProgress(
-                    workDataOf(
-                        KEY_PROGRESS_CURRENT to 0,
-                        KEY_PROGRESS_TOTAL to 100,
-                        KEY_PROGRESS_MESSAGE to "Starting discovery..."
-                    )
-                )
-            }
-
-            // Run clustering
-            val result = clusteringService.discoverPeople(
-                onProgress = { current, total, message ->
-                    if (!isStopped) {
-                        kotlinx.coroutines.runBlocking {
-                            withContext(Dispatchers.Main) {
-                                setProgress(
-                                    workDataOf(
-                                        KEY_PROGRESS_CURRENT to current,
-                                        KEY_PROGRESS_TOTAL to total,
-                                        KEY_PROGRESS_MESSAGE to message
-                                    )
-                                )
-                            }
-                        }
-                    }
-                }
-            )
-
-            // Save result to SharedPreferences for ViewModel to read
-            val prefs = context.getSharedPreferences("face_clustering", Context.MODE_PRIVATE)
-            prefs.edit().apply {
-                putInt(KEY_CLUSTER_COUNT, result.clusters.size)
-                putInt(KEY_FACE_COUNT, result.totalFacesAnalyzed)
-                putLong("timestamp", System.currentTimeMillis())
-                // Don't serialize full result - too complex without proper setup
-                // Phase 2 will handle proper result persistence
-                apply()
-            }
-
-            // Success!
-            Result.success(
-                workDataOf(
-                    KEY_CLUSTER_COUNT to result.clusters.size,
-                    KEY_FACE_COUNT to result.totalFacesAnalyzed
-                )
-            )
-
-        } catch (e: Exception) {
-            // Save error state
-            val prefs = context.getSharedPreferences("face_clustering", Context.MODE_PRIVATE)
-            prefs.edit().apply {
-                putString("error", e.message ?: "Unknown error")
-                putLong("timestamp", System.currentTimeMillis())
-                apply()
-            }
-
-            Result.failure(
-                workDataOf("error" to (e.message ?: "Unknown error"))
-            )
-        }
-    }
-}

gradle/libs.versions.toml

@@ -28,18 +28,6 @@ tensorflow-lite = "2.14.0"
 tensorflow-lite-support = "0.4.4"
 gson = "2.10.1"
 
-#Album/Image View Tools
-zoomable = "1.6.1"
-
-#Charting Lib
-vico = "2.0.0-alpha.28"
-
-#workers
-work = "2.9.0"
-hilt-work = "1.1.0"
-mlkit-face = "16.1.6"
-
-
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
 androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
@@ -80,23 +68,6 @@ tensorflow-lite-gpu = { group = "org.tensorflow", name = "tensorflow-lite-gpu",
 
 gson = { group = "com.google.code.gson", name = "gson", version.ref = "gson" }
 
-
-#Album/Image View Tools
-zoomable = { group = "net.engawapg.lib", name = "zoomable", version.ref = "zoomable" }
-
-vico-compose = { module = "com.patrykandpatrick.vico:compose", version.ref = "vico" }
-vico-compose-m3 = { module = "com.patrykandpatrick.vico:compose-m3", version.ref = "vico" }
-vico-core = { module = "com.patrykandpatrick.vico:core", version.ref = "vico" }
-
-
-#workers
-androidx-work-runtime-ktx = { module = "androidx.work:work-runtime-ktx", version.ref = "work" }
-
-androidx-hilt-work = { module = "androidx.hilt:hilt-work", version.ref = "hilt-work" }
-androidx-hilt-compiler = { module = "androidx.hilt:hilt-compiler", version.ref = "hilt-work" }
-
-
-
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }