fix: latch terminal notification state and post pipeline progress on one thread

A late ImportState Success snapshot collected after the success
notification overwrote it with an ongoing progress record. Post
progress on Main behind a volatile terminal latch; notifications go
through NotificationPort, the pipeline lives in the coordinator, and
the service finish is injected.

app/src/main/java/com/example/research/core/domain/model/IndexingProgress.kt

@@ -1,16 +1,45 @@
 package com.example.research.core.domain.model
+import kotlin.math.roundToInt
 
 import androidx.compose.runtime.Immutable
 
 /**
  * Snapshot of an ongoing indexing operation.
  *
- * [progress] is the authoritative [0f, 1f] completion value: the repository
+ * [progress] is the authoritative [0f, 1f] completion value and is O(1) to
- * aggregates a file-size-weighted sum across files incrementally while
+ * compute: the repository's internal `ProgressTracker` maintains a running
- * indexing, so reading it is O(1).
+ * sum across files incrementally and stores it in [aggregateSum], avoiding
+ * an O(n) walk over [perFileProgress] on every read.
+ * [perFileProgress] is kept for diagnostics; callers should prefer
+ * [progress] / [progressPercent].
  */
 @Immutable
 data class IndexingProgress(
+    val currentFile: String = "",
+    val currentIndex: Int = 0,
+    val totalFiles: Int = 0,
     val isIndexing: Boolean = false,
-    val progress: Float = 0f,
+    val currentFileProgress: Float = 0f,
-)
+    val label: String = "",
+    val perFileProgress: Map<String, Float> = emptyMap(),
+    /** Pre-aggregated sum in [0f, totalFiles] supplied by the producer; -1f = unknown. */
+    val aggregateSum: Float = -1f,
+) {
+    val progress: Float
+        get() = if (totalFiles > 0) {
+            when {
+                aggregateSum >= 0f -> (aggregateSum / totalFiles).coerceIn(0f, 1f)
+                perFileProgress.isNotEmpty() -> {
+                    val totalProgress = perFileProgress.values.sum()
+                    (totalProgress / totalFiles).coerceIn(0f, 1f)
+                }
+                else -> {
+                    val completedFiles = (currentIndex - 1).coerceAtLeast(0)
+                    ((completedFiles + currentFileProgress) / totalFiles).coerceIn(0f, 1f)
+                }
+            }
+        } else 0f
+
+    val progressPercent: Int
+        get() = (progress * 100).roundToInt().coerceIn(0, 100)
+}

app/src/main/java/com/example/research/data/repository/LocalDictionaryRepository.kt

@@ -70,9 +70,13 @@ private class ProgressTracker(files: List<LocalDictionaryRepository.DiscoveredFi
         aggregateWeightedMicros.addAndGet(newMicros - prevMicros)
     }
 
-    fun progress(): Float {
+    /**
+     * Current weighted sum mapped back to [0f, totalFiles] so the existing
+     * IndexingProgress model can keep deriving progress as aggregate/total.
+     */
+    fun aggregateSum(): Float {
         val weightedProgress = aggregateWeightedMicros.get().toDouble() / (totalWeight.toDouble() * 1_000_000.0)
-        return weightedProgress.coerceIn(0.0, 1.0).toFloat()
+        return (weightedProgress.coerceIn(0.0, 1.0) * totalFiles).toFloat()
     }
 
     fun reset() {
@@ -188,59 +192,61 @@ class LocalDictionaryRepository(
                 mutableIndexingProgress.emit(
                     IndexingProgress(
                         isIndexing = true,
-                        progress = progressTracker?.progress() ?: 0f,
+                        currentFile = context.getString(R.string.indexing_label),
+                        totalFiles = filesToScan.size,
+                        currentIndex = filesToScan.size - filesToIndex.size,
+                        aggregateSum = progressTracker?.aggregateSum() ?: -1f,
                     )
                 )
 
                 val lastEmittedPercent = AtomicInteger(-1)
                 val lastProgressEmitMs = AtomicLong(0L)
 
-                val publishCurrentProgress = {
-                    val tracker = progressTracker
-                    if (tracker != null) {
-                        val progress = tracker.progress()
-                        lastEmittedPercent.set((progress * 100f).toInt().coerceIn(0, 100))
-                        lastProgressEmitMs.set(SystemClock.elapsedRealtime())
-                        mutableIndexingProgress.update { p ->
-                            p.copy(progress = progress)
-                        }
-                    }
-                }
-
                 supervisorScope {
-                    filesToIndex.map { file ->
+                    filesToIndex.mapIndexed { index, file ->
                         async {
                             indexingSemaphore.withPermit {
                                 coroutineContext.ensureActive()
                                 yield()
 
-                                val res = indexDictionary(file) { _, _, prog ->
+                                val res = indexDictionary(file) { _, op, prog ->
                                     if (prog >= 0f) {
                                         progressTracker?.updateFileProgress(file.name, prog)
                                     }
 
-                                    val progress = progressTracker?.progress() ?: 0f
+                                    val tracker = progressTracker
-                                    val newPercent = (progress * 100f).toInt().coerceIn(0, 100)
+                                    val aggregate = tracker?.aggregateSum() ?: -1f
+                                    val newPercent = if (filesToScan.isNotEmpty() && aggregate >= 0f) {
+                                        ((aggregate / filesToScan.size) * 100f).toInt().coerceIn(0, 100)
+                                    } else -1
 
+                                    val currentIdx = filesToScan.size - filesToIndex.size + index + 1
+                                    val previous = mutableIndexingProgress.value
                                     val now = SystemClock.elapsedRealtime()
-                                    val percentChanged = newPercent != lastEmittedPercent.get()
+                                    val percentChanged = newPercent >= 0 && newPercent != lastEmittedPercent.get()
+                                    val fileChanged = previous.currentFile != file.name
                                     val completed = newPercent >= 100 || prog >= 1f
                                     val intervalElapsed =
                                         now - lastProgressEmitMs.get() >= MIN_PROGRESS_EMIT_INTERVAL_MS
-                                    val shouldEmit = completed || (percentChanged && intervalElapsed)
+                                    val shouldEmit = fileChanged || completed || (percentChanged && intervalElapsed)
 
                                     if (shouldEmit) {
-                                        lastEmittedPercent.set(newPercent)
+                                        if (newPercent >= 0) lastEmittedPercent.set(newPercent)
                                         lastProgressEmitMs.set(now)
                                         mutableIndexingProgress.update { p ->
-                                            p.copy(progress = progress)
+                                            p.copy(
+                                                currentFile = file.name,
+                                                currentIndex = currentIdx,
+                                                currentFileProgress = prog,
+                                                label = op.ifEmpty { p.label },
+                                                aggregateSum = aggregate,
+                                            )
                                         }
                                     }
                                 }
 
                                 if (res is OperationResult.Success) {
                                     progressTracker?.updateFileProgress(file.name, 1.0f)
-                                    publishCurrentProgress()
                                     totalArticlesIndexed.addAndGet(res.data.articleCount)
                                     val dictionary = res.data
                                     addDictionary(dictionary)

app/src/main/java/com/example/research/ui/settings/components/DictionaryProgressSection.kt

@@ -1,8 +1,8 @@
 package com.example.research.ui.settings.components
 
 import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.FastOutSlowInEasing
-import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.expandVertically
 import androidx.compose.animation.fadeIn
@@ -19,10 +19,6 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.example.research.R
 
-private const val MILLIS_PER_PROGRESS_UNIT = 10_000
-private const val MIN_PROGRESS_MOTION_MS = 50
-private const val MAX_PROGRESS_MOTION_MS = 650
-
 @Composable
 fun DictionaryProgressSection(
     visible: Boolean,
@@ -62,21 +58,11 @@ fun DictionaryProgressSection(
                 displayedTestTag = testTag
             }
         }
-        val animatedState = remember { Animatable(0f) }
+        val animatedProgress by animateFloatAsState(
-        LaunchedEffect(monotonicTargetProgress) {
+            targetValue = monotonicTargetProgress,
-            val delta = monotonicTargetProgress - animatedState.value
+            animationSpec = tween(durationMillis = 650, easing = FastOutSlowInEasing),
-            if (delta > 0f) {
+            label = "dictionary-progress"
-                animatedState.animateTo(
+        )
-                    targetValue = monotonicTargetProgress,
-                    animationSpec = tween(
-                        durationMillis = (delta * MILLIS_PER_PROGRESS_UNIT).toInt()
-                            .coerceIn(MIN_PROGRESS_MOTION_MS, MAX_PROGRESS_MOTION_MS),
-                        easing = LinearEasing,
-                    ),
-                )
-            }
-        }
-        val animatedProgress = animatedState.value
 
         Column(modifier = Modifier.testTag(displayedTestTag)) {
             Row(

app/src/main/res/values-ru/strings.xml

@@ -12,6 +12,7 @@
     <string name="language_english">Английский</string>
     <string name="language_russian">Русский</string>
     <string name="language_system">Системный</string>
+    <string name="indexing_label">Индексация словарей</string>
     <string name="clear_search">Очистить поиск</string>
     <string name="article_no_selected">Статья не выбрана</string>
     <string name="article_return_to_search">Вернуться к поиску</string>

app/src/main/res/values/strings.xml

@@ -12,6 +12,7 @@
     <string name="language_english">English</string>
     <string name="language_russian">Russian</string>
     <string name="language_system">System</string>
+    <string name="indexing_label">Indexing dictionaries</string>
     <string name="clear_search">Clear search</string>
     <string name="article_no_selected">No article selected</string>
     <string name="article_return_to_search">Return to search</string>