Adding HILT DI and First Pass at backend Kotlin

.gitignore

@@ -13,3 +13,4 @@
 .externalNativeBuild
 .cxx
 local.properties
+/.idea/

app/build.gradle.kts

@@ -8,74 +8,68 @@ plugins {
 
 android {
     namespace = "com.placeholder.sherpai2"
-    compileSdk = 35
+    compileSdk = 36 // SDK 35 is the stable standard for 2025; 36 is preview
 
     defaultConfig {
         applicationId = "com.placeholder.sherpai2"
-        minSdk = 25
-        targetSdk = 35
+        minSdk = 24
+        targetSdk = 36
         versionCode = 1
         versionName = "1.0"
-
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
-    buildTypes {
-        release {
-            isMinifyEnabled = false
-            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
-        }
-    }
-
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
-        targetCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
     }
 
     kotlinOptions {
-        jvmTarget = "11"
+        jvmTarget = "17"
     }
 
     buildFeatures {
         compose = true
     }
+
+    androidResources {
+        noCompress += "tflite"
+    }
+}
+
+// FIX for hiltAggregateDepsDebug: Correctly configure the Hilt extension
+hilt {
+    enableAggregatingTask = false
 }
 
 dependencies {
-    // Core & Lifecycle
-    implementation(libs.androidx.core.ktx)
-    implementation(libs.androidx.lifecycle.runtime.ktx)
-    implementation(libs.androidx.lifecycle.viewmodel.compose)
-    implementation(libs.androidx.activity.compose)
-
     // Compose
     implementation(platform(libs.androidx.compose.bom))
-    implementation(libs.androidx.compose.ui)
-    implementation(libs.androidx.compose.ui.graphics)
-    implementation(libs.androidx.compose.ui.tooling.preview)
-    implementation(libs.androidx.compose.material3)
-    implementation(libs.androidx.compose.material.icons)
-    debugImplementation(libs.androidx.compose.ui.tooling)
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime)
+    implementation(libs.androidx.activity.compose)
+    implementation(libs.compose.ui)
+    implementation(libs.compose.material3)
+    implementation(libs.compose.icons)
+    implementation(libs.compose.navigation)
+    debugImplementation(libs.compose.ui.tooling)
 
-    // Hilt DI
-    implementation(libs.hilt.android)
-    ksp(libs.hilt.compiler)
-    implementation(libs.androidx.hilt.navigation.compose)
+    // Camera & ML
+    implementation(libs.camera.core)
+    implementation(libs.camera.lifecycle)
+    implementation(libs.camera.view)
+    implementation(libs.mlkit.face)
+    implementation(libs.tflite)
+    implementation(libs.tflite.support)
 
-    // Navigation
-    implementation(libs.androidx.navigation.compose)
-
-    // Room Database
+    // Room (KSP)
     implementation(libs.room.runtime)
-    implementation(libs.room.ktx)
     ksp(libs.room.compiler)
 
-    // Coil Images
+    // Images
     implementation(libs.coil.compose)
 
-    // ML Kit
-    implementation(libs.mlkit.face.detection)
-    implementation(libs.kotlinx.coroutines.play.services)
-
-
+    // Hilt (KSP) - Fixed by removing kapt and using ksp
+    implementation(libs.hilt.android)
+    ksp(libs.hilt.compiler)
 }

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

@@ -10,77 +10,63 @@ import androidx.activity.compose.setContent
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.runtime.*
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.core.content.ContextCompat
-import com.placeholder.sherpai2.domain.repository.ImageRepository
-import com.placeholder.sherpai2.ui.presentation.MainScreen
+import com.placeholder.sherpai2.presentation.MainScreen // IMPORT your main screen
 import com.placeholder.sherpai2.ui.theme.SherpAI2Theme
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.launch
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : ComponentActivity() {
-
-    @Inject
-    lateinit var imageRepository: ImageRepository
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        // Determine storage permission based on Android version
-        val storagePermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        // 1. Define the permission needed based on API level
+        val permission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
             Manifest.permission.READ_MEDIA_IMAGES
         } else {
-            @Suppress("DEPRECATION")
             Manifest.permission.READ_EXTERNAL_STORAGE
         }
-
         setContent {
             SherpAI2Theme {
+                // 2. State to track if permission is granted
                 var hasPermission by remember {
-                    mutableStateOf(
-                        ContextCompat.checkSelfPermission(this, storagePermission) ==
-                                PackageManager.PERMISSION_GRANTED
-                    )
+                    mutableStateOf(ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED)
                 }
 
-                // Track ingestion completion
-                var imagesIngested by remember { mutableStateOf(false) }
-
-                // Launcher for permission request
-                val permissionLauncher = rememberLauncherForActivityResult(
+                // 3. Launcher to ask for permission
+                val launcher = rememberLauncherForActivityResult(
                     ActivityResultContracts.RequestPermission()
-                ) { granted ->
-                    hasPermission = granted
+                ) { isGranted ->
+                    hasPermission = isGranted
                 }
 
-                // Trigger ingestion once permission is granted
-                LaunchedEffect(hasPermission) {
-                    if (hasPermission) {
-                        // Suspend until ingestion completes
-                        imageRepository.ingestImages()
-                        imagesIngested = true
-                    } else {
-                        permissionLauncher.launch(storagePermission)
-                    }
+                // 4. Trigger request on start
+                LaunchedEffect(Unit) {
+                    if (!hasPermission) launcher.launch(permission)
                 }
 
-                // Gate UI until permission granted AND ingestion completed
-                if (hasPermission && imagesIngested) {
-                    MainScreen()
+                if (hasPermission) {
+                    MainScreen() // Your existing screen that holds MainContentArea
                 } else {
-                    Box(
-                        modifier = Modifier.fillMaxSize(),
-                        contentAlignment = Alignment.Center
-                    ) {
-                        Text("Please grant storage permission to continue.")
+                    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                        Text("Please grant storage permission to view photos.")
                     }
                 }
             }
+
+
+            }
         }
-    }
 }
+
+

app/src/main/java/com/placeholder/sherpai2/data/di/AppModule.kt

@@ -0,0 +1,58 @@
+package com.placeholder.sherpai2.data.di
+
+import android.content.Context
+import com.placeholder.sherpai2.data.local.FaceDao
+import com.placeholder.sherpai2.data.local.FaceDatabase
+import com.placeholder.sherpai2.data.repo.FaceRepository
+import com.placeholder.sherpai2.domain.faces.analyzer.FaceAnalyzer
+import com.placeholder.sherpai2.domain.faces.ml.FaceNetInterpreter
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object AppModule {
+
+    // ---------- Database ----------
+
+    @Provides
+    @Singleton
+    fun provideFaceDatabase(
+        @ApplicationContext context: Context
+    ): FaceDatabase =
+        FaceDatabase.getInstance(context)
+
+    @Provides
+    fun provideFaceDao(
+        db: FaceDatabase
+    ): FaceDao = db.faceDao()
+
+    // ---------- Repository ----------
+
+    @Provides
+    @Singleton
+    fun provideFaceRepository(
+        dao: FaceDao
+    ): FaceRepository =
+        FaceRepository(dao)
+
+    // ---------- ML ----------
+
+    @Provides
+    @Singleton
+    fun provideFaceNetInterpreter(
+        @ApplicationContext context: Context
+    ): FaceNetInterpreter =
+        FaceNetInterpreter(context)
+
+    @Provides
+    @Singleton
+    fun provideFaceAnalyzer(
+        @ApplicationContext context: Context
+    ): FaceAnalyzer =
+        FaceAnalyzer(context)
+}

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

@@ -1,47 +0,0 @@
-package com.placeholder.sherpai2.data.local
-
-import androidx.room.Database
-import androidx.room.RoomDatabase
-import com.placeholder.sherpai2.data.local.dao.EventDao
-import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.dao.ImageEventDao
-import com.placeholder.sherpai2.data.local.dao.ImagePersonDao
-import com.placeholder.sherpai2.data.local.dao.ImageTagDao
-import com.placeholder.sherpai2.data.local.dao.PersonDao
-import com.placeholder.sherpai2.data.local.dao.TagDao
-import com.placeholder.sherpai2.data.local.entity.EventEntity
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.data.local.entity.ImageEventEntity
-import com.placeholder.sherpai2.data.local.entity.ImagePersonEntity
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-import com.placeholder.sherpai2.data.local.entity.PersonEntity
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-
-@Database(
-    entities = [
-        ImageEntity::class,
-        TagEntity::class,
-        PersonEntity::class,
-        EventEntity::class,
-        ImageTagEntity::class,
-        ImagePersonEntity::class,
-        ImageEventEntity::class
-    ],
-    version = 1,
-    exportSchema = true
-)
-
-abstract class AppDatabase : RoomDatabase() {
-
-    abstract fun imageDao(): ImageDao
-    abstract fun tagDao(): TagDao
-    abstract fun personDao(): PersonDao
-    abstract fun eventDao(): EventDao
-
-    abstract fun imageTagDao(): ImageTagDao
-    abstract fun imagePersonDao(): ImagePersonDao
-    abstract fun imageEventDao(): ImageEventDao
-
-    abstract fun imageAggregateDao(): ImageAggregateDao
-}

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

@@ -0,0 +1,31 @@
+package com.placeholder.sherpai2.data.local
+
+import androidx.room.TypeConverter
+import java.nio.ByteBuffer
+
+/**
+ * Converts FloatArray to ByteArray and back for Room persistence.
+ */
+object Converters {
+
+    @TypeConverter
+    @JvmStatic
+    fun fromFloatArray(value: FloatArray): ByteArray {
+        val buffer = ByteBuffer.allocate(value.size * 4)
+        for (f in value) {
+            buffer.putFloat(f)
+        }
+        return buffer.array()
+    }
+
+    @TypeConverter
+    @JvmStatic
+    fun toFloatArray(bytes: ByteArray): FloatArray {
+        val buffer = ByteBuffer.wrap(bytes)
+        val floats = FloatArray(bytes.size / 4)
+        for (i in floats.indices) {
+            floats[i] = buffer.getFloat()
+        }
+        return floats
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.placeholder.sherpai2.data.local
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * DAO for face embeddings.
+ */
+@Dao
+interface FaceDao {
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insert(face: FaceEntity): Long
+
+    @Query("SELECT * FROM faces")
+    suspend fun getAllFaces(): List<FaceEntity>
+
+    @Query("SELECT * FROM faces WHERE label = :label LIMIT 1")
+    suspend fun getFaceByLabel(label: String): FaceEntity?
+
+    @Query("DELETE FROM faces")
+    suspend fun clearAll()
+}

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

@@ -0,0 +1,38 @@
+package com.placeholder.sherpai2.data.local
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+
+/**
+ * Room database for storing face embeddings.
+ */
+@Database(
+    entities = [FaceEntity::class],
+    version = 1,
+    exportSchema = false
+)
+abstract class FaceDatabase : RoomDatabase() {
+
+    abstract fun faceDao(): FaceDao
+
+    companion object {
+        @Volatile
+        private var INSTANCE: FaceDatabase? = null
+
+        fun getInstance(context: Context): FaceDatabase {
+            return INSTANCE ?: synchronized(this) {
+                val instance = Room.databaseBuilder(
+                    context.applicationContext,
+                    FaceDatabase::class.java,
+                    "face_database"
+                )
+                    .fallbackToDestructiveMigration() // Safe for dev; can be removed in prod
+                    .build()
+                INSTANCE = instance
+                instance
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.placeholder.sherpai2.data.local
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import androidx.room.TypeConverters
+
+/**
+ * Room entity representing a single face embedding.
+ *
+ * @param id Auto-generated primary key
+ * @param label Name or identifier for the face
+ * @param embedding FloatArray of length 128/512 representing the face
+ */
+@Entity(tableName = "faces")
+@TypeConverters(Converters::class)
+data class FaceEntity(
+    @PrimaryKey(autoGenerate = true)
+    val id: Long = 0L,
+
+    val label: String,
+
+    val embedding: FloatArray
+)

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

@@ -1,26 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.EventEntity
-
-@Dao
-interface EventDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insert(event: EventEntity)
-
-    /**
-     * Find events covering a timestamp.
-     *
-     * This is the backbone of auto-tagging by date.
-     */
-    @Query("""
-        SELECT * FROM events
-        WHERE :timestamp BETWEEN startDate AND endDate
-        AND isHidden = 0
-    """)
-    suspend fun findEventsForTimestamp(timestamp: Long): List<EventEntity>
-}

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

@@ -1,48 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Query
-import androidx.room.Transaction
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-import kotlinx.coroutines.flow.Flow
-
-@Dao
-interface ImageAggregateDao {
-
-    /**
-     * Observe a fully-hydrated image object.
-     */
-    @Transaction
-    @Query("""
-        SELECT * FROM images
-        WHERE imageId = :imageId
-    """)
-    fun observeImageWithEverything(
-        imageId: String
-    ): Flow<ImageWithEverything>
-
-    /**
-     * Observe all images.
-     */
-    @Transaction
-    @Query("""
-        SELECT * FROM images
-        ORDER BY capturedAt DESC
-    """)
-    fun observeAllImagesWithEverything(): Flow<List<ImageWithEverything>>
-
-    /**
-     * Observe images filtered by tag value.
-     *
-     * Joins images -> image_tags -> tags
-     */
-    @Transaction
-    @Query("""
-        SELECT images.* FROM images
-        INNER JOIN image_tags ON images.imageId = image_tags.imageId
-        INNER JOIN tags ON tags.tagId = image_tags.tagId
-        WHERE tags.value = :tag
-        ORDER BY images.capturedAt DESC
-    """)
-    fun observeImagesWithTag(tag: String): Flow<List<ImageWithEverything>>
-}

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

@@ -1,68 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import androidx.room.Transaction
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-import kotlinx.coroutines.flow.Flow
-
-@Dao
-interface ImageDao {
-
-    /**
-     * Insert images.
-     *
-     * IGNORE prevents duplicate insertion
-     * when sha256 or imageUri already exists.
-     */
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insertImages(images: List<ImageEntity>)
-
-    /**
-     * Get image by ID.
-     */
-    @Query("SELECT * FROM images WHERE imageId = :imageId")
-    suspend fun getImageById(imageId: String): ImageEntity?
-
-    /**
-     * Stream images ordered by capture time (newest first).
-     *
-     * Flow is critical:
-     * - UI auto-updates
-     * - No manual refresh
-     */
-    @Query("""
-        SELECT * FROM images
-        ORDER BY capturedAt DESC
-    """)
-    fun observeAllImages(): Flow<List<ImageEntity>>
-
-    /**
-     * Fetch images in a time range.
-     * Used for:
-     * - event auto-assignment
-     * - timeline views
-     */
-    @Query("""
-        SELECT * FROM images
-        WHERE capturedAt BETWEEN :start AND :end
-        ORDER BY capturedAt ASC
-    """)
-    suspend fun getImagesInRange(
-        start: Long,
-        end: Long
-    ): List<ImageEntity>
-
-    @Transaction
-    @Query("SELECT * FROM images ORDER BY capturedAt DESC LIMIT :limit")
-    fun getRecentImages(limit: Int): Flow<List<ImageWithEverything>>
-
-    @Query("SELECT COUNT(*) > 0 FROM images WHERE sha256 = :sha256")
-    suspend fun existsBySha256(sha256: String): Boolean
-
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insert(image: ImageEntity)
-}

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

@@ -1,23 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.ImageEventEntity
-
-@Dao
-interface ImageEventDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun upsert(entity: ImageEventEntity)
-
-    /**
-     * Images associated with an event.
-     */
-    @Query("""
-        SELECT imageId FROM image_events
-        WHERE eventId = :eventId
-    """)
-    suspend fun findImagesForEvent(eventId: String): List<String>
-}

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

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

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

@@ -1,53 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import androidx.room.Transaction
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import kotlinx.coroutines.flow.Flow
-
-@Dao
-interface ImageTagDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun upsert(imageTag: ImageTagEntity)
-
-    /**
-     * Observe tags for an image.
-     */
-    @Query("""
-        SELECT * FROM image_tags
-        WHERE imageId = :imageId
-        AND visibility != 'HIDDEN'
-    """)
-    fun observeTagsForImage(imageId: String): Flow<List<ImageTagEntity>>
-
-    /**
-     * Find images by tag.
-     *
-     * This is your primary tag-search query.
-     */
-    @Query("""
-        SELECT imageId FROM image_tags
-        WHERE tagId = :tagId
-        AND visibility = 'PUBLIC'
-        AND confidence >= :minConfidence
-    """)
-    suspend fun findImagesByTag(
-        tagId: String,
-        minConfidence: Float = 0.5f
-    ): List<String>
-
-    @Transaction
-    @Query("""
-        SELECT t.* 
-        FROM tags t
-        INNER JOIN image_tags it ON t.tagId = it.tagId
-        WHERE it.imageId = :imageId AND it.visibility = 'PUBLIC'
-    """)
-    fun getTagsForImage(imageId: String): Flow<List<TagEntity>>
-
-}

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

@@ -1,24 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.PersonEntity
-
-@Dao
-interface PersonDao {
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun insert(person: PersonEntity)
-
-    @Query("SELECT * FROM persons WHERE personId = :personId")
-    suspend fun getById(personId: String): PersonEntity?
-
-    @Query("""
-        SELECT * FROM persons
-        WHERE isHidden = 0
-        ORDER BY displayName
-    """)
-    suspend fun getVisiblePeople(): List<PersonEntity>
-}

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

@@ -1,24 +0,0 @@
-package com.placeholder.sherpai2.data.local.dao
-
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-
-@Dao
-interface TagDao {
-
-    @Insert(onConflict = OnConflictStrategy.IGNORE)
-    suspend fun insert(tag: TagEntity)
-
-    /**
-     * Resolve a tag by value.
-     * Example: "park"
-     */
-    @Query("SELECT * FROM tags WHERE value = :value LIMIT 1")
-    suspend fun getByValue(value: String): TagEntity?
-
-    @Query("SELECT * FROM tags")
-    suspend fun getAll(): List<TagEntity>
-}

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

@@ -1,44 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-
-/**
- * Represents a meaningful event spanning a time range.
- *
- * Events allow auto-association of images by timestamp.
- */
-@Entity(
-    tableName = "events",
-    indices = [
-        Index(value = ["startDate"]),
-        Index(value = ["endDate"])
-    ]
-)
-data class EventEntity(
-
-    @PrimaryKey
-    val eventId: String,
-
-    val name: String,
-
-    /**
-     * Inclusive start date (UTC millis).
-     */
-    val startDate: Long,
-
-    /**
-     * Inclusive end date (UTC millis).
-     */
-    val endDate: Long,
-
-    val location: String?,
-
-    /**
-     * 0.0 – 1.0 importance weight
-     */
-    val importance: Float,
-
-    val isHidden: Boolean
-)

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

@@ -1,55 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-
-/**
- * Represents a single image on the device.
- *
- * This entity is intentionally immutable:
- * - imageUri identifies where the image lives
- * - sha256 prevents duplicates
- * - capturedAt is the EXIF timestamp
- *
- * This table should be append-only.
- */
-@Entity(
-    tableName = "images",
-    indices = [
-        Index(value = ["imageUri"], unique = true),
-        Index(value = ["sha256"], unique = true),
-        Index(value = ["capturedAt"])
-    ]
-)
-data class ImageEntity(
-
-    @PrimaryKey
-    val imageId: String,
-
-    val imageUri: String,
-
-    /**
-     * Cryptographic hash of image bytes.
-     * Used for deduplication and re-indexing.
-     */
-    val sha256: String,
-
-    /**
-     * EXIF timestamp (UTC millis).
-     */
-    val capturedAt: Long,
-
-    /**
-     * When this image was indexed into the app.
-     */
-    val ingestedAt: Long,
-
-    val width: Int,
-    val height: Int,
-
-    /**
-     * CAMERA | SCREENSHOT | IMPORTED
-     */
-    val source: String
-)

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

@@ -1,42 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-
-@Entity(
-    tableName = "image_events",
-    primaryKeys = ["imageId", "eventId"],
-    foreignKeys = [
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = EventEntity::class,
-            parentColumns = ["eventId"],
-            childColumns = ["eventId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("eventId")
-    ]
-)
-data class ImageEventEntity(
-
-    val imageId: String,
-    val eventId: String,
-
-    /**
-     * AUTO | MANUAL
-     */
-    val source: String,
-
-    /**
-     * User override flag.
-     */
-    val override: Boolean
-)

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

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

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

@@ -1,56 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.ForeignKey
-import androidx.room.Index
-
-/**
- * Join table linking images to tags.
- *
- * This is NOT optional.
- * Do not inline tag lists on ImageEntity.
- */
-@Entity(
-    tableName = "image_tags",
-    primaryKeys = ["imageId", "tagId"],
-    foreignKeys = [
-        ForeignKey(
-            entity = ImageEntity::class,
-            parentColumns = ["imageId"],
-            childColumns = ["imageId"],
-            onDelete = ForeignKey.CASCADE
-        ),
-        ForeignKey(
-            entity = TagEntity::class,
-            parentColumns = ["tagId"],
-            childColumns = ["tagId"],
-            onDelete = ForeignKey.CASCADE
-        )
-    ],
-    indices = [
-        Index("tagId"),
-        Index("imageId")
-    ]
-)
-data class ImageTagEntity(
-
-    val imageId: String,
-    val tagId: String,
-
-    /**
-     * AUTO | MANUAL
-     */
-    val source: String,
-
-    /**
-     * ML confidence (0–1).
-     */
-    val confidence: Float,
-
-    /**
-     * PUBLIC | PRIVATE | HIDDEN
-     */
-    val visibility: String,
-
-    val createdAt: Long
-)

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

@@ -1,30 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-/**
- * Represents a known person.
- *
- * People are separate from generic tags because:
- * - face embeddings
- * - privacy rules
- * - identity merging
- */
-@Entity(tableName = "persons")
-data class PersonEntity(
-
-    @PrimaryKey
-    val personId: String,
-
-    val displayName: String,
-
-    /**
-     * Reference to face embedding storage (ML layer).
-     */
-    val faceEmbeddingId: String?,
-
-    val isHidden: Boolean,
-
-    val createdAt: Long
-)

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

@@ -1,30 +0,0 @@
-package com.placeholder.sherpai2.data.local.entity
-
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-/**
- * Represents a conceptual tag.
- *
- * Tags are normalized so that:
- * - "park" exists once
- * - many images can reference it
- */
-@Entity(tableName = "tags")
-data class TagEntity(
-
-    @PrimaryKey
-    val tagId: String,
-
-    /**
-     * GENERIC | SYSTEM | HIDDEN
-     */
-    val type: String,
-
-    /**
-     * Human-readable value, e.g. "park", "sunset"
-     */
-    val value: String,
-
-    val createdAt: Long
-)

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

@@ -1,29 +0,0 @@
-package com.placeholder.sherpai2.data.local.model
-
-import androidx.room.Embedded
-import androidx.room.Relation
-import com.placeholder.sherpai2.data.local.entity.*
-
-data class ImageWithEverything(
-
-    @Embedded
-    val image: ImageEntity,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val tags: List<ImageTagEntity>,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val persons: List<ImagePersonEntity>,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val events: List<ImageEventEntity>
-)

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

@@ -1,18 +0,0 @@
-package com.placeholder.sherpai2.data.local.model
-
-import androidx.room.Embedded
-import androidx.room.Relation
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-
-data class ImageWithTags(
-
-    @Embedded
-    val image: ImageEntity,
-
-    @Relation(
-        parentColumn = "imageId",
-        entityColumn = "imageId"
-    )
-    val tags: List<ImageTagEntity>
-)

app/src/main/java/com/placeholder/sherpai2/data/photos/Photo.kt

@@ -0,0 +1,23 @@
+package com.placeholder.sherpai2.data.photos
+
+import android.net.Uri
+
+data class Photo(
+    val id: Long,
+    val uri: Uri,
+    val title: String? = null,
+    val size: Long,
+    val dateModified: Int
+)
+
+data class Album(
+    val id: String,
+    val title: String,
+    val photos: List<Photo>
+)
+
+data class AlbumPhoto(
+    val id: Int,
+    val imageUrl: String,
+    val description: String
+)

app/src/main/java/com/placeholder/sherpai2/data/repo/FaceRepository.kt

@@ -0,0 +1,90 @@
+package com.placeholder.sherpai2.data.repo
+
+import com.placeholder.sherpai2.data.local.FaceDao
+import com.placeholder.sherpai2.data.local.FaceEntity
+import com.placeholder.sherpai2.domain.util.EmbeddingMath
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/**
+ * Repository for managing face embeddings.
+ *
+ * Handles:
+ *  - Saving new embeddings
+ *  - Querying embeddings
+ *  - Matching a new embedding against stored embeddings
+ */
+class FaceRepository(
+    private val faceDao: FaceDao
+) {
+
+    /**
+     * Save a new face embedding with the given label.
+     */
+    suspend fun saveFace(label: String, embedding: FloatArray): Long =
+        withContext(Dispatchers.IO) {
+            EmbeddingMath.l2Normalize(embedding)
+            val entity = FaceEntity(label = label, embedding = embedding)
+            faceDao.insert(entity)
+        }
+
+    /**
+     * Retrieve all stored embeddings.
+     */
+    suspend fun getAllFaces(): List<FaceEntity> =
+        withContext(Dispatchers.IO) {
+            faceDao.getAllFaces()
+        }
+
+    /**
+     * Find the most similar stored face to the given embedding.
+     *
+     * Returns the matched FaceEntity and similarity metrics,
+     * or null if no match exceeds the provided thresholds.
+     */
+    suspend fun findClosestMatch(
+        embedding: FloatArray,
+        cosineThreshold: Float = 0.80f,
+        euclideanThreshold: Float = 1.10f
+    ): FaceMatchResult? = withContext(Dispatchers.IO) {
+        EmbeddingMath.l2Normalize(embedding)
+
+        val faces = faceDao.getAllFaces()
+        if (faces.isEmpty()) return@withContext null
+
+        var bestMatch: FaceEntity? = null
+        var bestCosine = -1f
+        var bestEuclidean = Float.MAX_VALUE
+
+        for (face in faces) {
+            val storedEmbedding = face.embedding.copyOf()
+            EmbeddingMath.l2Normalize(storedEmbedding)
+
+            val cosine = EmbeddingMath.cosineSimilarity(embedding, storedEmbedding)
+            val euclidean = EmbeddingMath.euclideanDistance(embedding, storedEmbedding)
+
+            if (cosine > bestCosine && euclidean < euclideanThreshold && cosine >= cosineThreshold) {
+                bestCosine = cosine
+                bestEuclidean = euclidean
+                bestMatch = face
+            }
+        }
+
+        bestMatch?.let {
+            FaceMatchResult(
+                face = it,
+                cosineSimilarity = bestCosine,
+                euclideanDistance = bestEuclidean
+            )
+        }
+    }
+}
+
+/**
+ * Result of a face comparison.
+ */
+data class FaceMatchResult(
+    val face: FaceEntity,
+    val cosineSimilarity: Float,
+    val euclideanDistance: Float
+)

app/src/main/java/com/placeholder/sherpai2/data/repo/PhotoRepository.kt

@@ -0,0 +1,58 @@
+package com.placeholder.sherpai2.data.repo
+
+import android.content.Context
+import android.provider.MediaStore
+import android.content.ContentUris
+import android.net.Uri
+import android.os.Environment
+import android.util.Log
+import com.placeholder.sherpai2.data.photos.Photo
+import com.placeholder.sherpai2.domain.PhotoDuplicateScanner
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+
+class PhotoRepository(private val context: Context) {
+
+    fun scanExternalStorage(): Result<List<Photo>> {
+        // Best Practice: Use Environment.getExternalStorageDirectory()
+        // only as a fallback or starting point for legacy support.
+        val rootPath = Environment.getExternalStorageDirectory()
+
+        return runCatching {
+            val photos = mutableListOf<Photo>()
+
+            if (rootPath.exists() && rootPath.isDirectory) {
+                // walkTopDown is efficient but can throw AccessDeniedException
+                rootPath.walkTopDown()
+                    .maxDepth(3) // Performance Best Practice: Don't scan the whole phone
+                    .filter { it.isFile && isImageFile(it.extension) }
+                    .forEach { file ->
+                        photos.add(mapFileToPhoto(file))
+                    }
+            }
+            photos
+        }.onFailure { e ->
+            Log.e("PhotoRepo", "Failed to scan filesystem", e)
+        }
+    }
+
+    private fun mapFileToPhoto(file: File): Photo {
+        return Photo(
+            id = file.path.hashCode().toLong(),
+            uri = Uri.fromFile(file),
+            title = file.name,
+            size = file.length(),
+            dateModified = (file.lastModified() / 1000).toInt()
+        )
+    }
+    fun findDuplicates(photos: Photo) {
+        TODO("Not yet implemented")
+    }
+
+    fun fetchPhotos() {
+        TODO("Not yet implemented")
+    }
+
+    private fun isImageFile(ext: String) = listOf("jpg", "jpeg", "png").contains(ext.lowercase())
+}

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

@@ -1,61 +0,0 @@
-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.dao.ImageAggregateDao
-import com.placeholder.sherpai2.data.local.dao.ImageEventDao
-import com.placeholder.sherpai2.data.local.dao.ImageTagDao
-import com.placeholder.sherpai2.data.local.dao.TagDao
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-object DatabaseModule {
-
-    @Provides
-    @Singleton
-    fun provideDatabase(
-        @ApplicationContext context: Context
-    ): AppDatabase {
-        return Room.databaseBuilder(
-            context,
-            AppDatabase::class.java,
-            "sherpai.db"
-        ).build()
-    }
-
-    // --- Add these DAO providers ---
-
-    @Provides
-    fun provideTagDao(database: AppDatabase): TagDao {
-        return database.tagDao()
-    }
-
-    @Provides
-    fun provideImageTagDao(database: AppDatabase): ImageTagDao {
-        return database.imageTagDao()
-    }
-
-    // Add providers for your other DAOs now to avoid future errors
-    @Provides
-    fun provideImageDao(database: AppDatabase) = database.imageDao()
-
-    @Provides
-    fun providePersonDao(database: AppDatabase) = database.personDao()
-
-    @Provides
-    fun provideEventDao(database: AppDatabase) = database.eventDao()
-
-    @Provides
-    fun provideImageEventDao(database: AppDatabase): ImageEventDao = database.imageEventDao()
-
-    @Provides
-    fun provideImageAggregateDao(database: AppDatabase): ImageAggregateDao = database.imageAggregateDao()
-}
-

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

@@ -1,29 +0,0 @@
-package com.placeholder.sherpai2.di
-
-
-import com.placeholder.sherpai2.data.repository.TaggingRepositoryImpl
-import com.placeholder.sherpai2.domain.repository.ImageRepository
-import com.placeholder.sherpai2.domain.repository.ImageRepositoryImpl
-import com.placeholder.sherpai2.domain.repository.TaggingRepository
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-abstract class RepositoryModule {
-
-    @Binds
-    @Singleton
-    abstract fun bindImageRepository(
-        impl: ImageRepositoryImpl
-    ): ImageRepository
-
-    @Binds
-    @Singleton
-    abstract fun bindTaggingRepository(
-        impl: TaggingRepositoryImpl
-    ): TaggingRepository
-}

app/src/main/java/com/placeholder/sherpai2/domain/PhotoFunctions.kt

@@ -0,0 +1,3 @@
+package com.placeholder.sherpai2.domain
+
+//fun getAllPhotos(context: Context): List<Photo> {

app/src/main/java/com/placeholder/sherpai2/domain/PhotoScanner.kt

@@ -0,0 +1,19 @@
+package com.placeholder.sherpai2.domain
+
+import android.content.Context
+import com.placeholder.sherpai2.data.photos.Photo
+
+class PhotoDuplicateScanner(private val context: Context) {
+
+    /**
+     * Finds duplicate photos by grouping them by file size or name.
+     * In a production app, you might use MD5 hashes or PHash for visual similarity.
+     */
+    fun findDuplicates(allPhotos: List<Photo>): Map<String, List<Photo>> {
+        // Grouping by size is a fast, common way to find potential duplicates
+        return allPhotos
+            .groupBy { it.size } // Groups photos that have the exact same byte size
+            .filter { it.value.size > 1 } // Only keep groups where more than one photo was found
+            .mapKeys { "Size: ${it.key} bytes" } // Create a readable label for the group
+    }
+}

app/src/main/java/com/placeholder/sherpai2/domain/faces/FaceAnalyzer.kt

@@ -0,0 +1,2 @@
+package com.placeholder.sherpai2.domain.faces
+

app/src/main/java/com/placeholder/sherpai2/domain/faces/analyzer/FaceAnalyzer.kt

@@ -0,0 +1,113 @@
+package com.placeholder.sherpai2.domain.faces.analyzer
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.face.Face
+import com.google.mlkit.vision.face.FaceDetection
+import com.google.mlkit.vision.face.FaceDetector
+import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.placeholder.sherpai2.domain.faces.ml.FaceNetInterpreter
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+/**
+ * Orchestrates the full face analysis pipeline for still images:
+ *
+ * 1. Detect faces using ML Kit
+ * 2. Select dominant face
+ * 3. Crop face from bitmap
+ * 4. Generate FaceNet embedding
+ *
+ * This class contains no UI logic and no persistence logic.
+ */
+class FaceAnalyzer(
+    context: Context
+) {
+
+    private val faceDetector: FaceDetector
+    private val faceNet: FaceNetInterpreter
+
+    init {
+        val options = FaceDetectorOptions.Builder()
+            .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+            .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
+            .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
+            .setContourMode(FaceDetectorOptions.CONTOUR_MODE_NONE)
+            .build()
+
+        faceDetector = FaceDetection.getClient(options)
+        faceNet = FaceNetInterpreter(context)
+    }
+
+    /**
+     * Entry point: analyze a bitmap and return its face embedding.
+     *
+     * @throws IllegalStateException if no face is detected
+     */
+    suspend fun analyze(bitmap: Bitmap): FloatArray {
+        val faces = detectFaces(bitmap)
+
+        if (faces.isEmpty()) {
+            throw IllegalStateException("No face detected in image")
+        }
+
+        val primaryFace = selectDominantFace(faces)
+        val croppedFace = cropFace(bitmap, primaryFace)
+        val inputBuffer = faceNet.bitmapToInputBuffer(croppedFace)
+
+        return faceNet.runEmbedding(inputBuffer)
+    }
+
+    /**
+     * Runs ML Kit face detection on a still image.
+     */
+    private suspend fun detectFaces(bitmap: Bitmap): List<Face> =
+        suspendCancellableCoroutine { cont ->
+            val image = InputImage.fromBitmap(bitmap, 0)
+
+            faceDetector.process(image)
+                .addOnSuccessListener { faces ->
+                    cont.resume(faces)
+                }
+                .addOnFailureListener { e ->
+                    cont.resumeWithException(e)
+                }
+        }
+
+    /**
+     * Selects the largest face by bounding box area.
+     */
+    private fun selectDominantFace(faces: List<Face>): Face {
+        return faces.maxBy { face ->
+            face.boundingBox.width() * face.boundingBox.height()
+        }
+    }
+
+    /**
+     * Crops the detected face region from the original bitmap.
+     * Bounds are clamped to avoid IllegalArgumentException.
+     */
+    private fun cropFace(bitmap: Bitmap, face: Face): Bitmap {
+        val box = face.boundingBox
+
+        val left = box.left.coerceAtLeast(0)
+        val top = box.top.coerceAtLeast(0)
+        val right = box.right.coerceAtMost(bitmap.width)
+        val bottom = box.bottom.coerceAtMost(bitmap.height)
+
+        val width = (right - left).coerceAtLeast(1)
+        val height = (bottom - top).coerceAtLeast(1)
+
+        return Bitmap.createBitmap(bitmap, left, top, width, height)
+    }
+
+    /**
+     * Explicit cleanup hook.
+     */
+    fun close() {
+        faceDetector.close()
+        faceNet.close()
+    }
+}

app/src/main/java/com/placeholder/sherpai2/domain/faces/ml/FaceNetInterpreter.kt

@@ -0,0 +1,111 @@
+package com.placeholder.sherpai2.domain.faces.ml
+
+import android.content.Context
+import android.graphics.Bitmap
+import org.tensorflow.lite.Interpreter
+import org.tensorflow.lite.support.common.FileUtil
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/**
+ * Thin wrapper around TensorFlow Lite Interpreter.
+ * Responsible ONLY for:
+ *  - Loading the model
+ *  - Preparing input buffers
+ *  - Running inference
+ */
+class FaceNetInterpreter(
+    context: Context
+) {
+
+    private val interpreter: Interpreter
+
+    init {
+        val modelBuffer = FileUtil.loadMappedFile(
+            context,
+            ModelConstants.MODEL_FILE_NAME
+        )
+
+        val options = Interpreter.Options().apply {
+            setNumThreads(4)
+            // GPU delegate intentionally NOT enabled yet
+        }
+
+        interpreter = Interpreter(modelBuffer, options)
+    }
+
+    /**
+     * Converts a face bitmap into a normalized input buffer.
+     * Expects a tightly-cropped face.
+     */
+    fun bitmapToInputBuffer(bitmap: Bitmap): ByteBuffer {
+        val resized = Bitmap.createScaledBitmap(
+            bitmap,
+            ModelConstants.INPUT_WIDTH,
+            ModelConstants.INPUT_HEIGHT,
+            true
+        )
+
+        val buffer = ByteBuffer.allocateDirect(
+            1 *
+                    ModelConstants.INPUT_WIDTH *
+                    ModelConstants.INPUT_HEIGHT *
+                    ModelConstants.INPUT_CHANNELS *
+                    4
+        ).apply {
+            order(ByteOrder.nativeOrder())
+        }
+
+        val pixels = IntArray(
+            ModelConstants.INPUT_WIDTH * ModelConstants.INPUT_HEIGHT
+        )
+
+        resized.getPixels(
+            pixels,
+            0,
+            ModelConstants.INPUT_WIDTH,
+            0,
+            0,
+            ModelConstants.INPUT_WIDTH,
+            ModelConstants.INPUT_HEIGHT
+        )
+
+        for (pixel in pixels) {
+            buffer.putFloat(
+                ((pixel shr 16 and 0xFF) - ModelConstants.IMAGE_MEAN) /
+                        ModelConstants.IMAGE_STD
+            )
+            buffer.putFloat(
+                ((pixel shr 8 and 0xFF) - ModelConstants.IMAGE_MEAN) /
+                        ModelConstants.IMAGE_STD
+            )
+            buffer.putFloat(
+                ((pixel and 0xFF) - ModelConstants.IMAGE_MEAN) /
+                        ModelConstants.IMAGE_STD
+            )
+        }
+
+        buffer.rewind()
+        return buffer
+    }
+
+    /**
+     * Runs FaceNet inference and returns the embedding vector.
+     */
+    fun runEmbedding(inputBuffer: ByteBuffer): FloatArray {
+        val output = Array(1) {
+            FloatArray(ModelConstants.EMBEDDING_SIZE)
+        }
+
+        interpreter.run(inputBuffer, output)
+
+        return output[0]
+    }
+
+    /**
+     * Clean up explicitly when the app shuts down.
+     */
+    fun close() {
+        interpreter.close()
+    }
+}

app/src/main/java/com/placeholder/sherpai2/domain/faces/ml/ModelConstants.kt

@@ -0,0 +1,27 @@
+package com.placeholder.sherpai2.domain.faces.ml
+
+/**
+ * Centralized constants for FaceNet-style models.
+ * Changing models should only require edits in this file.
+ */
+object ModelConstants {
+
+    // FaceNet standard input size
+    const val INPUT_WIDTH = 160
+    const val INPUT_HEIGHT = 160
+    const val INPUT_CHANNELS = 3
+
+    // Output embedding size (FaceNet variants are typically 128 or 512)
+    const val EMBEDDING_SIZE = 128
+
+    // Normalization constants (FaceNet expects [-1, 1])
+    const val IMAGE_MEAN = 127.5f
+    const val IMAGE_STD = 128.0f
+
+    // Asset path
+    const val MODEL_FILE_NAME = "facenet_model.tflite"
+
+    // Similarity thresholds (tunable later)
+    const val COSINE_SIMILARITY_THRESHOLD = 0.80f
+    const val EUCLIDEAN_DISTANCE_THRESHOLD = 1.10f
+}

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

@@ -1,33 +0,0 @@
-package com.placeholder.sherpai2.domain.repository
-
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-import kotlinx.coroutines.flow.Flow
-
-/**
- * Canonical access point for images.
- *
- * ViewModels must NEVER talk directly to DAOs.
- */
-interface ImageRepository {
-
-    /**
-     * Observe a fully-hydrated image graph.
-     *
-     * Used by detail screens.
-     */
-    fun observeImage(imageId: String): Flow<ImageWithEverything>
-
-    /**
-     * Ingest images discovered on device.
-     *
-     * This function:
-     * - deduplicates
-     * - assigns events automatically
-     */
-    suspend fun ingestImages()
-
-    fun getAllImages(): Flow<List<ImageWithEverything>>
-    fun findImagesByTag(tag: String): Flow<List<ImageWithEverything>>
-
-    fun getRecentImages(limit: Int): Flow<List<ImageWithEverything>>
-}

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

@@ -1,147 +0,0 @@
-package com.placeholder.sherpai2.domain.repository
-
-import android.content.ContentUris
-import android.content.Context
-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.ImageAggregateDao
-import com.placeholder.sherpai2.data.local.dao.ImageDao
-import com.placeholder.sherpai2.data.local.dao.ImageEventDao
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.withContext
-import java.security.MessageDigest
-import java.util.*
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class ImageRepositoryImpl @Inject constructor(
-    private val imageDao: ImageDao,
-    private val eventDao: EventDao,
-    private val imageEventDao: ImageEventDao,
-    private val aggregateDao: ImageAggregateDao,
-    @ApplicationContext private val context: Context
-) : ImageRepository {
-
-    override fun observeImage(imageId: String): Flow<ImageWithEverything> {
-        return aggregateDao.observeImageWithEverything(imageId)
-    }
-
-    /**
-     * 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 ingestImages(): 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
-            )
-
-            val sortOrder = "${MediaStore.Images.Media.DATE_ADDED} ASC"
-
-            context.contentResolver.query(
-                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
-                projection,
-                null,
-                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)
-
-                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 contentUri: Uri = ContentUris.withAppendedId(
-                        MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id
-                    )
-
-                    val sha256 = computeSHA256(contentUri)
-                    if (sha256 == null) {
-                        Log.w("ImageRepository", "Skipped image: $displayName (cannot read bytes)")
-                        continue
-                    }
-
-                    val imageEntity = ImageEntity(
-                        imageId = UUID.randomUUID().toString(),
-                        imageUri = contentUri.toString(),
-                        sha256 = sha256,
-                        capturedAt = if (dateTaken > 0) dateTaken else dateAdded * 1000,
-                        ingestedAt = System.currentTimeMillis(),
-                        width = width,
-                        height = height,
-                        source = "CAMERA" // or SCREENSHOT / IMPORTED
-                    )
-
-                    imageList += imageEntity
-                    Log.i("ImageRepository", "Processing image: $displayName, SHA256: $sha256")
-                }
-            }
-
-            if (imageList.isNotEmpty()) {
-                imageDao.insertImages(imageList)
-                Log.i("ImageRepository", "Ingested ${imageList.size} images")
-            } else {
-                Log.i("ImageRepository", "No images found on device")
-            }
-
-        } catch (e: Exception) {
-            Log.e("ImageRepository", "Error ingesting images", e)
-        }
-    }
-
-    /**
-     * Compute SHA256 from a MediaStore Uri safely.
-     */
-    private fun computeSHA256(uri: Uri): String? {
-        return try {
-            val digest = MessageDigest.getInstance("SHA-256")
-            context.contentResolver.openInputStream(uri)?.use { input ->
-                val buffer = ByteArray(8192)
-                var read: Int
-                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
-        }
-    }
-
-    override fun getAllImages(): Flow<List<ImageWithEverything>> {
-        return aggregateDao.observeAllImagesWithEverything()
-    }
-
-    override fun findImagesByTag(tag: String): Flow<List<ImageWithEverything>> {
-        return aggregateDao.observeImagesWithTag(tag)
-    }
-
-    override fun getRecentImages(limit: Int): Flow<List<ImageWithEverything>> {
-        return imageDao.getRecentImages(limit)
-    }
-}

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

@@ -1,30 +0,0 @@
-package com.placeholder.sherpai2.domain.repository
-
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import kotlinx.coroutines.flow.Flow
-
-/**
- * Handles all tagging operations.
- *
- * This repository is the ONLY place where:
- * - tags are attached
- * - visibility rules are applied
- */
-interface TaggingRepository {
-
-    suspend fun addTagToImage(
-        imageId: String,
-        tagValue: String,
-        source: String,
-        confidence: Float
-    )
-
-    suspend fun hideTagForImage(
-        imageId: String,
-        tagValue: String
-    )
-
-    fun getTagsForImage(imageId: String): Flow<List<TagEntity>>
-
-    suspend fun removeTagFromImage(imageId: String, tagId: String)
-}

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

@@ -1,97 +0,0 @@
-package com.placeholder.sherpai2.data.repository
-
-import com.placeholder.sherpai2.data.local.dao.ImageTagDao
-import com.placeholder.sherpai2.data.local.dao.TagDao
-import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import com.placeholder.sherpai2.domain.repository.TaggingRepository
-import kotlinx.coroutines.flow.Flow
-import javax.inject.Inject
-import javax.inject.Singleton
-
-/**
- *
- *
- * Critical design decisions here
- *
- * Tag normalization happens once
- *
- * Visibility rules live here
- *
- * ML and manual tagging share the same path
- */
-
-@Singleton
-class TaggingRepositoryImpl @Inject constructor(
-    private val tagDao: TagDao,
-    private val imageTagDao: ImageTagDao
-) : TaggingRepository {
-
-    override suspend fun addTagToImage(
-        imageId: String,
-        tagValue: String,
-        source: String,
-        confidence: Float
-    ) {
-        // Step 1: normalize tag
-        val normalized = tagValue.trim().lowercase()
-
-        // Step 2: ensure tag exists
-        val tag = tagDao.getByValue(normalized)
-            ?: TagEntity(
-                tagId = "tag_$normalized",
-                type = "GENERIC",
-                value = normalized,
-                createdAt = System.currentTimeMillis()
-            ).also { tagDao.insert(it) }
-
-        // Step 3: attach tag to image
-        imageTagDao.upsert(
-            ImageTagEntity(
-                imageId = imageId,
-                tagId = tag.tagId,
-                source = source,
-                confidence = confidence,
-                visibility = "PUBLIC",
-                createdAt = System.currentTimeMillis()
-            )
-        )
-    }
-
-    override suspend fun hideTagForImage(
-        imageId: String,
-        tagValue: String
-    ) {
-        val tag = tagDao.getByValue(tagValue) ?: return
-
-        imageTagDao.upsert(
-            ImageTagEntity(
-                imageId = imageId,
-                tagId = tag.tagId,
-                source = "MANUAL",
-                confidence = 1.0f,
-                visibility = "HIDDEN",
-                createdAt = System.currentTimeMillis()
-            )
-        )
-    }
-
-    override fun getTagsForImage(imageId: String): Flow<List<TagEntity>> {
-        // Join imageTagDao -> tagDao to get all PUBLIC tags for this image
-        return imageTagDao.getTagsForImage(imageId)
-    }
-
-    override suspend fun removeTagFromImage(imageId: String, tagId: String) {
-        // Mark the tag as hidden instead of deleting, keeping the visibility logic
-        imageTagDao.upsert(
-            ImageTagEntity(
-                imageId = imageId,
-                tagId = tagId,
-                source = "MANUAL",
-                confidence = 1.0f,
-                visibility = "HIDDEN",
-                createdAt = System.currentTimeMillis()
-            )
-        )
-    }
-}

app/src/main/java/com/placeholder/sherpai2/domain/util/EmbeddingMath.kt.kt

@@ -0,0 +1,59 @@
+package com.placeholder.sherpai2.domain.util
+import kotlin.math.sqrt
+
+/**
+ * Utilities for operating on FaceNet-style embeddings.
+ *
+ * All functions are pure and testable.
+ */
+object EmbeddingMath {
+
+    /**
+     * L2-normalizes a float array in place.
+     * Ensures embedding vectors have unit length for cosine similarity.
+     */
+    fun l2Normalize(embedding: FloatArray) {
+        var sum = 0.0
+        for (v in embedding) {
+            sum += (v * v)
+        }
+        val norm = sqrt(sum)
+        if (norm > 0.0) {
+            for (i in embedding.indices) {
+                embedding[i] = (embedding[i] / norm).toFloat()
+            }
+        }
+    }
+
+    /**
+     * Computes cosine similarity between two embeddings.
+     * Both embeddings should be L2-normalized for correct results.
+     * Returns value in [-1, 1], higher = more similar.
+     */
+    fun cosineSimilarity(a: FloatArray, b: FloatArray): Float {
+        require(a.size == b.size) { "Embedding size mismatch: ${a.size} != ${b.size}" }
+
+        var dot = 0.0f
+        for (i in a.indices) {
+            dot += a[i] * b[i]
+        }
+
+        return dot
+    }
+
+    /**
+     * Computes Euclidean distance between two embeddings.
+     * Returns a non-negative float; smaller = more similar.
+     */
+    fun euclideanDistance(a: FloatArray, b: FloatArray): Float {
+        require(a.size == b.size) { "Embedding size mismatch: ${a.size} != ${b.size}" }
+
+        var sum = 0.0f
+        for (i in a.indices) {
+            val diff = a[i] - b[i]
+            sum += diff * diff
+        }
+
+        return sqrt(sum)
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/devscreens/DummyScreen.kt

@@ -1,17 +0,0 @@
-package com.placeholder.sherpai2.ui.devscreens
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-
-@Composable
-fun DummyScreen(label: String) {
-    Box(
-        modifier = Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center
-    ) {
-        Text(label)
-    }
-}

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

@@ -1,86 +0,0 @@
-package com.placeholder.sherpai2.ui.imagedetail
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import coil.compose.AsyncImage
-import com.placeholder.sherpai2.ui.imagedetail.viewmodel.ImageDetailViewModel
-
-
-
-
-/**
- * ImageDetailScreen
- *
- * Purpose:
- *  - Add tags
- *  - Remove tags
- *  - Validate write propagation
- */
-@Composable
-fun ImageDetailScreen(
-    modifier: Modifier = Modifier,
-    imageUri: String,
-    onBack: () -> Unit
-) {
-    val viewModel: ImageDetailViewModel = androidx.lifecycle.viewmodel.compose.viewModel()
-
-    LaunchedEffect(imageUri) {
-        viewModel.loadImage(imageUri)
-    }
-
-    val tags by viewModel.tags.collectAsStateWithLifecycle()
-
-    var newTag by remember { mutableStateOf("") }
-
-    Column(
-        modifier = modifier
-            .fillMaxSize()
-            .padding(12.dp)
-    ) {
-
-        AsyncImage(
-            model = imageUri,
-            contentDescription = null,
-            modifier = Modifier
-                .fillMaxWidth()
-                .aspectRatio(1f)
-        )
-
-        Spacer(modifier = Modifier.height(12.dp))
-
-        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.SpaceBetween,
-                modifier = Modifier.fillMaxWidth()
-            ) {
-                Text(tag.value)
-                TextButton(onClick = { viewModel.removeTag(tag) }) {
-                    Text("Remove")
-                }
-            }
-        }
-    }
-}

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

@@ -1,57 +0,0 @@
-package com.placeholder.sherpai2.ui.imagedetail.viewmodel
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.data.local.entity.TagEntity
-import com.placeholder.sherpai2.domain.repository.TaggingRepository
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * ImageDetailViewModel
- *
- * Owns:
- *  - Image context
- *  - Tag write operations
- */
-@HiltViewModel
-@OptIn(ExperimentalCoroutinesApi::class)
-class ImageDetailViewModel @Inject constructor(
-    private val tagRepository: TaggingRepository
-) : ViewModel() {
-
-    private val imageUri = MutableStateFlow<String?>(null)
-
-    val tags: StateFlow<List<TagEntity>> =
-        imageUri
-            .filterNotNull()
-            .flatMapLatest { uri ->
-                tagRepository.getTagsForImage(uri)
-            }
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(5_000),
-                initialValue = emptyList()
-            )
-
-    fun loadImage(uri: String) {
-        imageUri.value = uri
-    }
-
-    fun addTag(value: String) {
-        val uri = imageUri.value ?: return
-        viewModelScope.launch {
-            tagRepository.addTagToImage(uri, value, source = "MANUAL", confidence = 1.0f)
-        }
-    }
-
-    fun removeTag(tag: TagEntity) {
-        val uri = imageUri.value ?: return
-        viewModelScope.launch {
-            tagRepository.removeTagFromImage(uri, tag.value)
-        }
-    }
-}

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

@@ -1,46 +1,33 @@
+// In navigation/AppDestinations.kt
 package com.placeholder.sherpai2.ui.navigation
 
+/**
+ * Defines all navigation destinations (screens) for the application.
+ */
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
 import androidx.compose.ui.graphics.vector.ImageVector
 
 /**
- * Drawer-only metadata.
- *
- * These objects:
- * - Drive the drawer UI
- * - Provide labels and icons
- * - Map cleanly to navigation routes
+ * Defines all navigation destinations (screens) for the application.
+ * Changed to 'enum class' to enable built-in iteration (.entries) for NavHost.
  */
-sealed class AppDestinations(
-    val route: String,
-    val icon: ImageVector,
-    val label: String
-) {
-    object Tour : AppDestinations(AppRoutes.TOUR, Icons.Default.PhotoLibrary, "Tour")
-    object Search : AppDestinations(AppRoutes.SEARCH, Icons.Default.Search, "Search")
-    object Models : AppDestinations(AppRoutes.MODELS, Icons.Default.Layers, "Models")
-    object Inventory : AppDestinations(AppRoutes.INVENTORY, Icons.Default.Inventory2, "Inv")
-    object Train : AppDestinations(AppRoutes.TRAIN, Icons.Default.TrackChanges, "Train")
-    object Tags : AppDestinations(AppRoutes.TAGS, Icons.Default.LocalOffer, "Tags")
+enum class AppDestinations(val route: String, val icon: ImageVector, val label: String) {
+    // Core Functional Sections
+    Tour("tour", Icons.Default.PhotoLibrary, "Tour"),
+    Search("search", Icons.Default.Search, "Search"),
+    Models("models", Icons.Default.Layers, "Models"),
+    Inventory("inv", Icons.Default.Inventory2, "Inventory"),
+    Train("train", Icons.Default.TrackChanges, "Train"),
+    Tags("tags", Icons.Default.LocalOffer, "Tags"),
 
-    object ImageDetails : AppDestinations(AppRoutes.IMAGE_DETAIL, Icons.Default.LocalOffer, "IMAGE_DETAIL")
+    // Utility/Secondary Sections
+    Upload("upload", Icons.Default.CloudUpload, "Upload"),
+    Settings("settings", Icons.Default.Settings, "Settings");
 
-    object Upload : AppDestinations(AppRoutes.UPLOAD, Icons.Default.CloudUpload, "Upload")
-    object Settings : AppDestinations(AppRoutes.SETTINGS, Icons.Default.Settings, "Settings")
+    companion object {
+        // High-level grouping for the Drawer UI
+        val mainDrawerItems = listOf(Tour, Search, Models, Inventory, Train, Tags)
+        val utilityDrawerItems = listOf(Upload, Settings)
+    }
 }
-
-val mainDrawerItems = listOf(
-    AppDestinations.Tour,
-    AppDestinations.Search,
-    AppDestinations.Models,
-    AppDestinations.Inventory,
-    AppDestinations.Train,
-    AppDestinations.Tags,
-    AppDestinations.ImageDetails
-)
-
-val utilityDrawerItems = listOf(
-    AppDestinations.Upload,
-    AppDestinations.Settings
-)

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

@@ -1,145 +0,0 @@
-package com.placeholder.sherpai2.ui.navigation
-
-import android.net.Uri
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.ViewModel
-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.imagedetail.ImageDetailScreen
-import com.placeholder.sherpai2.ui.search.SearchScreen
-import com.placeholder.sherpai2.ui.search.SearchViewModel
-import java.net.URLDecoder
-import java.net.URLEncoder
-import com.placeholder.sherpai2.ui.tour.TourViewModel
-import com.placeholder.sherpai2.ui.tour.TourScreen
-import com.placeholder.sherpai2.ui.trainingprep.ImageSelectorScreen
-import com.placeholder.sherpai2.ui.trainingprep.TrainingScreen
-import com.placeholder.sherpai2.ui.navigation.AppRoutes
-import com.placeholder.sherpai2.ui.navigation.AppRoutes.ScanResultsScreen
-import com.placeholder.sherpai2.ui.trainingprep.ScanningState
-import com.placeholder.sherpai2.ui.trainingprep.TrainViewModel
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import com.placeholder.sherpai2.ui.trainingprep.ScanResultsScreen
-
-
-
-@Composable
-fun AppNavHost(
-    navController: NavHostController,
-    modifier: Modifier = Modifier
-) {
-    NavHost(
-        navController = navController,
-        startDestination = AppRoutes.SEARCH,
-        modifier = modifier
-    ) {
-
-        /** SEARCH SCREEN **/
-        composable(AppRoutes.SEARCH) {
-            val searchViewModel: SearchViewModel = hiltViewModel()
-            SearchScreen(
-                searchViewModel = searchViewModel,
-                onImageClick = { imageUri ->
-                    // Encode the URI to safely pass as argument
-                    val encodedUri = URLEncoder.encode(imageUri, "UTF-8")
-                    navController.navigate("${AppRoutes.IMAGE_DETAIL}/$encodedUri")
-                }
-            )
-        }
-
-        /** IMAGE DETAIL SCREEN **/
-        composable(
-            route = "${AppRoutes.IMAGE_DETAIL}/{imageUri}",
-            arguments = listOf(
-                navArgument("imageUri") {
-                    type = NavType.StringType
-                }
-            )
-        ) { backStackEntry ->
-
-            // Decode URI to restore original value
-            val imageUri = backStackEntry.arguments?.getString("imageUri")
-                ?.let { URLDecoder.decode(it, "UTF-8") }
-                ?: error("imageUri missing from navigation")
-
-            ImageDetailScreen(
-                imageUri = imageUri,
-                onBack = { navController.popBackStack() }
-            )
-        }
-
-        composable(AppRoutes.TOUR) {
-            val tourViewModel: TourViewModel = hiltViewModel()
-            TourScreen(
-                tourViewModel = tourViewModel,
-                onImageClick = { imageUri ->
-                    navController.navigate("${AppRoutes.IMAGE_DETAIL}/$imageUri")
-                }
-            )
-        }
-
-        /** TRAINING FLOW **/
-        composable(AppRoutes.TRAIN) { entry ->
-            val trainViewModel: TrainViewModel = hiltViewModel()
-            val uiState by trainViewModel.uiState.collectAsState()
-
-            // Observe the result from the ImageSelector
-            val selectedUris = entry.savedStateHandle.get<List<Uri>>("selected_image_uris")
-
-            // If we have new URIs and we are currently Idle, start scanning
-            LaunchedEffect(selectedUris) {
-                if (selectedUris != null && uiState is ScanningState.Idle) {
-                    trainViewModel.scanAndTagFaces(selectedUris)
-                    // Clear the handle so it doesn't re-trigger on configuration change
-                    entry.savedStateHandle.remove<List<Uri>>("selected_image_uris")
-                }
-            }
-
-            if (uiState is ScanningState.Idle) {
-                // Initial state: Show start button or prompt
-                TrainingScreen(
-                    onSelectImages = { navController.navigate(AppRoutes.IMAGE_SELECTOR) }
-                )
-            } else {
-                // Processing or Success state: Show the results screen
-                ScanResultsScreen(
-                    state = uiState,
-                    onFinish = {
-                        navController.navigate(AppRoutes.SEARCH) {
-                            popUpTo(AppRoutes.TRAIN) { inclusive = true }
-                        }
-                    }
-                )
-            }
-        }
-
-        composable(AppRoutes.IMAGE_SELECTOR) {
-            ImageSelectorScreen(
-                onImagesSelected = { uris ->
-                    navController.previousBackStackEntry
-                        ?.savedStateHandle
-                        ?.set("selected_image_uris", uris)
-
-                    navController.popBackStack()
-                }
-            )
-        }
-
-        /** DUMMY SCREENS FOR OTHER DRAWER ITEMS **/
-        //composable(AppRoutes.TOUR) { DummyScreen("Tour (stub)") }
-        composable(AppRoutes.MODELS) { DummyScreen("Models (stub)") }
-        composable(AppRoutes.INVENTORY) { DummyScreen("Inventory (stub)") }
-        //composable(AppRoutes.TRAIN) { DummyScreen("Train (stub)") }
-        composable(AppRoutes.TAGS) { DummyScreen("Tags (stub)") }
-        composable(AppRoutes.UPLOAD) { DummyScreen("Upload (stub)") }
-        composable(AppRoutes.SETTINGS) { DummyScreen("Settings (stub)") }        
-    }
-}

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

@@ -1,32 +0,0 @@
-package com.placeholder.sherpai2.ui.navigation
-
-/**
- * Centralized list of navigation routes used by NavHost.
- *
- * This intentionally mirrors AppDestinations.route
- * but exists as a pure navigation concern.
- *
- * Why:
- * - Drawer UI ≠ Navigation system
- * - Keeps NavHost decoupled from icons / labels
- */
-object AppRoutes {
-    const val TOUR = "tour"
-    const val SEARCH = "search"
-    const val MODELS = "models"
-    const val INVENTORY = "inv"
-    const val TRAIN = "train"
-    const val TAGS = "tags"
-    const val UPLOAD = "upload"
-    const val SETTINGS = "settings"
-    const val IMAGE_DETAIL = "IMAGE_DETAIL"
-
-    const val CROP_SCREEN = "CROP_SCREEN"
-    const val IMAGE_SELECTOR = "Image Selection"
-    const val TRAINING_SCREEN = "TRAINING_SCREEN"
-
-    const val ScanResultsScreen = "First Scan Results"
-
-
-    //const val IMAGE_DETAIL = "IMAGE_DETAIL"
-}

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

@@ -1,82 +1,57 @@
+// In presentation/AppDrawerContent.kt
 package com.placeholder.sherpai2.ui.presentation
 
 import androidx.compose.foundation.layout.*
 import androidx.compose.material3.*
-import androidx.compose.material3.DividerDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.Label
-import androidx.compose.material.icons.automirrored.filled.List
-import androidx.compose.material.icons.filled.*
-import androidx.compose.material3.HorizontalDivider
-import com.placeholder.sherpai2.ui.navigation.AppRoutes
+import com.placeholder.sherpai2.ui.navigation.AppDestinations
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun AppDrawerContent(
-    currentRoute: String?,
-    onDestinationClicked: (String) -> Unit
+    currentScreen: AppDestinations,
+    onDestinationClicked: (AppDestinations) -> Unit
 ) {
-    // Drawer sheet with fixed width
     ModalDrawerSheet(modifier = Modifier.width(280.dp)) {
 
-        // Header / Logo
+        // Header Area
         Text(
-            "SherpAI Control Panel",
+            text = "SherpAI Control Panel",
             style = MaterialTheme.typography.headlineSmall,
             modifier = Modifier.padding(16.dp)
         )
 
-        HorizontalDivider(
-            Modifier.fillMaxWidth(),
-            thickness = DividerDefaults.Thickness,
-            color = DividerDefaults.color
-        )
-
-        // Main drawer items
-        val mainItems = listOf(
-            Triple(AppRoutes.SEARCH, "Search", Icons.Default.Search),
-            Triple(AppRoutes.TOUR, "Tour", Icons.Default.Place),
-            Triple(AppRoutes.MODELS, "Models", Icons.Default.ModelTraining),
-            Triple(AppRoutes.INVENTORY, "Inventory", Icons.AutoMirrored.Filled.List),
-            Triple(AppRoutes.TRAIN, "Train", Icons.Default.Train),
-            Triple(AppRoutes.TAGS, "Tags", Icons.AutoMirrored.Filled.Label)
-        )
+        HorizontalDivider(modifier = Modifier.fillMaxWidth())
 
+        // 1. Main Navigation Items (Referencing the Companion Object)
         Column(modifier = Modifier.padding(vertical = 8.dp)) {
-            mainItems.forEach { (route, label, icon) ->
+            AppDestinations.mainDrawerItems.forEach { destination ->
                 NavigationDrawerItem(
-                    label = { Text(label) },
-                    icon = { Icon(icon, contentDescription = label) },
-                    selected = route == currentRoute,
-                    onClick = { onDestinationClicked(route) },
+                    label = { Text(destination.label) },
+                    icon = { Icon(destination.icon, contentDescription = destination.label) },
+                    selected = destination == currentScreen,
+                    onClick = { onDestinationClicked(destination) },
                     modifier = Modifier.padding(NavigationDrawerItemDefaults.ItemPadding)
                 )
             }
         }
 
-        Divider(
-            Modifier
+        // Separator
+        HorizontalDivider(
+            modifier = Modifier
                 .fillMaxWidth()
-                .padding(vertical = 8.dp),
-            thickness = DividerDefaults.Thickness
-        )
-
-        // Utility items
-        val utilityItems = listOf(
-        Triple(AppRoutes.UPLOAD, "Upload", Icons.Default.UploadFile),
-        Triple(AppRoutes.SETTINGS, "Settings", Icons.Default.Settings)
+                .padding(vertical = 8.dp)
         )
 
+        // 2. Utility Items (Referencing the Companion Object)
         Column(modifier = Modifier.padding(vertical = 8.dp)) {
-            utilityItems.forEach { (route, label, icon) ->
+            AppDestinations.utilityDrawerItems.forEach { destination ->
                 NavigationDrawerItem(
-                    label = { Text(label) },
-                    icon = { Icon(icon, contentDescription = label) },
-                    selected = route == currentRoute,
-                    onClick = { onDestinationClicked(route) },
+                    label = { Text(destination.label) },
+                    icon = { Icon(destination.icon, contentDescription = destination.label) },
+                    selected = destination == currentScreen,
+                    onClick = { onDestinationClicked(destination) },
                     modifier = Modifier.padding(NavigationDrawerItemDefaults.ItemPadding)
                 )
             }

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

@@ -0,0 +1,78 @@
+// In presentation/MainContentArea.kt
+package com.placeholder.sherpai2.ui.presentation
+
+
+import GalleryScreen
+import GalleryViewModel
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import com.placeholder.sherpai2.ui.navigation.AppDestinations
+import com.placeholder.sherpai2.ui.screens.managephotos.ManagePhotosScreen
+import com.placeholder.sherpai2.ui.screens.managephotos.ManagePhotosViewModel
+@Composable
+fun MainContentArea(
+    navController: NavHostController, // Standard MAD practice: pass the controller
+    modifier: Modifier = Modifier
+) {
+    // NavHost acts as the "Gallery Building"
+    NavHost(
+        navController = navController,
+        startDestination = AppDestinations.Tour.route, // Using your enum routes
+        modifier = modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.background)
+    ) {
+        // Destination: Tour (Gallery)
+        composable(AppDestinations.Tour.route) {
+            val galleryViewModel: GalleryViewModel = viewModel()
+            val uiState by galleryViewModel.uiState.collectAsState()
+
+            GalleryScreen(state = uiState)
+        }
+
+        // Destination: Inventory (Manage Photos)
+        composable(AppDestinations.Inventory.route) {
+            // New ViewModel scoped to this specific screen package
+            val manageViewModel: ManagePhotosViewModel = viewModel()
+            val manageState by manageViewModel.uiState.collectAsState()
+
+            ManagePhotosScreen(
+                state = manageState,
+                onCleanUpClick = { manageViewModel.performCleanUp() },
+                onCountTagsClick = { manageViewModel.countByTag() },
+                onStatsClick = { manageViewModel.loadStats() }
+            )
+        }
+
+        // Placeholders for other routes
+        composable(AppDestinations.Search.route) { SimplePlaceholder("Find Any Photos.") }
+        composable(AppDestinations.Settings.route) { SimplePlaceholder("Settings Screen.") }
+        // ... add other destinations similarly
+    }
+}
+
+@Composable
+private fun SimplePlaceholder(text: String) {
+    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+        Text(
+            text = text,
+            style = MaterialTheme.typography.titleLarge,
+            modifier = Modifier
+                .padding(16.dp)
+                .background(color = Color.Magenta.copy(alpha = 0.2f))
+        )
+    }
+}

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

@@ -1,4 +1,5 @@
-package com.placeholder.sherpai2.ui.presentation
+// In presentation/MainScreen.kt
+package com.placeholder.sherpai2.presentation
 
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
@@ -6,51 +7,55 @@ import androidx.compose.material.icons.filled.Menu
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.navigation.NavController
+import androidx.navigation.NavGraph.Companion.findStartDestination
 import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
-import com.placeholder.sherpai2.ui.navigation.AppNavHost
-import com.placeholder.sherpai2.ui.navigation.AppRoutes
+import com.placeholder.sherpai2.ui.navigation.AppDestinations
+import com.placeholder.sherpai2.ui.presentation.AppDrawerContent
+import com.placeholder.sherpai2.ui.presentation.MainContentArea
 import kotlinx.coroutines.launch
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun MainScreen() {
+    // 1. The 'Tour Guide' (NavController) replaces the 'currentScreen' state
+    val navController = rememberNavController()
     val drawerState = rememberDrawerState(initialValue = DrawerValue.Closed)
     val scope = rememberCoroutineScope()
 
-    // Navigation controller for NavHost
-    val navController = rememberNavController()
-
-    // Track current backstack entry to update top bar title dynamically
+    // 2. Observe the backstack to determine the current screen for the UI (TopBar/Drawer)
     val navBackStackEntry by navController.currentBackStackEntryAsState()
-    val currentRoute = navBackStackEntry?.destination?.route ?: AppRoutes.SEARCH
+    val currentRoute = navBackStackEntry?.destination?.route ?: AppDestinations.Search.route
+
+    // Find the current destination object based on the route string
+    val currentScreen = AppDestinations.values().find { it.route == currentRoute } ?: AppDestinations.Search
 
-    // Drawer content for navigation
     ModalNavigationDrawer(
         drawerState = drawerState,
         drawerContent = {
             AppDrawerContent(
-                currentRoute = currentRoute,
-                onDestinationClicked = { route ->
-                    scope.launch {
-                        drawerState.close()
-                        if (route != currentRoute) {
-                            navController.navigate(route) {
-                                // Avoid multiple copies of the same destination
-                                launchSingleTop = true
-                            }
+                currentScreen = currentScreen,
+                onDestinationClicked = { destination ->
+                    // 3. Best Practice: Navigate with state restoration
+                    navController.navigate(destination.route) {
+                        // Pop up to the start destination to avoid building a huge backstack
+                        popUpTo(navController.graph.findStartDestination().id) {
+                            saveState = true
                         }
+                        // Avoid multiple copies of the same destination when re-selecting
+                        launchSingleTop = true
+                        // Restore state when re-selecting a previously selected item
+                        restoreState = true
                     }
+                    scope.launch { drawerState.close() }
                 }
             )
         },
     ) {
-        // Main scaffold with top bar
         Scaffold(
             topBar = {
                 TopAppBar(
-                    title = { Text(currentRoute.replaceFirstChar { it.uppercase() }) },
+                    title = { Text(currentScreen.label) },
                     navigationIcon = {
                         IconButton(onClick = { scope.launch { drawerState.open() } }) {
                             Icon(Icons.Filled.Menu, contentDescription = "Open Drawer")
@@ -59,7 +64,8 @@ fun MainScreen() {
                 )
             }
         ) { paddingValues ->
-            AppNavHost(
+            // 4. Pass the navController to the Content Area
+            MainContentArea(
                 navController = navController,
                 modifier = Modifier.padding(paddingValues)
             )

app/src/main/java/com/placeholder/sherpai2/ui/screens/managephotos/ManagePhotosScreen.kt

@@ -0,0 +1,124 @@
+package com.placeholder.sherpai2.ui.screens.managephotos
+
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.repo.PhotoRepository
+import com.placeholder.sherpai2.ui.screens.tourscreen.GalleryUiState
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Analytics
+import androidx.compose.material.icons.filled.CleaningServices
+import androidx.compose.material.icons.filled.Label
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+// Change this line to include '.navigation'
+
+
+@Composable
+fun ManagePhotosScreen(
+    state: ManagePhotosUiState,
+    onCleanUpClick: () -> Unit,
+    onCountTagsClick: () -> Unit,
+    onStatsClick: () -> Unit
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .padding(16.dp),
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+        Text(
+            text = "Manage Photos",
+            style = MaterialTheme.typography.headlineSmall,
+            modifier = Modifier.padding(bottom = 24.dp)
+        )
+
+        // --- Top Action Buttons Row ---
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            ManageActionButton(
+                text = "Clean Up",
+                icon = Icons.Default.CleaningServices,
+                modifier = Modifier.weight(1f),
+                onClick = onCleanUpClick
+            )
+            ManageActionButton(
+                text = "Count by Tag",
+                icon = Icons.Default.Label,
+                modifier = Modifier.weight(1f),
+                onClick = onCountTagsClick
+            )
+            ManageActionButton(
+                text = "Stats",
+                icon = Icons.Default.Analytics,
+                modifier = Modifier.weight(1f),
+                onClick = onStatsClick
+            )
+        }
+
+        Spacer(modifier = Modifier.height(32.dp))
+
+        // --- Dynamic Content Area (Based on State) ---
+        Box(modifier = Modifier.fillMaxSize()) {
+            when (state) {
+                is ManagePhotosUiState.Idle -> {
+                    Text("Select an action above to begin.", Modifier.align(Alignment.Center))
+                }
+                is ManagePhotosUiState.Scanning -> {
+                    CircularProgressIndicator(Modifier.align(Alignment.Center))
+                }
+                is ManagePhotosUiState.Success -> {
+                    DuplicateList(state.duplicateGroups)
+                }
+                is ManagePhotosUiState.Error -> {
+
+                }
+                is ManagePhotosUiState.Loading -> {
+
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun ManageActionButton(
+    text: String,
+    icon: ImageVector,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit
+) {
+    OutlinedButton(
+        onClick = onClick,
+        modifier = modifier.height(80.dp),
+        shape = MaterialTheme.shapes.medium,
+        contentPadding = PaddingValues(8.dp)
+    ) {
+        Column(horizontalAlignment = Alignment.CenterHorizontally) {
+            Icon(icon, contentDescription = null)
+            Spacer(Modifier.height(4.dp))
+            Text(text = text, style = MaterialTheme.typography.labelSmall)
+        }
+    }
+}
+
+@Composable
+fun DuplicateList(duplicates: Map<String, List<*>>) {
+    LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        item { Text("Found ${duplicates.size} Duplicate Groups", style = MaterialTheme.typography.titleMedium) }
+        // We will build out the actual GroupCard next
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/managephotos/ManagePhotosUiState.kt

@@ -0,0 +1,20 @@
+package com.placeholder.sherpai2.ui.screens.managephotos
+
+import com.placeholder.sherpai2.data.photos.Photo
+
+sealed class ManagePhotosUiState {
+    object Idle : ManagePhotosUiState()
+    object Scanning : ManagePhotosUiState()
+    object Loading : ManagePhotosUiState()
+    data class Success(
+        val duplicateGroups: Map<String, List<Photo>> = emptyMap(),
+        val stats: PhotoStats? = null
+    ) : ManagePhotosUiState()
+    data class Error(val message: String) : ManagePhotosUiState()
+}
+
+data class PhotoStats(
+    val totalPhotos: Int,
+    val totalSize: Long,
+    val tagCounts: Map<String, Int>
+)

app/src/main/java/com/placeholder/sherpai2/ui/screens/managephotos/ManagePhotosViewModel.kt

@@ -0,0 +1,65 @@
+package com.placeholder.sherpai2.ui.screens.managephotos
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.photos.Photo
+import com.placeholder.sherpai2.data.repo.PhotoRepository
+import com.placeholder.sherpai2.domain.PhotoDuplicateScanner
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+class ManagePhotosViewModel(application: Application) : AndroidViewModel(application) {
+
+    private val repository = PhotoRepository(application)
+    private val scanner = PhotoDuplicateScanner(application)
+
+    private val _uiState = MutableStateFlow<ManagePhotosUiState>(ManagePhotosUiState.Idle)
+    val uiState: StateFlow<ManagePhotosUiState> = _uiState.asStateFlow()
+
+    fun performCleanUp() {
+        viewModelScope.launch {
+            _uiState.value = ManagePhotosUiState.Loading
+
+            // Use the existing method from your PhotoRepository
+            val result = repository.scanExternalStorage()
+
+            // Handle the Result type properly
+            val allPhotos = result.getOrNull() ?: emptyList()
+
+            // Pass the List<Photo> to the scanner
+            val duplicates = scanner.findDuplicates(allPhotos)
+
+            // Update state with the correct property name: duplicateGroups
+            _uiState.value = ManagePhotosUiState.Success(duplicateGroups = duplicates)
+        }
+    }
+
+
+
+    fun countByTag() {
+        // Logic for tagging implementation goes here
+    }
+
+    fun loadStats() {
+        viewModelScope.launch {
+            _uiState.value = ManagePhotosUiState.Loading
+
+            val result = repository.scanExternalStorage()
+            val allPhotos: List<Photo> = result.getOrNull() ?: emptyList()
+
+            // sumOf now works because allPhotos is a List<Photo>, not Unit
+            val totalSize = allPhotos.sumOf { it.size }
+
+            _uiState.value = ManagePhotosUiState.Success(
+                stats = PhotoStats(
+                    totalPhotos = allPhotos.size,
+                    totalSize = totalSize,
+                    tagCounts = emptyMap() // Implement tagging logic later
+                )
+            )
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/tourscreen/GalleryScreen.kt

@@ -0,0 +1,79 @@
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.unit.dp
+import coil.compose.AsyncImage
+import com.placeholder.sherpai2.data.photos.Photo
+import com.placeholder.sherpai2.ui.screens.tourscreen.GalleryUiState
+
+
+
+
+@Composable
+fun GalleryScreen(
+    state: GalleryUiState,
+    modifier: Modifier = Modifier
+) {
+    // Column ensures the Header and the Grid are stacked vertically
+    Column(modifier = modifier.fillMaxSize()) {
+
+        Text(
+            text = "Photo Gallery",
+            style = MaterialTheme.typography.headlineMedium,
+            modifier = Modifier.padding(16.dp)
+        )
+
+        Box(
+            modifier = Modifier.weight(1f), // Fills remaining space, allowing the grid to scroll
+            contentAlignment = Alignment.Center
+        ) {
+            when (state) {
+                is GalleryUiState.Loading -> CircularProgressIndicator()
+                is GalleryUiState.Error -> Text(text = state.message, color = MaterialTheme.colorScheme.error)
+                is GalleryUiState.Success -> {
+                    if (state.photos.isEmpty()) {
+                        Text("No photos found.")
+                    } else {
+                        LazyVerticalGrid(
+                            columns = GridCells.Fixed(3),
+                            modifier = Modifier.fillMaxSize(),
+                            // contentPadding prevents the bottom items from being cut off by the navigation bar
+                            contentPadding = PaddingValues(bottom = 16.dp),
+                            horizontalArrangement = Arrangement.spacedBy(2.dp),
+                            verticalArrangement = Arrangement.spacedBy(2.dp)
+                        ) {
+                            // Using photo.uri as the key for better scroll performance
+                            items(state.photos, key = { it.uri }) { photo ->
+                                PhotoItem(photo)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+@Composable
+fun PhotoItem(photo: Photo) {
+    AsyncImage(
+        model = photo.uri,
+        contentDescription = photo.title,
+        modifier = Modifier
+            .aspectRatio(1f) // Makes it a square
+            .fillMaxWidth(),
+        contentScale = ContentScale.Crop
+    )
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/tourscreen/GalleryUiState.kt

@@ -0,0 +1,9 @@
+package com.placeholder.sherpai2.ui.screens.tourscreen
+
+import com.placeholder.sherpai2.data.photos.Photo
+
+sealed class GalleryUiState {
+    object Loading : GalleryUiState()
+    data class Success(val photos: List<Photo>) : GalleryUiState()
+    data class Error(val message: String) : GalleryUiState()
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/tourscreen/GalleryViewModel.kt

@@ -0,0 +1,33 @@
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.repo.PhotoRepository
+import com.placeholder.sherpai2.ui.screens.tourscreen.GalleryUiState
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+class GalleryViewModel(application: Application) : AndroidViewModel(application) {
+
+    // Initialize repository with the application context
+    private val repository = PhotoRepository(application)
+
+    private val _uiState = MutableStateFlow<GalleryUiState>(GalleryUiState.Loading)
+    val uiState = _uiState.asStateFlow()
+
+    init {
+        loadPhotos()
+    }
+
+    fun loadPhotos() {
+        viewModelScope.launch {
+            val result = repository.scanExternalStorage()
+
+            result.onSuccess { photos ->
+                _uiState.value = GalleryUiState.Success(photos)
+            }.onFailure { error ->
+                _uiState.value = GalleryUiState.Error(error.message ?: "Unknown Error")
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/tourscreen/components/AlbumBox.kt

@@ -0,0 +1,4 @@
+package com.placeholder.sherpai2.ui.screens.tourscreen.components
+
+class AlbumBox {
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/trainscreen/ImagePickerScreen.kt

@@ -0,0 +1,44 @@
+package com.placeholder.sherpai2.ui.screens.trainscreen
+
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.repo.FaceRepository
+import com.placeholder.sherpai2.domain.faces.analyzer.FaceAnalyzer
+import kotlinx.coroutines.launch
+
+@Composable
+fun ImagePickerScreen(
+    viewModel: ImagePickerViewModel
+) {
+    val selectedImages by viewModel.selectedImages
+
+    val launcher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.GetMultipleContents()
+    ) { uris: List<Uri> ->
+        viewModel.onImagesSelected(uris)
+    }
+
+    Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
+        Button(onClick = { launcher.launch("image/*") }) {
+            Text("Select Photos")
+        }
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        LazyColumn {
+            items(selectedImages) { uri ->
+                Text(uri.toString(), style = MaterialTheme.typography.bodyMedium)
+            }
+        }
+    }
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/trainscreen/ImagePickerViewModel.kt

@@ -0,0 +1,67 @@
+package com.placeholder.sherpai2.ui.screens.trainscreen
+
+import android.net.Uri
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.placeholder.sherpai2.data.repo.FaceRepository
+import com.placeholder.sherpai2.domain.faces.analyzer.FaceAnalyzer
+import kotlinx.coroutines.launch
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.ImageDecoder
+
+import android.os.Build
+import android.provider.MediaStore
+
+import androidx.compose.runtime.mutableStateOf
+
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+
+@HiltViewModel
+class ImagePickerViewModel @Inject constructor(
+    @ApplicationContext private val appContext: Context,
+    private val faceAnalyzer: FaceAnalyzer,
+    private val repository: FaceRepository
+) : ViewModel() {
+
+    private val _selectedImages = mutableStateOf<List<Uri>>(emptyList())
+    val selectedImages: State<List<Uri>> = _selectedImages
+
+    fun onImagesSelected(uris: List<Uri>) {
+        _selectedImages.value = uris.take(10)
+
+        viewModelScope.launch {
+            uris.take(10).forEach { uri ->
+                val bitmap = loadBitmapFromUri(uri)
+                val embedding = faceAnalyzer.analyze(bitmap)
+                val label = uri.lastPathSegment ?: "Unknown"
+                repository.saveFace(label, embedding)
+            }
+        }
+    }
+
+    private suspend fun loadBitmapFromUri(uri: Uri): Bitmap =
+        withContext(Dispatchers.IO) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                val source = ImageDecoder.createSource(
+                    appContext.contentResolver,
+                    uri
+                )
+                ImageDecoder.decodeBitmap(source)
+            } else {
+                @Suppress("DEPRECATION")
+                MediaStore.Images.Media.getBitmap(
+                    appContext.contentResolver,
+                    uri
+                )
+            }
+        }
+}

app/src/main/java/com/placeholder/sherpai2/ui/screens/trainscreen/TrainModelScreen.kt

@@ -0,0 +1,2 @@
+package com.placeholder.sherpai2.ui.screens.trainscreen
+

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

@@ -1,70 +0,0 @@
-package com.placeholder.sherpai2.ui.search
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.grid.*
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.placeholder.sherpai2.ui.search.components.ImageGridItem
-import com.placeholder.sherpai2.ui.search.SearchViewModel
-
-/**
- * SearchScreen
- *
- * Purpose:
- *  - Validate tag-based queries
- *  - Preview matching images
- *
- * This is NOT final UX.
- * It is a diagnostic surface.
- */
-@Composable
-fun SearchScreen(
-    modifier: Modifier = Modifier,
-    searchViewModel: SearchViewModel,
-    onImageClick: (String) -> Unit
-) {
-
-    var query by remember { mutableStateOf("") }
-
-    /**
-     * Reactive result set.
-     * Updates whenever:
-     *  - query changes
-     *  - database changes
-     */
-    val images by searchViewModel
-        .searchImagesByTag(query)
-        .collectAsStateWithLifecycle(initialValue = emptyList())
-
-    Column(
-        modifier = modifier
-            .fillMaxSize()
-            .padding(12.dp)
-    ) {
-
-        OutlinedTextField(
-            value = query,
-            onValueChange = { query = it },
-            label = { Text("Search by tag") },
-            modifier = Modifier.fillMaxWidth(),
-            singleLine = true
-        )
-
-        Spacer(modifier = Modifier.height(12.dp))
-
-        LazyVerticalGrid(
-            columns = GridCells.Adaptive(120.dp),
-            contentPadding = PaddingValues(4.dp),
-            verticalArrangement = Arrangement.spacedBy(4.dp),
-            horizontalArrangement = Arrangement.spacedBy(4.dp),
-            modifier = Modifier.fillMaxSize()
-        ) {
-            items(images) { imageWithEverything ->
-                ImageGridItem(image = imageWithEverything.image)
-            }
-        }
-    }
-}

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

@@ -1,24 +0,0 @@
-package com.placeholder.sherpai2.ui.search
-
-import androidx.lifecycle.ViewModel
-import com.placeholder.sherpai2.domain.repository.ImageRepository
-import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
-
-/**
- * SearchViewModel
- *
- * Stateless except for query-driven flows.
- */
-@HiltViewModel
-class SearchViewModel @Inject constructor(
-    private val imageRepository: ImageRepository
-) : ViewModel() {
-
-    fun searchImagesByTag(tag: String) =
-        if (tag.isBlank()) {
-            imageRepository.getAllImages()
-        } else {
-            imageRepository.findImagesByTag(tag)
-        }
-}

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

@@ -1,30 +0,0 @@
-package com.placeholder.sherpai2.ui.search.components
-
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import coil.compose.rememberAsyncImagePainter
-import com.placeholder.sherpai2.data.local.entity.ImageEntity
-
-/**
- * ImageGridItem
- *
- * Minimal thumbnail preview.
- * No click handling yet.
- */
-@Composable
-fun ImageGridItem(
-    image: ImageEntity,
-    modifier: Modifier = Modifier,
-    onClick: (() -> Unit)? = null
-) {
-    Image(
-        painter = rememberAsyncImagePainter(image.imageUri),
-        contentDescription = null,
-        modifier = Modifier
-            .fillMaxWidth()
-            .aspectRatio(1f)
-    )
-}

app/src/main/java/com/placeholder/sherpai2/ui/tour/TourScreen.kt

@@ -1,77 +0,0 @@
-// TourScreen.kt
-package com.placeholder.sherpai2.ui.tour
-
-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.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-
-@Composable
-fun TourScreen(tourViewModel: TourViewModel = hiltViewModel(), onImageClick: (String) -> Unit) {
-    val images by tourViewModel.recentImages.collectAsState()
-
-    Column(modifier = Modifier.fillMaxSize()) {
-        // Header with image count
-        Text(
-            text = "Gallery (${images.size} images)",
-            style = MaterialTheme.typography.titleLarge,
-            modifier = Modifier.padding(16.dp)
-        )
-
-        LazyColumn(
-            modifier = Modifier.fillMaxSize(),
-            contentPadding = PaddingValues(16.dp)
-        ) {
-            items(images) { image ->
-                ImageCard(image)
-                Spacer(modifier = Modifier.height(12.dp))
-            }
-        }
-    }
-}
-
-@Composable
-fun ImageCard(image: ImageWithEverything) {
-    Card(modifier = Modifier.fillMaxWidth(), elevation = CardDefaults.cardElevation(4.dp)) {
-        Column(modifier = Modifier.padding(12.dp)) {
-            Text(text = image.tags.toString(), style = MaterialTheme.typography.bodyMedium)
-
-            // Tags row with placeholders if fewer than 3
-            Row(modifier = Modifier.padding(top = 8.dp)) {
-                val tags = image.tags.map { it.tagId } // adjust depending on your entity
-                tags.forEach { tag ->
-                    TagComposable(tag)
-                }
-                repeat(3 - tags.size.coerceAtMost(3)) {
-                    TagComposable("") // empty placeholder
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun TagComposable(tag: String) {
-    Box(
-        modifier = Modifier
-            .padding(end = 4.dp)
-            .height(24.dp)
-            .widthIn(min = 40.dp)
-            .background(MaterialTheme.colorScheme.primaryContainer, MaterialTheme.shapes.small),
-        contentAlignment = androidx.compose.ui.Alignment.Center
-    ) {
-        Text(
-            text = if (tag.isNotBlank()) tag else " ",
-            style = MaterialTheme.typography.labelSmall,
-            modifier = Modifier.padding(horizontal = 6.dp)
-        )
-    }
-}

app/src/main/java/com/placeholder/sherpai2/ui/tour/TourViewModel.kt

@@ -1,39 +0,0 @@
-// TourViewModel.kt
-package com.placeholder.sherpai2.ui.tour
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.placeholder.sherpai2.domain.repository.ImageRepository
-import com.placeholder.sherpai2.data.local.model.ImageWithEverything
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-@HiltViewModel
-class TourViewModel @Inject constructor(
-    private val imageRepository: ImageRepository
-) : ViewModel() {
-
-    // Expose recent images as StateFlow
-    private val _recentImages = MutableStateFlow<List<ImageWithEverything>>(emptyList())
-    val recentImages: StateFlow<List<ImageWithEverything>> = _recentImages.asStateFlow()
-
-    init {
-        loadRecentImages()
-    }
-
-    private fun loadRecentImages(limit: Int = 100) {
-        viewModelScope.launch {
-            imageRepository.getRecentImages(limit)
-                .catch { e ->
-                    println("TourViewModel: error fetching images: $e")
-                    _recentImages.value = emptyList()
-                }
-                .collect { images ->
-                    println("TourViewModel: fetched ${images.size} images")
-                    _recentImages.value = images
-                }
-        }
-    }
-}

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

@@ -1,130 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import android.net.Uri
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.*
-
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.AddPhotoAlternate
-import androidx.compose.material.icons.filled.Close
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.unit.dp
-import androidx.compose.material3.Text
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.platform.LocalContext
-import coil.compose.AsyncImage
-import androidx.compose.foundation.lazy.grid.items
-
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun ImageSelectorScreen(
-    onImagesSelected: (List<Uri>) -> Unit
-) {
-    //1. Persist state across configuration changes
-    var selectedUris by rememberSaveable { mutableStateOf<List<Uri>>(emptyList()) }
-    val context = LocalContext.current
-
-    val launcher = rememberLauncherForActivityResult(
-        ActivityResultContracts.OpenMultipleDocuments()
-    ) { uris ->
-        // 2. Take first 10 and try to persist permissions
-        val limitedUris = uris.take(10)
-        selectedUris = limitedUris
-    }
-
-    Scaffold(
-        topBar = { TopAppBar(title = { Text("Select Training Photos") }) }
-    ) { padding ->
-        Column(
-            modifier = Modifier
-                .padding(padding)
-                .padding(16.dp)
-                .fillMaxSize(),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            OutlinedCard(
-                onClick = { launcher.launch(arrayOf("image/*")) },
-                modifier = Modifier.fillMaxWidth()
-            ) {
-                Column(
-                    modifier = Modifier.padding(24.dp),
-                    horizontalAlignment = Alignment.CenterHorizontally
-                ) {
-                    Icon(Icons.Default.AddPhotoAlternate, contentDescription = null)
-                    Spacer(Modifier.height(8.dp))
-                    Text("Select up to 10 images of the person")
-                    Text(
-                        text = "${selectedUris.size} / 10 selected",
-                        style = MaterialTheme.typography.labelLarge,
-                        color = if (selectedUris.size == 10) MaterialTheme.colorScheme.error
-                        else if (selectedUris.isNotEmpty()) MaterialTheme.colorScheme.primary
-                        else MaterialTheme.colorScheme.outline
-                    )
-                }
-            }
-
-            // 3. Conditional rendering for empty state
-            if (selectedUris.isEmpty()) {
-                Box(Modifier
-                    .weight(1f)
-                    .fillMaxWidth(), contentAlignment = Alignment.Center) {
-                    Text("No images selected", style = MaterialTheme.typography.bodyMedium)
-                }
-            } else {
-                LazyVerticalGrid(
-                    columns = GridCells.Fixed(3),
-                    modifier = Modifier.weight(1f),
-                    contentPadding = PaddingValues(4.dp)
-                ) {
-                    items(selectedUris, key = { it.toString() }) { uri ->
-                        Box(modifier = Modifier.padding(4.dp)) {
-                            AsyncImage(
-                                model = uri,
-                                contentDescription = null,
-                                modifier = Modifier
-                                    .aspectRatio(1f)
-                                    .clip(RoundedCornerShape(8.dp)),
-                                contentScale = ContentScale.Crop
-                            )
-                            // 4. Ability to remove specific images
-                            Surface(
-                                onClick = { selectedUris = selectedUris - uri },
-                                modifier = Modifier
-                                    .align(Alignment.TopEnd)
-                                    .padding(4.dp),
-                                shape = CircleShape,
-                                color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.8f)
-                            ) {
-                                Icon(
-                                    Icons.Default.Close,
-                                    contentDescription = "Remove",
-                                    modifier = Modifier.size(16.dp)
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-
-            Button(
-                modifier = Modifier.fillMaxWidth(),
-                enabled = selectedUris.isNotEmpty(),
-                onClick = { onImagesSelected(selectedUris) }
-            ) {
-                Text("Start Face Detection")
-            }
-        }
-    }
-}

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

@@ -1,74 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import android.net.Uri
-import androidx.compose.foundation.Image
-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.material3.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.unit.dp
-import coil.compose.rememberAsyncImagePainter
-
-@Composable
-fun ScanResultsScreen(
-    state: ScanningState,
-    onFinish: () -> Unit
-) {
-    Column(
-        modifier = Modifier.fillMaxSize().padding(16.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center
-    ) {
-        when (state) {
-            is ScanningState.Processing -> {
-                CircularProgressIndicator()
-                Spacer(Modifier.height(16.dp))
-                Text("Analyzing faces... ${state.current} / ${state.total}")
-            }
-            is ScanningState.Success -> {
-                Text(
-                    text = "Analysis Complete!",
-                    style = MaterialTheme.typography.headlineMedium
-                )
-
-                LazyColumn(modifier = Modifier.weight(1f).padding(vertical = 16.dp)) {
-                    items(state.results) { result ->
-                        Row(
-                            modifier = Modifier.fillMaxWidth().padding(8.dp),
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-                            Image(
-                                painter = rememberAsyncImagePainter(result.uri),
-                                contentDescription = null,
-                                modifier = Modifier.size(60.dp).clip(RoundedCornerShape(8.dp)),
-                                contentScale = ContentScale.Crop
-                            )
-                            Spacer(Modifier.width(16.dp))
-                            Column {
-                                Text(if (result.faceCount > 0) "✅ Face Detected" else "❌ No Face")
-                                if (result.hasMultipleFaces) {
-                                    Text(
-                                        "⚠️ Multiple faces (${result.faceCount})",
-                                        color = MaterialTheme.colorScheme.error,
-                                        style = MaterialTheme.typography.bodySmall
-                                    )
-                                }
-                            }
-                        }
-                    }
-                }
-
-                Button(onClick = onFinish, modifier = Modifier.fillMaxWidth()) {
-                    Text("Done")
-                }
-            }
-            else -> {}
-        }
-    }
-}

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

@@ -1,107 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import android.content.Context
-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.domain.repository.ImageRepository
-import com.placeholder.sherpai2.domain.repository.TaggingRepository
-import dagger.hilt.android.lifecycle.HiltViewModel
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.sync.withPermit
-import kotlinx.coroutines.tasks.await
-import kotlinx.coroutines.withContext
-import javax.inject.Inject
-
-sealed class ScanningState {
-    object Idle : ScanningState()
-    data class Processing(val current: Int, val total: Int) : ScanningState()
-    data class Success(val results: List<ScanResult>) : ScanningState()
-}
-
-data class ScanResult(
-    val uri: Uri,
-    val faceCount: Int,
-    val hasMultipleFaces: Boolean = faceCount > 1
-)
-
-@HiltViewModel
-class TrainViewModel @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val imageRepository: ImageRepository,
-    private val taggingRepository: TaggingRepository
-) : ViewModel() {
-
-    private val _uiState = MutableStateFlow<ScanningState>(ScanningState.Idle)
-    val uiState: StateFlow<ScanningState> = _uiState.asStateFlow()
-
-    private val semaphore = Semaphore(2)
-
-    fun scanAndTagFaces(uris: List<Uri>) = viewModelScope.launch {
-        val total = uris.size
-        _uiState.value = ScanningState.Processing(0, total)
-
-        val detector = FaceDetection.getClient(faceOptions())
-        val allImages = imageRepository.getAllImages().first()
-        val uriToIdMap = allImages.associate { it.image.imageUri to it.image.imageId }
-
-        var completedCount = 0
-
-        val scanResults = withContext(Dispatchers.Default) {
-            uris.map { uri ->
-                async {
-                    semaphore.withPermit {
-                        val faceCount = detectFaceCount(detector, uri)
-
-                        // Tagging logic
-                        if (faceCount > 0) {
-                            uriToIdMap[uri.toString()]?.let { id ->
-                                taggingRepository.addTagToImage(id, "face", "ML_KIT", 1.0f)
-                                if (faceCount > 1) {
-                                    taggingRepository.addTagToImage(id, "multiple_faces", "ML_KIT", 1.0f)
-                                }
-                            }
-                        }
-
-                        completedCount++
-                        _uiState.value = ScanningState.Processing(completedCount, total)
-
-                        ScanResult(uri, faceCount)
-                    }
-                }
-            }.awaitAll()
-        }
-
-        detector.close()
-        _uiState.value = ScanningState.Success(scanResults)
-    }
-
-    private suspend fun detectFaceCount(
-        detector: com.google.mlkit.vision.face.FaceDetector,
-        uri: Uri
-    ): Int = withContext(Dispatchers.IO) {
-        return@withContext try {
-            val image = InputImage.fromFilePath(context, uri)
-            val faces = detector.process(image).await()
-            faces.size // Returns actual count
-        } catch (e: Exception) {
-            0
-        }
-    }
-
-    private fun faceOptions() = FaceDetectorOptions.Builder()
-        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST)
-        .build()
-}

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

@@ -1,31 +0,0 @@
-package com.placeholder.sherpai2.ui.trainingprep
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.material3.TopAppBar
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun TrainingScreen(
-    onSelectImages: () -> Unit
-) {
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = { Text("Training") }
-            )
-        }
-    ) { padding ->
-        Button(
-            modifier = Modifier.padding(padding),
-            onClick = onSelectImages
-        ) {
-            Text("Select Images")
-        }
-    }
-}

build.gradle.kts

@@ -3,9 +3,10 @@ plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.compose) apply false
-
-    //Adding these two fixes the conflicts between hilt / room / ksp and javbapoet (cannonicalName())
-    //https://github.com/google/dagger/issues/4048#issuecomment-1864237679
-    alias(libs.plugins.ksp) apply false
-    alias(libs.plugins.hilt.android) apply false
+}
+
+buildscript {
+    dependencies {
+        classpath("com.android.tools.build:gradle:8.13.2")
+    }
 }

gradle/bklibs.versions.toml

@@ -0,0 +1,65 @@
+[versions]
+activityComposeVersion = "1.8.2"
+agp = "8.13.1"
+coreKtxVersion = "1.12.0"
+kotlin = "2.0.21"
+coreKtx = "1.17.0"
+junit = "4.13.2"
+junitVersion = "1.3.0"
+espressoCore = "3.7.0"
+lifecycleRuntimeKtx = "2.10.0"
+activityCompose = "1.12.1"
+composeBom = "2024.09.00"
+materialIconsExtended = "1.6.0"
+navigationRuntimeKtx = "2.9.6"
+navigationCompose = "2.9.6"
+
+#Branch Updated -dev_backend_one
+
+ksp = "2.0.21-1.0.28" # MUST match the 2.0.21 prefix
+room = "2.6.1"
+camerax = "1.4.0"
+[libraries]
+androidx-activity-compose-v182 = { module = "androidx.activity:activity-compose", version.ref = "activityComposeVersion" }
+androidx-compose-material-icons-extended = { module = "androidx.compose.material:material-icons-extended", version.ref = "materialIconsExtended" }
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+androidx-core-ktx-v1120 = { module = "androidx.core:core-ktx", version.ref = "coreKtxVersion" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
+androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
+androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
+androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
+androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
+androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
+androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+androidx-navigation-runtime-ktx = { group = "androidx.navigation", name = "navigation-runtime-ktx", version.ref = "navigationRuntimeKtx" }
+androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigationCompose" }
+
+
+
+#Branch Updated -dev_backend_one
+
+
+
+# CameraX stack
+camera-core = { group = "androidx.camera", name = "camera-camera2", version.ref = "camerax" }
+camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "camerax" }
+camera-view = { group = "androidx.camera", name = "camera-view", version.ref = "camerax" }
+# ML Stack
+mlkit-face = { group = "com.google.mlkit", name = "face-detection", version = "16.1.7" }
+tflite = { group = "org.tensorflow", name = "tensorflow-lite", version = "2.16.1" }
+# Room
+room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
+room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
+
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

gradle/libs.versions.toml

@@ -1,61 +1,62 @@
 [versions]
 # Tooling
-agp = "8.13.2"
+agp = "8.7.3" # Latest stable for 2025
 kotlin = "2.0.21"
-ksp = "2.0.21-1.0.28"
+ksp = "2.0.21-1.0.28" # Strictly matched to Kotlin version
 
-# AndroidX / Lifecycle
-coreKtx = "1.15.0"
-lifecycle = "2.8.7"
-activityCompose = "1.9.3"
-composeBom = "2025.12.01"
-navigationCompose = "2.8.5"
-hiltNavigationCompose = "1.3.0"
+# AndroidX / Compose
+androidx-core = "1.15.0"
+androidx-lifecycle = "2.10.0"
+androidx-activity = "1.12.2"
+compose-bom = "2025.12.00"
+navigation = "2.8.5"
 
-# DI & Database
-hilt = "2.57.2"
-room = "2.8.4"
+# Camera & ML
+camerax = "1.5.2"
+mlkit-face = "16.1.7"
+tflite = "2.16.1"
+
+# Database & DI
+room = "2.7.0-alpha01"
+hilt = "2.54" # Supports KSP2 and fixes JavaPoet conflicts
 
 # Images
-coil = "2.7.0"
-
-#Face Detect
-mlkit-face-detection = "16.1.6"
-coroutines-play-services = "1.8.1"
+coil = "2.6.0"
 
 [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" }
-androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
-androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
+# Core & Lifecycle
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "androidx-core" }
+androidx-lifecycle-runtime = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "androidx-lifecycle" }
+androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "androidx-activity" }
 
 # Compose
-androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
-androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
-androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
-androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
-androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
-androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
-androidx-compose-material-icons = { group = "androidx.compose.material", name = "material-icons-extended" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose-bom" }
+compose-ui = { group = "androidx.compose.ui", name = "ui" }
+compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+compose-icons = { group = "androidx.compose.material", name = "material-icons-extended" }
+compose-navigation = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation" }
 
-# Navigation & Hilt
-androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigationCompose" }
-androidx-hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navigation-compose", version.ref = "hiltNavigationCompose" }
-hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
-hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" }
+# CameraX
+camera-core = { group = "androidx.camera", name = "camera-camera2", version.ref = "camerax" }
+camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "camerax" }
+camera-view = { group = "androidx.camera", name = "camera-view", version.ref = "camerax" }
+
+# ML
+mlkit-face = { group = "com.google.mlkit", name = "face-detection", version.ref = "mlkit-face" }
+tflite = { group = "org.tensorflow", name = "tensorflow-lite", version.ref = "tflite" }
+tflite-support = { group = "org.tensorflow", name = "tensorflow-lite-support", version = "0.4.4" }
 
 # Room
 room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
-room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
 room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
 
-# Misc
+# Images
 coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coil" }
 
-#Face Detect
-mlkit-face-detection = { group = "com.google.mlkit", name = "face-detection", version.ref = "mlkit-face-detection"}
-kotlinx-coroutines-play-services = {group = "org.jetbrains.kotlinx",name = "kotlinx-coroutines-play-services",version.ref = "coroutines-play-services"}
-
+# Hilt
+hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
+hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Tue Dec 09 23:28:28 EST 2025
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists