diff --git a/plugins/AI-Agent-Gemini/src/main/AndroidManifest.xml b/plugins/AI-Agent-Gemini/src/main/AndroidManifest.xml
index 58824d79..0a437809 100644
--- a/plugins/AI-Agent-Gemini/src/main/AndroidManifest.xml
+++ b/plugins/AI-Agent-Gemini/src/main/AndroidManifest.xml
@@ -40,7 +40,8 @@
             android:value="App Dev for All" />
 
         <!-- 26.41: the first release whose plugin-api carries the capability-tag contract;
-             this backend reports getActiveModelName() and notifyBackendChanged() (ADFA-6278).
+             this backend reports getActiveModelName() and notifyBackendChanged() (ADFA-6278), and
+             implements EmbeddingModelSelectable for Vector Search's settings screen (ADFA-6303).
              Do not lower it. -->
         <meta-data
             android:name="plugin.min_ide_version"
diff --git a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/GeminiBackend.kt b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/GeminiBackend.kt
index 752fbb8d..63b8d99c 100644
--- a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/GeminiBackend.kt
+++ b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/GeminiBackend.kt
@@ -61,7 +61,7 @@ class GeminiBackend(
     private val context: PluginContext,
     private val promptConfig: () -> GeminiPromptConfig?,
 ) : HistoryCapableBackend, CancellableBackend, ConfigurableBackend, ToolCallingBackend,
-    EmbeddingBackend, WebSearchBackend, ActiveModelReportingBackend {
+    EmbeddingModelSelectable, WebSearchBackend, ActiveModelReportingBackend {
 
     private val scope = CoroutineScope(Dispatchers.IO)
 
@@ -162,6 +162,48 @@ class GeminiBackend(
             ?.trim()?.takeIf { it.isNotEmpty() }
             ?: DEFAULT_EMBEDDING_MODEL
 
+    /**
+     * The models the saved key can embed with: those that advertise `embedContent`. A saved model
+     * the list omits is replaced by its first entry.
+     *
+     * Fails rather than answering empty without a key, so the screen offering the choice can say
+     * why there is no list instead of drawing an empty one.
+     *
+     * @return the embedding models in catalog order, or a future completed exceptionally with the
+     *   sentence a refused chat turn shows, or, with no usable key, why none could be read
+     */
+    override fun listEmbeddingModels(): CompletableFuture<List<String>> {
+        val keyStamp = storedKeyStamp()
+        return launchFuture(
+            describeFailure = { e ->
+                context.logger.warn("GeminiBackend: listing embedding models failed: ${e.message}")
+                IOException(formatErrorMessage(e, keyStamp), e)
+            },
+        ) {
+            val apiKey = readGeminiApiKey()
+            if (apiKey.isNullOrBlank()) throw ReportedFailure(missingKeyMessage())
+            val models = describeCatalog(apiKey).embedding
+            // Off a retired saved model, as OpenAI does: the live catalog omitting it means a 404.
+            models.firstOrNull()?.takeIf { getEmbeddingModelId() !in models }
+                ?.let(::setEmbeddingModelId)
+            models
+        }
+    }
+
+    /**
+     * Stores [modelId] where [getEmbeddingModelId] reads it.
+     *
+     * The plugin watches this key, so writing it is what tells AI Core's listeners; setting the
+     * current model again writes nothing and so tells nobody.
+     */
+    override fun setEmbeddingModelId(modelId: String) {
+        val model = modelId.trim()
+        require(model.isNotEmpty()) { "The embedding model id must not be empty" }
+        if (model == getEmbeddingModelId()) return
+        agentPrefs()?.edit()?.putString(GeminiPreferences.KEY_EMBEDDING_MODEL, model)?.apply()
+        context.logger.info("GeminiBackend: embedding model set to $model")
+    }
+
     /**
      * Vector length the API last produced for the configured embedding model.
      *
@@ -183,42 +225,20 @@ class GeminiBackend(
      *   store a partial space
      */
     override fun embed(texts: List<String>): CompletableFuture<List<FloatArray>> {
-        val future = CompletableFuture<List<FloatArray>>()
-        if (texts.isEmpty()) {
-            future.complete(emptyList())
-            return future
-        }
-        // close() cancels the scope, making launch a silent no-op; fail loudly instead.
-        if (!scope.isActive) {
-            future.completeExceptionally(IllegalStateException("Gemini backend is closed"))
-            return future
-        }
-
-        val job = scope.launch {
-            val keyStamp = storedKeyStamp()
-            try {
-                val apiKey = readGeminiApiKey()
-                if (apiKey.isNullOrBlank()) {
-                    // The same refusal a chat turn reports, through the same formatter.
-                    future.completeExceptionally(
-                        IOException(userMessage(GeminiFailure.KeyInvalid))
-                    )
-                    return@launch
-                }
-                future.complete(embedBatches(texts, apiKey))
-            } catch (e: CancellationException) {
-                future.cancel(true)
-                throw e
-            } catch (e: Exception) {
+        if (texts.isEmpty()) return CompletableFuture.completedFuture(emptyList())
+        val keyStamp = storedKeyStamp()
+        return launchFuture(
+            describeFailure = { e ->
                 context.logger.error("GeminiBackend: embedding ${texts.size} texts failed", e)
                 // The formatted sentence, not the raw body: this message reaches the user through
                 // whichever consumer asked, exactly as a refused chat turn's does.
-                future.completeExceptionally(IOException(formatErrorMessage(e, keyStamp), e))
-            }
+                IOException(formatErrorMessage(e, keyStamp), e)
+            },
+        ) {
+            val apiKey = readGeminiApiKey()
+            if (apiKey.isNullOrBlank()) throw ReportedFailure(missingKeyMessage())
+            embedBatches(texts, apiKey)
         }
-        future.cancelJobOnCancel(job)
-
-        return future
     }
 
     /**
@@ -670,36 +690,22 @@ class GeminiBackend(
      * network/API failure, so the caller can fall back to a current-models-only list and
      * never advertise a dead model.
      */
-    internal fun listCatalog(): CompletableFuture<ModelCatalog> {
-        val future = CompletableFuture<ModelCatalog>()
-        // close() cancels the scope, making launch a silent no-op; fail loudly instead, or the
-        // gateway's blocking get() would sit at "Loading" for its full 60-second timeout.
-        if (!scope.isActive) {
-            future.completeExceptionally(IllegalStateException("Gemini backend is closed"))
-            return future
-        }
-
-        val job = scope.launch {
-            try {
-                val key = readGeminiApiKey()
-                if (key.isNullOrBlank()) {
-                    context.logger.warn("GeminiBackend: no API key configured; cannot list live models")
-                    future.complete(ModelCatalog.EMPTY)
-                    return@launch
-                }
-                future.complete(describeCatalog(key))
-            } catch (e: CancellationException) {
-                future.cancel(true)
-                throw e
-            } catch (e: Exception) {
+    internal fun listCatalog(): CompletableFuture<ModelCatalog> =
+        // A closed scope fails at once, not after the gateway's blocking 60-second get().
+        launchFuture(
+            describeFailure = { e ->
                 context.logger.error("GeminiBackend: Error in listCatalog", e)
-                future.completeExceptionally(e)
+                e
+            },
+        ) {
+            val key = readGeminiApiKey()
+            if (key.isNullOrBlank()) {
+                context.logger.warn("GeminiBackend: no API key configured; cannot list live models")
+                ModelCatalog.EMPTY
+            } else {
+                describeCatalog(key)
             }
         }
-        future.cancelJobOnCancel(job)
-
-        return future
-    }
 
     /**
      * List the models a caller-supplied [apiKey] can use, instead of the one saved on disk.
@@ -713,32 +719,19 @@ class GeminiBackend(
      *   status code out of that message to tell a refused key from an unreachable network
      */
     internal fun listCatalog(apiKey: String): CompletableFuture<ModelCatalog> {
-        val future = CompletableFuture<ModelCatalog>()
         val key = apiKey.trim()
         if (key.isEmpty()) {
-            future.completeExceptionally(IllegalArgumentException("Gemini API key is blank"))
-            return future
-        }
-        // close() cancels the scope, making launch a silent no-op; fail loudly instead.
-        if (!scope.isActive) {
-            future.completeExceptionally(IllegalStateException("Gemini backend is closed"))
-            return future
-        }
-
-        val job = scope.launch {
-            try {
-                future.complete(describeCatalog(key))
-            } catch (e: CancellationException) {
-                future.cancel(true)
-                throw e
-            } catch (e: Exception) {
-                context.logger.warn("GeminiBackend: candidate key check failed: ${e.message}")
-                future.completeExceptionally(e)
+            // Not CompletableFuture.failedFuture: that is API 31, and the host still runs on 28.
+            return CompletableFuture<ModelCatalog>().apply {
+                completeExceptionally(IllegalArgumentException("Gemini API key is blank"))
             }
         }
-        future.cancelJobOnCancel(job)
-
-        return future
+        return launchFuture(
+            describeFailure = { e ->
+                context.logger.warn("GeminiBackend: candidate key check failed: ${e.message}")
+                e
+            },
+        ) { describeCatalog(key) }
     }
 
     /**
@@ -1098,6 +1091,65 @@ class GeminiBackend(
         }
     }
 
+    /**
+     * Runs [block] on this backend's scope and completes the returned future with its value.
+     *
+     * Cancelling the future cancels [block], and a closed backend fails the future at once: after
+     * close() cancels the scope, launch is a silent no-op that would leave it pending forever.
+     *
+     * @param describeFailure turns what [block] threw into what the future fails with; a
+     *   [ReportedFailure] skips it, being already in the user's words
+     */
+    private fun <T> launchFuture(
+        describeFailure: (Exception) -> Throwable,
+        block: suspend () -> T,
+    ): CompletableFuture<T> {
+        val future = CompletableFuture<T>()
+        if (!scope.isActive) {
+            future.completeExceptionally(IllegalStateException("Gemini backend is closed"))
+            return future
+        }
+
+        val job = scope.launch {
+            try {
+                future.complete(block())
+            } catch (e: CancellationException) {
+                future.cancel(true)
+                throw e
+            } catch (e: ReportedFailure) {
+                future.completeExceptionally(e)
+            } catch (e: Exception) {
+                future.completeExceptionally(describeFailure(e))
+            }
+        }
+        future.cancelJobOnCancel(job)
+        return future
+    }
+
+    /**
+     * Why no key could be used, in words that do not blame a key that was never sent: none saved,
+     * one this device can no longer decrypt, or a Keystore that did not answer this time.
+     */
+    private fun missingKeyMessage(): String {
+        val stored = runCatching {
+            secureApiKeyStore.readAndMigrate(agentPrefs(), GeminiPreferences.KEY_API_KEY)
+        }.getOrNull()
+        val res = when (stored) {
+            KeystoreSecretStore.Stored.Absent -> R.string.gemini_error_key_missing
+            is KeystoreSecretStore.Stored.Value ->
+                // Readable now but not a moment ago, or saved blank; only blank lasts.
+                if (stored.plain.isBlank()) R.string.gemini_error_key_missing
+                else R.string.msg_api_key_unavailable
+            KeystoreSecretStore.Stored.Unreadable -> R.string.msg_api_key_unreadable
+            KeystoreSecretStore.Stored.Unavailable, null -> R.string.msg_api_key_unavailable
+        }
+        return try {
+            context.androidContext.getString(res)
+        } catch (e: Exception) {
+            "No usable Gemini API key"
+        }
+    }
+
     /**
      * Turn a failure into one user-facing sentence.
      *
@@ -1181,6 +1233,12 @@ class GeminiBackend(
     }
 }
 
+/**
+ * A failure already worded for the user, which [GeminiBackend]'s future helper passes on as it is
+ * instead of classifying it again as a transport error.
+ */
+private class ReportedFailure(message: String) : IOException(message)
+
 /**
  * Cancel [job] when this future is cancelled by its caller.
  *
diff --git a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/ModelCatalog.kt b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/ModelCatalog.kt
index ad3f70ed..8e9ce704 100644
--- a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/ModelCatalog.kt
+++ b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/ModelCatalog.kt
@@ -1,11 +1,8 @@
 package com.itsaky.androidide.plugins.aiagentgemini.backend
 
 /**
- * One key's catalog, split into the models each picker may offer.
- *
- * Carried as one value because both halves come from one paginated `ListModels` walk, filtered on
- * the capability each model declares: fetching them separately would pay for the walk twice and
- * let the two pickers describe different snapshots.
+ * One key's catalog, split by declared capability: chat models for this plugin's settings pane,
+ * embedding models for Vector Search's. One value because both come from one `ListModels` walk.
  *
  * @param chat models that advertise `generateContent`
  * @param embedding models that advertise `embedContent`
diff --git a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/plugin/GeminiPlugin.kt b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/plugin/GeminiPlugin.kt
index fc1249fb..f838285a 100644
--- a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/plugin/GeminiPlugin.kt
+++ b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/plugin/GeminiPlugin.kt
@@ -49,11 +49,17 @@ class GeminiPlugin : IPlugin, DocumentationExtension {
         // Tags for the controls on this backend's settings pane (see GeminiSettingsFragment).
         const val TOOLTIP_TAG_SETTINGS_GEMINI_KEY = "ai_gemini_key"
         const val TOOLTIP_TAG_SETTINGS_GEMINI_MODEL = "ai_gemini_model"
-        const val TOOLTIP_TAG_SETTINGS_GEMINI_EMBEDDING_MODEL = "ai_gemini_embedding_model"
         const val TOOLTIP_TAG_SETTINGS_GET_KEY = "ai_gemini_get_free_key"
 
-        /** The settings that change what [GeminiBackend.isAvailable] or its model name answers. */
-        private val WATCHED_KEYS = setOf(GeminiPreferences.KEY_API_KEY, GeminiPreferences.KEY_MODEL)
+        /**
+         * The settings that change what [GeminiBackend.isAvailable], its model name or its
+         * embedding model answers; the last is set from Vector Search, which re-reads on notice.
+         */
+        private val WATCHED_KEYS = setOf(
+            GeminiPreferences.KEY_API_KEY,
+            GeminiPreferences.KEY_MODEL,
+            GeminiPreferences.KEY_EMBEDDING_MODEL,
+        )
 
         @Volatile
         private var pluginContext: PluginContext? = null
@@ -220,22 +226,6 @@ class GeminiPlugin : IPlugin, DocumentationExtension {
                 current models is shown instead.</p>
             """.trimIndent(),
         ),
-        PluginTooltipEntry(
-            tag = TOOLTIP_TAG_SETTINGS_GEMINI_EMBEDDING_MODEL,
-            summary = "Which model turns your code into vectors for semantic search. Never used for chat.",
-            detail = """
-                <p>Semantic search compares meaning rather than words, which it
-                does by embedding every chunk of the project with this model. It
-                is a separate setting because no Gemini model does both: this list
-                holds the models that advertise <code>embedContent</code>, and the
-                <b>Model</b> list above holds those that advertise
-                <code>generateContent</code>.</p>
-                <p>Changing it changes the vector space, so the project is indexed
-                again from scratch. Vectors from two different models are not
-                comparable, and mixing them would quietly return worse results
-                rather than fail.</p>
-            """.trimIndent(),
-        ),
         PluginTooltipEntry(
             tag = TOOLTIP_TAG_SETTINGS_GET_KEY,
             summary = "Opens Google AI Studio in your browser, where API keys are free to create.",
diff --git a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/CatalogResult.kt b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/CatalogResult.kt
index e0eeb829..fcd741c1 100644
--- a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/CatalogResult.kt
+++ b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/CatalogResult.kt
@@ -9,19 +9,11 @@ package com.itsaky.androidide.plugins.aiagentgemini.settings
 sealed interface CatalogResult {
 
     /**
-     * The backend answered. Either list may be empty, which for [models] is itself suspicious for
-     * a valid key.
-     *
-     * Both halves come from one paginated walk, split by the method each model declares, so they
-     * describe the same snapshot of the same key.
+     * The backend answered. The list may be empty, which is itself suspicious for a valid key.
      *
      * @param models the chat-capable models the key can reach
-     * @param embeddingModels the embedding-capable models the key can reach
      */
-    data class Success(
-        val models: List<String>,
-        val embeddingModels: List<String>,
-    ) : CatalogResult
+    data class Success(val models: List<String>) : CatalogResult
 
     /** No "gemini" backend was resolvable — ai-core or ai-agent-gemini is missing, disabled,
      * or not yet active. */
diff --git a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiCatalogGateway.kt b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiCatalogGateway.kt
index a57c006e..d6f71e22 100644
--- a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiCatalogGateway.kt
+++ b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiCatalogGateway.kt
@@ -96,7 +96,7 @@ class BackendGeminiCatalogGateway(
         return try {
             val catalog = future.get(LIST_MODELS_TIMEOUT_SECONDS, TimeUnit.SECONDS)
                 ?: ModelCatalog.EMPTY
-            CatalogResult.Success(catalog.chat, catalog.embedding)
+            CatalogResult.Success(catalog.chat)
         } catch (e: ExecutionException) {
             // The API failure the backend reported; its message carries the HTTP status.
             CatalogResult.Failed(e.cause ?: e)
diff --git a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsFragment.kt b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsFragment.kt
index 2a3aed6f..667442fd 100644
--- a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsFragment.kt
+++ b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsFragment.kt
@@ -20,10 +20,7 @@ import android.widget.LinearLayout
 import android.widget.TextView
 import android.widget.Toast
 import androidx.annotation.DrawableRes
-import androidx.annotation.IdRes
-import androidx.annotation.StringRes
 import androidx.fragment.app.Fragment
-import androidx.lifecycle.LiveData
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
@@ -147,8 +144,7 @@ class GeminiSettingsFragment : Fragment() {
 
         view.applyPaneStyling(PANE_STYLE, OUTLINED_BUTTON_IDS)
         setupApiKeyUi(view)
-        setupModelPicker(view, chatModelPicker())
-        setupModelPicker(view, embeddingModelPicker())
+        setupModelPicker(view)
         setupModelRefresh(view)
     }
 
@@ -642,59 +638,7 @@ class GeminiSettingsFragment : Fragment() {
         box.isEndIconCheckable = false
     }
 
-    // --- Model pickers -------------------------------------------------------------------------
-
-    /**
-     * Everything one model dropdown needs, so the chat and embedding pickers are one
-     * implementation rather than two that drift.
-     *
-     * @param tooltipTag long-press help shared by the picker's label, field, hint and chevron
-     * @param helpHint hint shown while no catalog is offered
-     * @param liveHint hint shown once there is a list to tap
-     * @param read the currently saved model
-     * @param write persists a model the user picked
-     * @param options the catalog to offer
-     */
-    private class ModelPicker(
-        @IdRes val boxId: Int,
-        @IdRes val inputId: Int,
-        @IdRes val labelId: Int,
-        @IdRes val hintId: Int,
-        val tooltipTag: String,
-        @StringRes val helpHint: Int,
-        @StringRes val liveHint: Int,
-        val read: () -> String,
-        val write: (String) -> Unit,
-        val options: LiveData<GeminiModelOptions>,
-    )
-
-    /** The chat model: what a turn is generated with. */
-    private fun chatModelPicker() = ModelPicker(
-        boxId = R.id.gemini_model_box,
-        inputId = R.id.gemini_model_input,
-        labelId = R.id.gemini_model_label,
-        hintId = R.id.gemini_model_hint_text,
-        tooltipTag = GeminiPlugin.TOOLTIP_TAG_SETTINGS_GEMINI_MODEL,
-        helpHint = R.string.hint_gemini_model_help,
-        liveHint = R.string.hint_gemini_model_live,
-        read = viewModel::getGeminiModel,
-        write = viewModel::saveGeminiModel,
-        options = viewModel.geminiModels,
-    )
-
-    /** The embedding model: what semantic search indexes and queries with. */
-    private fun embeddingModelPicker() = ModelPicker(
-        boxId = R.id.gemini_embedding_model_box,
-        inputId = R.id.gemini_embedding_model_input,
-        labelId = R.id.gemini_embedding_model_label,
-        hintId = R.id.gemini_embedding_model_hint_text,
-        tooltipTag = GeminiPlugin.TOOLTIP_TAG_SETTINGS_GEMINI_EMBEDDING_MODEL,
-        helpHint = R.string.hint_gemini_embedding_model_help,
-        liveHint = R.string.hint_gemini_embedding_model_live,
-        read = viewModel::getGeminiEmbeddingModel,
-        write = viewModel::saveGeminiEmbeddingModel,
-        options = viewModel.geminiEmbeddingModels,
-    )
+    // --- Model picker --------------------------------------------------------------------------
 
     /**
      * One model dropdown, built as the same control the OpenAI pane carries rather than a
@@ -704,16 +648,16 @@ class GeminiSettingsFragment : Fragment() {
      * unlike the OpenAI pane there is no free-text model to type. The field itself is what shows
      * the model in use, which is why there is no separate "current model" line any more.
      */
-    private fun setupModelPicker(view: View, picker: ModelPicker) {
-        val modelBox = view.findViewById<TextInputLayout>(picker.boxId)
-        val modelInput = view.findViewById<AutoCompleteTextView>(picker.inputId)
-        val modelLabel = view.findViewById<TextView>(picker.labelId)
-        val modelHint = view.findViewById<TextView>(picker.hintId)
+    private fun setupModelPicker(view: View) {
+        val modelBox = view.findViewById<TextInputLayout>(R.id.gemini_model_box)
+        val modelInput = view.findViewById<AutoCompleteTextView>(R.id.gemini_model_input)
+        val modelLabel = view.findViewById<TextView>(R.id.gemini_model_label)
+        val modelHint = view.findViewById<TextView>(R.id.gemini_model_hint_text)
 
         setupDropdownEndIcon(modelBox)
 
         listOf<View>(modelLabel, modelInput, modelHint)
-            .forEach { wireTooltip(it, picker.tooltipTag) }
+            .forEach { wireTooltip(it, GeminiPlugin.TOOLTIP_TAG_SETTINGS_GEMINI_MODEL) }
 
         // A picker, not a text field: the list is the only way to change it.
         modelInput.keyListener = null
@@ -722,20 +666,20 @@ class GeminiSettingsFragment : Fragment() {
         // the list holding only the selected entry after a day/night switch.
         modelInput.isSaveEnabled = false
         // The suppressing overload throughout: a filtering write would narrow the list.
-        modelInput.setText(picker.read(), false)
+        modelInput.setText(viewModel.getGeminiModel(), false)
 
         // Tapping anywhere in the field opens the list; the end icon is only a second way in.
         modelInput.setOnClickListener { modelInput.showDropDown() }
         modelBox.setEndIconOnClickListener { modelInput.showDropDown() }
-        wireEndIconTooltip(modelBox, picker.tooltipTag)
+        wireEndIconTooltip(modelBox, GeminiPlugin.TOOLTIP_TAG_SETTINGS_GEMINI_MODEL)
         // Only a real pick reaches here, so unlike the Spinner this replaced there is no
         // programmatic selection to tell apart from a user's.
         modelInput.setOnItemClickListener { parent, _, position, _ ->
             val selected = parent.getItemAtPosition(position) as? String
-            if (selected == null || selected == picker.read()) {
+            if (selected == null || selected == viewModel.getGeminiModel()) {
                 return@setOnItemClickListener
             }
-            picker.write(selected)
+            viewModel.saveGeminiModel(selected)
             Toast.makeText(
                 requireContext(),
                 getString(R.string.model_changed, selected),
@@ -743,7 +687,7 @@ class GeminiSettingsFragment : Fragment() {
             ).show()
         }
 
-        picker.options.observe(viewLifecycleOwner) { options ->
+        viewModel.geminiModels.observe(viewLifecycleOwner) { options ->
             // Cleared, not left stale: an empty list means there is no catalog to offer, and a
             // remembered one would suggest models this key may no longer reach.
             modelInput.setAdapter(
@@ -753,25 +697,23 @@ class GeminiSettingsFragment : Fragment() {
                     DropdownAdapter(modelInput.context, options.models)
                 }
             )
-            modelHint.setText(if (options.models.isEmpty()) picker.helpHint else picker.liveHint)
+            modelHint.setText(
+                if (options.models.isEmpty()) R.string.hint_gemini_model_help
+                else R.string.hint_gemini_model_live
+            )
 
             // Migrate off a retired saved model only for a live catalog, never for the fallback:
             // the field has to show what will actually be requested.
-            if (!options.isLive || options.models.contains(picker.read())) {
+            if (!options.isLive || options.models.contains(viewModel.getGeminiModel())) {
                 return@observe
             }
             val migrated = options.models.firstOrNull() ?: return@observe
-            picker.write(migrated)
+            viewModel.saveGeminiModel(migrated)
             modelInput.setText(migrated, false)
         }
     }
 
-    /**
-     * The one Refresh button, shared by both pickers since one catalog walk answers them both.
-     *
-     * The initial fetch is guarded on the chat picker alone: the two are published together, so a
-     * non-empty chat list means the fetch has already happened.
-     */
+    /** The Refresh button; a non-empty model list means the initial fetch has already happened. */
     private fun setupModelRefresh(view: View) {
         val refreshButton = view.findViewById<Button>(R.id.btn_refresh_models)
         wireTooltip(refreshButton, GeminiPlugin.TOOLTIP_TAG_SETTINGS_GEMINI_MODEL)
diff --git a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsViewModel.kt b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsViewModel.kt
index 496447dd..54a2dafd 100644
--- a/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsViewModel.kt
+++ b/plugins/AI-Agent-Gemini/src/main/kotlin/com/itsaky/androidide/plugins/aiagentgemini/settings/GeminiSettingsViewModel.kt
@@ -46,7 +46,6 @@ class GeminiSettingsViewModel(
         private val KEY_API_KEY_TIMESTAMP = GeminiPreferences.KEY_API_KEY_TIMESTAMP
         private val KEY_API_KEY_VERIFIED = GeminiPreferences.KEY_API_KEY_VERIFIED
         private val KEY_MODEL = GeminiPreferences.KEY_MODEL
-        private val KEY_EMBEDDING_MODEL = GeminiPreferences.KEY_EMBEDDING_MODEL
 
         /** Shown only when the live catalog can't be fetched — current models, no retired ones. */
         private val FALLBACK_MODELS = listOf(
@@ -54,12 +53,6 @@ class GeminiSettingsViewModel(
             "gemini-2.5-pro",
             "gemini-2.0-flash",
         )
-
-        /** The embedding half of [FALLBACK_MODELS], offered under the same conditions. */
-        private val FALLBACK_EMBEDDING_MODELS = listOf(
-            "gemini-embedding-001",
-            "text-embedding-004",
-        )
     }
 
     /**
@@ -75,10 +68,6 @@ class GeminiSettingsViewModel(
     private val _geminiModelsLoading = MutableLiveData(false)
     val geminiModelsLoading: LiveData<Boolean> get() = _geminiModelsLoading
 
-    private val _geminiEmbeddingModels =
-        MutableLiveData(GeminiModelOptions(emptyList(), isLive = false))
-    val geminiEmbeddingModels: LiveData<GeminiModelOptions> get() = _geminiEmbeddingModels
-
     /**
      * This plugin's own settings store — the same one [GeminiBackend] reads at request time, so a
      * key saved here is the key that gets used.
@@ -229,20 +218,6 @@ class GeminiSettingsViewModel(
     fun getGeminiModel(): String =
         prefs()?.getString(KEY_MODEL, GeminiBackend.DEFAULT_MODEL) ?: GeminiBackend.DEFAULT_MODEL
 
-    /**
-     * Stores [model] as the embedding model.
-     *
-     * Its own setting, not a second use of [saveGeminiModel]: the two catalogs are disjoint, and a
-     * chat model asked to embed answers 404.
-     */
-    fun saveGeminiEmbeddingModel(model: String) {
-        prefs()?.edit()?.putString(KEY_EMBEDDING_MODEL, model)?.apply()
-    }
-
-    fun getGeminiEmbeddingModel(): String =
-        prefs()?.getString(KEY_EMBEDDING_MODEL, GeminiBackend.DEFAULT_EMBEDDING_MODEL)
-            ?: GeminiBackend.DEFAULT_EMBEDDING_MODEL
-
     /**
      * Ask the backend for the models the current API key can actually use, and publish them to
      * [geminiModels]. Falls back to [FALLBACK_MODELS] (current models only — never a retired one)
@@ -265,19 +240,13 @@ class GeminiSettingsViewModel(
 
                 when (val result = catalogGateway.listModelsForSavedKey()) {
                     is CatalogResult.Success -> {
-                        if (result.models.isEmpty() && result.embeddingModels.isEmpty()) {
+                        if (result.models.isEmpty()) {
                             logger?.warn("$TAG: live model list empty; showing fallback models")
                             publishFallbackModels()
                         } else {
-                            logger?.debug(
-                                "$TAG: fetched ${result.models.size} chat and " +
-                                    "${result.embeddingModels.size} embedding Gemini models"
-                            )
-                            publishLive(_geminiModels, result.models, FALLBACK_MODELS)
-                            publishLive(
-                                _geminiEmbeddingModels,
-                                result.embeddingModels,
-                                FALLBACK_EMBEDDING_MODELS,
+                            logger?.debug("$TAG: fetched ${result.models.size} Gemini models")
+                            _geminiModels.postValue(
+                                GeminiModelOptions(result.models, isLive = true)
                             )
                         }
                     }
@@ -295,34 +264,8 @@ class GeminiSettingsViewModel(
         }
     }
 
-    /** Offers both pickers the current-models-only list, which never carries a retired model. */
+    /** Offers the current-models-only list, which never carries a retired model. */
     private fun publishFallbackModels() {
         _geminiModels.postValue(GeminiModelOptions(FALLBACK_MODELS, isLive = false))
-        _geminiEmbeddingModels.postValue(
-            GeminiModelOptions(FALLBACK_EMBEDDING_MODELS, isLive = false)
-        )
-    }
-
-    /**
-     * Publishes one half of a fetched catalog, falling back when this key can reach nothing of
-     * that kind.
-     *
-     * A key with no embedding models is possible while its chat list is healthy, and publishing an
-     * empty list would leave that picker blank with no way to pick anything at all.
-     *
-     * @param target the picker to publish to
-     * @param fetched what the key can reach, possibly empty
-     * @param fallback the current-models-only list to offer instead of nothing
-     */
-    private fun publishLive(
-        target: MutableLiveData<GeminiModelOptions>,
-        fetched: List<String>,
-        fallback: List<String>,
-    ) {
-        if (fetched.isEmpty()) {
-            target.postValue(GeminiModelOptions(fallback, isLive = false))
-        } else {
-            target.postValue(GeminiModelOptions(fetched, isLive = true))
-        }
     }
 }
diff --git a/plugins/AI-Agent-Gemini/src/main/res/layout/fragment_gemini_settings.xml b/plugins/AI-Agent-Gemini/src/main/res/layout/fragment_gemini_settings.xml
index 93c8c402..a08906d3 100644
--- a/plugins/AI-Agent-Gemini/src/main/res/layout/fragment_gemini_settings.xml
+++ b/plugins/AI-Agent-Gemini/src/main/res/layout/fragment_gemini_settings.xml
@@ -159,45 +159,7 @@
         android:text="@string/hint_gemini_model_help"
         android:textAppearance="@style/Plugin.Text.Small" />
 
-    <!-- Embedding model. The other half of the same catalog: semantic search embeds with this one,
-         never with the chat model above. -->
-
-    <TextView
-        android:id="@+id/gemini_embedding_model_label"
-        style="@style/Plugin.SectionHeader"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="@dimen/space_xl"
-        android:text="@string/label_gemini_embedding_model" />
-
-    <com.google.android.material.textfield.TextInputLayout
-        android:id="@+id/gemini_embedding_model_box"
-        style="@style/PluginTextInputLayout"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:hint="@string/hint_gemini_embedding_model"
-        app:endIconContentDescription="@string/cd_show_embedding_models"
-        app:endIconMode="custom">
-
-        <AutoCompleteTextView
-            android:id="@+id/gemini_embedding_model_input"
-            style="@style/PluginTextInputEditText"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:completionThreshold="0"
-            android:inputType="none"
-            android:popupBackground="@color/plugin_surface" />
-    </com.google.android.material.textfield.TextInputLayout>
-
-    <TextView
-        android:id="@+id/gemini_embedding_model_hint_text"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="@dimen/space_xs"
-        android:text="@string/hint_gemini_embedding_model_help"
-        android:textAppearance="@style/Plugin.Text.Small" />
-
-    <!-- One Refresh for both pickers: a single catalog walk fills both lists. -->
+    <!-- Refresh asks the key's live catalog for the model list. -->
     <com.google.android.material.button.MaterialButton
         android:id="@+id/btn_refresh_models"
         style="@style/PluginButton.Outlined"
diff --git a/plugins/AI-Agent-Gemini/src/main/res/values/strings.xml b/plugins/AI-Agent-Gemini/src/main/res/values/strings.xml
index e3abc351..573d1b0a 100644
--- a/plugins/AI-Agent-Gemini/src/main/res/values/strings.xml
+++ b/plugins/AI-Agent-Gemini/src/main/res/values/strings.xml
@@ -4,6 +4,7 @@
     <string name="gemini_error_model_unavailable">The model \"%1$s\" is no longer available to your API key. Open AI Settings, tap Refresh Models and choose another model.</string>
     <string name="gemini_error_quota">You have reached your Gemini rate limit or quota. Wait a moment and try again, or check your usage in Google AI Studio.</string>
     <string name="gemini_error_key_refused">Google refused your Gemini API key. Re-enter it in AI Settings.</string>
+    <string name="gemini_error_key_missing">No Gemini API key is saved. Enter one in AI Settings.</string>
     <string name="gemini_error_key_invalid">Your Gemini API key is not valid. Re-enter it in AI Settings.</string>
     <string name="gemini_error_request_rejected">Gemini rejected the request.</string>
     <string name="gemini_error_request_rejected_reason">Gemini rejected the request. %1$s</string>
@@ -60,11 +61,6 @@
     <string name="cd_show_models">Show the model list</string>
     <string name="hint_gemini_model_help">Refresh to list the models your key can reach.</string>
     <string name="hint_gemini_model_live">Tap to pick from the models this key can reach.</string>
-    <string name="label_gemini_embedding_model">Embedding Model</string>
-    <string name="hint_gemini_embedding_model">Gemini embedding model</string>
-    <string name="cd_show_embedding_models">Show the embedding model list</string>
-    <string name="hint_gemini_embedding_model_help">Used by semantic search, never for chat. Refresh to list the embedding models your key can reach.</string>
-    <string name="hint_gemini_embedding_model_live">Tap to pick from the embedding models this key can reach.</string>
     <string name="refresh_models">Refresh Models</string>
     <string name="loading">Loading…</string>
     <string name="model_changed">Model changed to %s</string>
diff --git a/plugins/AI-Agent-Gemini/src/test/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/GeminiEmbeddingModelSelectionTest.kt b/plugins/AI-Agent-Gemini/src/test/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/GeminiEmbeddingModelSelectionTest.kt
new file mode 100644
index 00000000..b71d27d0
--- /dev/null
+++ b/plugins/AI-Agent-Gemini/src/test/kotlin/com/itsaky/androidide/plugins/aiagentgemini/backend/GeminiEmbeddingModelSelectionTest.kt
@@ -0,0 +1,60 @@
+package com.itsaky.androidide.plugins.aiagentgemini.backend
+
+import android.content.SharedPreferences
+import com.itsaky.androidide.plugins.PluginContext
+import com.itsaky.androidide.plugins.aiagentgemini.preferences.GeminiPreferences
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import java.util.concurrent.ExecutionException
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class GeminiEmbeddingModelSelectionTest {
+
+    private val editor = mockk<SharedPreferences.Editor>(relaxed = true)
+    private val prefs = mockk<SharedPreferences>(relaxed = true) {
+        every { edit() } returns editor
+        every { getString(GeminiPreferences.KEY_EMBEDDING_MODEL, any()) } returns "gemini-embedding-001"
+    }
+    private val context = mockk<PluginContext>(relaxed = true) {
+        every { getPluginSharedPreferences(any()) } returns prefs
+    }
+    private val backend = GeminiBackend(context) { null }
+
+    init {
+        every { editor.putString(any(), any()) } returns editor
+    }
+
+    @Test
+    fun givenAPaddedModel_whenSet_thenItIsStoredTrimmedWhereTheBackendReadsIt() {
+        backend.setEmbeddingModelId(" text-embedding-004 ")
+
+        verify { editor.putString(GeminiPreferences.KEY_EMBEDDING_MODEL, "text-embedding-004") }
+    }
+
+    @Test
+    fun givenTheCurrentModel_whenSetAgain_thenNothingIsWritten() {
+        // No write, so no change notice: the contract lets an unchanged model notify nobody.
+        backend.setEmbeddingModelId("gemini-embedding-001")
+
+        verify(exactly = 0) { editor.putString(any(), any()) }
+    }
+
+    @Test
+    fun givenABlankModel_whenSet_thenItIsRejected() {
+        assertThrows(IllegalArgumentException::class.java) { backend.setEmbeddingModelId("  ") }
+    }
+
+    @Test
+    fun givenAClosedBackend_whenListingModels_thenTheFutureFailsAtOnce() {
+        backend.close()
+
+        val future = backend.listEmbeddingModels()
+
+        assertTrue(future.isCompletedExceptionally)
+        val failure = assertThrows(ExecutionException::class.java) { future.get() }
+        assertTrue(failure.cause is IllegalStateException)
+    }
+}
diff --git a/plugins/AI-Agent-OpenAI/README.md b/plugins/AI-Agent-OpenAI/README.md
index 7c098c52..f35fd8bb 100644
--- a/plugins/AI-Agent-OpenAI/README.md
+++ b/plugins/AI-Agent-OpenAI/README.md
@@ -192,7 +192,7 @@ root of `com/itsaky/androidide/plugins/aiagentopenai/`.
 - `backend/OpenAiToolProtocol.kt` — `tools[]`, `tool_choice` and the streamed `tool_calls` accumulator (pure)
 - `backend/RequestTuning.kt` — reasoning-model parameters, the 400-retry rule and tool-refusal detection (pure)
 - `backend/SseChunk.kt` — one line of the token stream, text or `tool_calls` deltas (pure)
-- `backend/ModelCatalogFilter.kt` — splits one catalog into the chat and embedding pickers (pure)
+- `backend/ModelCatalogFilter.kt` — splits one catalog into chat and embedding models (pure)
 - `backend/OpenAiEmbeddingProtocol.kt` — the `/v1/embeddings` body, batching and index-ordered reply (pure)
 - `errors/OpenAiErrorFormatter.kt` — turns a failure into one translated sentence
 - `security/SecureApiKeyStore.kt` — this plugin's Keystore alias, over the IDE's `KeystoreSecretStore`
diff --git a/plugins/AI-Agent-OpenAI/src/main/AndroidManifest.xml b/plugins/AI-Agent-OpenAI/src/main/AndroidManifest.xml
index c5edba4c..3fb5ed0b 100644
--- a/plugins/AI-Agent-OpenAI/src/main/AndroidManifest.xml
+++ b/plugins/AI-Agent-OpenAI/src/main/AndroidManifest.xml
@@ -44,7 +44,8 @@
             android:value="App Dev for All" />
 
         <!-- 26.41: the first release whose plugin-api carries the capability-tag contract;
-             this backend reports getActiveModelName() and notifyBackendChanged() (ADFA-6278).
+             this backend reports getActiveModelName() and notifyBackendChanged() (ADFA-6278), and
+             implements EmbeddingModelSelectable for Vector Search's settings screen (ADFA-6303).
              Do not lower it. -->
         <meta-data
             android:name="plugin.min_ide_version"
diff --git a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalog.kt b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalog.kt
index 717c9c19..793f5830 100644
--- a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalog.kt
+++ b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalog.kt
@@ -1,13 +1,11 @@
 package com.itsaky.androidide.plugins.aiagentopenai.backend
 
 /**
- * One server's catalog, split into the models each picker may offer.
- *
- * Carried as one value because both halves come from one `GET /v1/models`: fetching them
- * separately would let the two pickers describe different snapshots of the same server.
+ * One server's catalog: chat models for this plugin's settings pane, embedding models for Vector
+ * Search's. One value because both come from one `GET /v1/models`, so they describe one snapshot.
  *
  * @param chat models the chat picker may offer
- * @param embedding models the embedding picker may offer
+ * @param embedding models Vector Search's embedding picker may offer
  */
 internal data class ModelCatalog(
     val chat: List<String>,
diff --git a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalogFilter.kt b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalogFilter.kt
index fb93ec08..7aa4808f 100644
--- a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalogFilter.kt
+++ b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/ModelCatalogFilter.kt
@@ -15,8 +15,8 @@ internal object ModelCatalogFilter {
      * Substrings that mark an embedding model.
      *
      * The embedding picker is an allowlist over these — a model it wrongly omits can still be
-     * typed in, and one it wrongly offers fails once with a clear server error. The families
-     * after the generic markers are the local-server ones whose ids say nothing about embedding:
+     * typed into Vector Search's picker, and one it wrongly offers fails once with a clear server
+     * error. The families after the generic markers are the local-server ones whose ids say nothing about embedding:
      * `bge-m3`, `all-minilm`, `gte-large` and `e5-base` would otherwise be missing from the
      * embedding picker and offered in the chat one.
      */
diff --git a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/OpenAiBackend.kt b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/OpenAiBackend.kt
index 247ae6ae..83542422 100644
--- a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/OpenAiBackend.kt
+++ b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/OpenAiBackend.kt
@@ -73,7 +73,8 @@ class OpenAiBackend(
     private val promptConfig: () -> OpenAiPromptConfig?,
     onStatusChanged: () -> Unit = {},
 ) : HistoryCapableBackend, CancellableBackend, ConfigurableBackend, ToolCallingBackend,
-    EmbeddingBackend, WebSearchBackend, StatusReportingBackend, ActiveModelReportingBackend {
+    EmbeddingModelSelectable, WebSearchBackend, StatusReportingBackend,
+    ActiveModelReportingBackend {
 
     private val scope = CoroutineScope(Dispatchers.IO)
 
@@ -192,6 +193,43 @@ class OpenAiBackend(
             ?.trim()?.takeIf { it.isNotEmpty() }
             ?: DEFAULT_EMBEDDING_MODEL
 
+    /**
+     * The models the configured server offers for embedding, as the settings catalog splits them.
+     *
+     * The key is read inside the launched work rather than on the caller's thread: decrypting it
+     * is a Keystore round trip, and the screen offering the choice calls this from the UI thread.
+     *
+     * @return the embedding models, or a future completed exceptionally with the same formatted
+     *   sentence a refused chat turn shows — a missing key on OpenAI's own API answers 401
+     */
+    override fun listEmbeddingModels(): CompletableFuture<List<String>> {
+        val keyStamp = storedKeyStamp()
+        return launchFuture(
+            describeFailure = { e ->
+                context.logger.warn("OpenAiBackend: listing embedding models failed: ${e.message}")
+                IOException(formatErrorMessage(e, keyStamp), e)
+            },
+        ) { fetchAvailableModels(readApiKeyOrBlank(), getBaseUrl()).embedding }
+    }
+
+    /**
+     * Stores [modelId] stamped with its server ([OpenAiPreferences.KEY_EMBEDDING_MODEL_URL]). The
+     * plugin watches the key, so the write is what tells AI Core's listeners; the current model set
+     * again writes only when it was stamped for another server.
+     */
+    override fun setEmbeddingModelId(modelId: String) {
+        val model = modelId.trim()
+        require(model.isNotEmpty()) { "The embedding model id must not be empty" }
+        val baseUrl = getBaseUrl()
+        val stampedFor = openAiPrefs()?.getString(OpenAiPreferences.KEY_EMBEDDING_MODEL_URL, null)
+        if (model == getEmbeddingModelId() && stampedFor == baseUrl) return
+        openAiPrefs()?.edit()
+            ?.putString(OpenAiPreferences.KEY_EMBEDDING_MODEL, model)
+            ?.putString(OpenAiPreferences.KEY_EMBEDDING_MODEL_URL, baseUrl)
+            ?.apply()
+        context.logger.info("OpenAiBackend: embedding model set to $model")
+    }
+
     /**
      * Vector length this server last produced for the configured embedding model.
      *
@@ -213,34 +251,16 @@ class OpenAiBackend(
      *   than store a partial space
      */
     override fun embed(texts: List<String>): CompletableFuture<List<FloatArray>> {
-        val future = CompletableFuture<List<FloatArray>>()
-        if (texts.isEmpty()) {
-            future.complete(emptyList())
-            return future
-        }
-        // close() cancels the scope, making launch a silent no-op; fail loudly instead.
-        if (!scope.isActive) {
-            future.completeExceptionally(IllegalStateException("OpenAI backend is closed"))
-            return future
-        }
-
-        val job = scope.launch {
-            val keyStamp = storedKeyStamp()
-            try {
-                future.complete(embedBatches(texts))
-            } catch (e: CancellationException) {
-                future.cancel(true)
-                throw e
-            } catch (e: Exception) {
+        if (texts.isEmpty()) return CompletableFuture.completedFuture(emptyList())
+        val keyStamp = storedKeyStamp()
+        return launchFuture(
+            describeFailure = { e ->
                 context.logger.error("OpenAiBackend: embedding ${texts.size} texts failed", e)
                 // The formatted sentence, not the raw body: this message reaches the user through
                 // whichever consumer asked, exactly as a refused chat turn's does.
-                future.completeExceptionally(IOException(formatErrorMessage(e, keyStamp), e))
-            }
-        }
-        future.cancelJobOnCancel(job)
-
-        return future
+                IOException(formatErrorMessage(e, keyStamp), e)
+            },
+        ) { embedBatches(texts) }
     }
 
     /**
@@ -991,9 +1011,34 @@ class OpenAiBackend(
      * @param apiKey the candidate key, or blank for a server that needs none; never logged
      * @param baseUrl the candidate server, normalized by the caller
      */
-    internal fun listCatalog(apiKey: String, baseUrl: String): CompletableFuture<ModelCatalog> {
-        val future = CompletableFuture<ModelCatalog>()
-        // close() cancels the scope, making launch a silent no-op; fail loudly instead.
+    internal fun listCatalog(apiKey: String, baseUrl: String): CompletableFuture<ModelCatalog> =
+        launchFuture(
+            describeFailure = { e ->
+                context.logger.warn("OpenAiBackend: model listing failed: ${e.message}")
+                e
+            },
+        ) {
+            val catalog = fetchAvailableModels(apiKey.trim(), baseUrl)
+            context.logger.info(
+                "OpenAiBackend: $baseUrl offers ${catalog.chat.size} chat and " +
+                    "${catalog.embedding.size} embedding models"
+            )
+            catalog
+        }
+
+    /**
+     * Runs [block] on this backend's scope and completes the returned future with its value.
+     *
+     * Cancelling the future cancels [block], and a closed backend fails the future at once: after
+     * close() cancels the scope, launch is a silent no-op that would leave it pending forever.
+     *
+     * @param describeFailure turns what [block] threw into what the future fails with
+     */
+    private fun <T> launchFuture(
+        describeFailure: (Exception) -> Throwable,
+        block: suspend () -> T,
+    ): CompletableFuture<T> {
+        val future = CompletableFuture<T>()
         if (!scope.isActive) {
             future.completeExceptionally(IllegalStateException("OpenAI backend is closed"))
             return future
@@ -1001,22 +1046,15 @@ class OpenAiBackend(
 
         val job = scope.launch {
             try {
-                val catalog = fetchAvailableModels(apiKey.trim(), baseUrl)
-                context.logger.info(
-                    "OpenAiBackend: $baseUrl offers ${catalog.chat.size} chat and " +
-                        "${catalog.embedding.size} embedding models"
-                )
-                future.complete(catalog)
+                future.complete(block())
             } catch (e: CancellationException) {
                 future.cancel(true)
                 throw e
             } catch (e: Exception) {
-                context.logger.warn("OpenAiBackend: model listing failed: ${e.message}")
-                future.completeExceptionally(e)
+                future.completeExceptionally(describeFailure(e))
             }
         }
         future.cancelJobOnCancel(job)
-
         return future
     }
 
diff --git a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/plugin/OpenAiPlugin.kt b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/plugin/OpenAiPlugin.kt
index 7f3177cd..392c080a 100644
--- a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/plugin/OpenAiPlugin.kt
+++ b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/plugin/OpenAiPlugin.kt
@@ -44,15 +44,18 @@ class OpenAiPlugin : IPlugin, DocumentationExtension {
         const val TOOLTIP_TAG_SETTINGS_PRESET = "ai_openai_preset"
         const val TOOLTIP_TAG_SETTINGS_KEY = "ai_openai_key"
         const val TOOLTIP_TAG_SETTINGS_MODEL = "ai_openai_model"
-        const val TOOLTIP_TAG_SETTINGS_EMBEDDING_MODEL = "ai_openai_embedding_model"
         const val TOOLTIP_TAG_SETTINGS_TEST = "ai_openai_test_connection"
         const val TOOLTIP_TAG_SETTINGS_GET_KEY = "ai_openai_get_key"
 
-        /** The settings that change what [OpenAiBackend.isAvailable] or its model name answers. */
+        /**
+         * The settings that change what [OpenAiBackend.isAvailable], its model name or its
+         * embedding model answers; the last is set from Vector Search, which re-reads on notice.
+         */
         private val WATCHED_KEYS = setOf(
             OpenAiPreferences.KEY_BASE_URL,
             OpenAiPreferences.KEY_API_KEY,
             OpenAiPreferences.KEY_MODEL,
+            OpenAiPreferences.KEY_EMBEDDING_MODEL,
         )
 
         /** The settings that change whether the server answers [OpenAiBackend.checkServer]. */
@@ -265,23 +268,6 @@ class OpenAiPlugin : IPlugin, DocumentationExtension {
                 out and anything unrecognised is kept.</p>
             """.trimIndent(),
         ),
-        PluginTooltipEntry(
-            tag = TOOLTIP_TAG_SETTINGS_EMBEDDING_MODEL,
-            summary = "Which model turns your code into vectors for semantic search. Never used for chat.",
-            detail = """
-                <p>Semantic search compares meaning rather than words, which it
-                does by embedding every chunk of the project with this model. It
-                is a separate setting because embedding models and chat models are
-                different models: this list offers exactly what the <b>Model</b>
-                list above filters out.</p>
-                <p>Changing it changes the vector space, so the project is indexed
-                again from scratch. Vectors from two different models are not
-                comparable, and mixing them would quietly return worse results
-                rather than fail.</p>
-                <p>Free text always works, which matters for a local server —
-                <code>nomic-embed-text</code> on Ollama, for example.</p>
-            """.trimIndent(),
-        ),
         PluginTooltipEntry(
             tag = TOOLTIP_TAG_SETTINGS_TEST,
             summary = "Checks the server and key, and fills the model list — both are the same request.",
diff --git a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/preferences/OpenAiPreferences.kt b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/preferences/OpenAiPreferences.kt
index fb7cbe45..9627dbbc 100644
--- a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/preferences/OpenAiPreferences.kt
+++ b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/preferences/OpenAiPreferences.kt
@@ -77,10 +77,9 @@ internal object OpenAiPreferences {
     const val KEY_REMEMBERED_MODELS_URL = "openai_remembered_models_url"
 
     /**
-     * The embedding half of the last model list a server returned, remembered under its own key so
-     * reopening the settings pane offers both pickers without another request. Encoded by
-     * `RememberedModels`, and guarded by the same [KEY_REMEMBERED_MODELS_URL]: both halves come
-     * from one listing, so one origin describes them both.
+     * The embedding half of the last model list a server returned, which keeps the saved embedding
+     * model valid for that server without another request. Encoded by `RememberedModels`; guarded
+     * by [KEY_REMEMBERED_MODELS_URL], since both halves come from one listing.
      */
     const val KEY_REMEMBERED_EMBEDDING_MODELS = "openai_remembered_embedding_models"
 
diff --git a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsFragment.kt b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsFragment.kt
index ef92fe0f..50be26a4 100644
--- a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsFragment.kt
+++ b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsFragment.kt
@@ -21,11 +21,8 @@ import android.widget.TextView
 import android.widget.Toast
 import androidx.annotation.DimenRes
 import androidx.annotation.DrawableRes
-import androidx.annotation.IdRes
-import androidx.annotation.StringRes
 import androidx.core.widget.doAfterTextChanged
 import androidx.fragment.app.Fragment
-import androidx.lifecycle.LiveData
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
@@ -152,8 +149,7 @@ class OpenAiSettingsFragment : Fragment() {
         view.applyPaneStyling(PANE_STYLE, OUTLINED_BUTTON_IDS)
         setupApiKeyUi(view)
         setupServerUi(view)
-        setupModelPicker(view, chatModelPicker())
-        setupModelPicker(view, embeddingModelPicker())
+        setupModelPicker(view)
         setupConnectionTest(view)
         onServerChanged?.invoke(viewModel.getBaseUrl())
     }
@@ -769,67 +765,7 @@ class OpenAiSettingsFragment : Fragment() {
         }
     }
 
-    // --- Model pickers -------------------------------------------------------------------------
-
-    /**
-     * Everything one editable model dropdown needs, so the chat and embedding pickers are one
-     * implementation rather than two that drift.
-     *
-     * @param tooltipTag long-press help shared by the picker's label, field and hint
-     * @param helpHint hint shown while no catalog is offered, i.e. free text only
-     * @param liveHint hint shown once there is a list to tap
-     * @param switchedMessage toast shown when this server retires the saved model
-     * @param read the currently saved model
-     * @param write persists a model the user typed or picked
-     * @param options the catalog to offer
-     * @param selected the model the field must show, republished when the saved one is retired
-     */
-    private class ModelPicker(
-        @IdRes val boxId: Int,
-        @IdRes val inputId: Int,
-        @IdRes val labelId: Int,
-        @IdRes val hintId: Int,
-        val tooltipTag: String,
-        @StringRes val helpHint: Int,
-        @StringRes val liveHint: Int,
-        @StringRes val switchedMessage: Int,
-        val read: () -> String,
-        val write: (String) -> Unit,
-        val options: LiveData<OpenAiModelOptions>,
-        val selected: LiveData<String>,
-    )
-
-    /** The chat model: what a turn is generated with. */
-    private fun chatModelPicker() = ModelPicker(
-        boxId = R.id.openai_model_box,
-        inputId = R.id.openai_model_input,
-        labelId = R.id.openai_model_label,
-        hintId = R.id.openai_model_hint_text,
-        tooltipTag = OpenAiPlugin.TOOLTIP_TAG_SETTINGS_MODEL,
-        helpHint = R.string.hint_openai_model_help,
-        liveHint = R.string.hint_openai_model_live,
-        switchedMessage = R.string.msg_model_switched,
-        read = viewModel::getModel,
-        write = viewModel::saveModel,
-        options = viewModel.models,
-        selected = viewModel.selectedModel,
-    )
-
-    /** The embedding model: what semantic search indexes and queries with. */
-    private fun embeddingModelPicker() = ModelPicker(
-        boxId = R.id.openai_embedding_model_box,
-        inputId = R.id.openai_embedding_model_input,
-        labelId = R.id.openai_embedding_model_label,
-        hintId = R.id.openai_embedding_model_hint_text,
-        tooltipTag = OpenAiPlugin.TOOLTIP_TAG_SETTINGS_EMBEDDING_MODEL,
-        helpHint = R.string.hint_openai_embedding_model_help,
-        liveHint = R.string.hint_openai_embedding_model_live,
-        switchedMessage = R.string.msg_embedding_model_switched,
-        read = viewModel::getEmbeddingModel,
-        write = viewModel::saveEmbeddingModel,
-        options = viewModel.embeddingModels,
-        selected = viewModel.selectedEmbeddingModel,
-    )
+    // --- Model picker --------------------------------------------------------------------------
 
     /**
      * One editable dropdown, not a field beside a spinner.
@@ -839,29 +775,29 @@ class OpenAiSettingsFragment : Fragment() {
      * the same control rather than a second one. The value is saved on pick, on IME Done and on
      * focus loss, so there is no Save button either.
      */
-    private fun setupModelPicker(view: View, picker: ModelPicker) {
-        val modelBox = view.findViewById<TextInputLayout>(picker.boxId)
-        val modelInput = view.findViewById<AutoCompleteTextView>(picker.inputId)
-        val modelLabel = view.findViewById<TextView>(picker.labelId)
-        val modelHint = view.findViewById<TextView>(picker.hintId)
+    private fun setupModelPicker(view: View) {
+        val modelBox = view.findViewById<TextInputLayout>(R.id.openai_model_box)
+        val modelInput = view.findViewById<AutoCompleteTextView>(R.id.openai_model_input)
+        val modelLabel = view.findViewById<TextView>(R.id.openai_model_label)
+        val modelHint = view.findViewById<TextView>(R.id.openai_model_hint_text)
 
         setupDropdownEndIcon(modelBox)
 
         listOf<View>(modelLabel, modelInput, modelHint)
-            .forEach { wireTooltip(it, picker.tooltipTag) }
+            .forEach { wireTooltip(it, OpenAiPlugin.TOOLTIP_TAG_SETTINGS_MODEL) }
 
         modelInput.isSaveEnabled = false
         // Typing searches, so the first keystroke has to replace the model id already in the field
         // rather than append to it — "gpt-4o-mini" + "claude" matches nothing, by construction.
         modelInput.setSelectAllOnFocus(true)
         // The suppressing overload throughout: a filtering write would narrow the list.
-        modelInput.setText(picker.read(), false)
+        modelInput.setText(viewModel.getModel(), false)
 
         /** Persist what is typed, ignoring a blank field rather than storing an unusable model. */
         fun commitTypedModel() {
             val typed = modelInput.text.toString().trim()
-            if (typed.isEmpty() || typed == picker.read()) return
-            picker.write(typed)
+            if (typed.isEmpty() || typed == viewModel.getModel()) return
+            viewModel.saveModel(typed)
         }
 
         modelInput.setOnEditorActionListener { _, _, _ ->
@@ -874,25 +810,25 @@ class OpenAiSettingsFragment : Fragment() {
         // Tapping the field opens the list; completionThreshold=0 alone waits for a keystroke.
         modelInput.setOnClickListener { modelInput.showDropDown() }
         modelBox.setEndIconOnClickListener { modelInput.showDropDown() }
-        wireEndIconTooltip(modelBox, picker.tooltipTag)
+        wireEndIconTooltip(modelBox, OpenAiPlugin.TOOLTIP_TAG_SETTINGS_MODEL)
         modelInput.setOnItemClickListener { _, _, _, _ -> commitTypedModel() }
 
         // A server that does not offer the saved model retires it; the field must show what will
         // actually be requested, and silently keeping the old id is what 404s on the first message.
-        picker.selected.observe(viewLifecycleOwner) { model ->
+        viewModel.selectedModel.observe(viewLifecycleOwner) { model ->
             val shown = modelInput.text.toString()
             if (shown == model || modelInput.hasFocus()) return@observe
             modelInput.setText(model, false)
             if (shown.isNotBlank()) {
                 Toast.makeText(
                     requireContext(),
-                    getString(picker.switchedMessage, model),
+                    getString(R.string.msg_model_switched, model),
                     Toast.LENGTH_LONG
                 ).show()
             }
         }
 
-        picker.options.observe(viewLifecycleOwner) { options ->
+        viewModel.models.observe(viewLifecycleOwner) { options ->
             // Cleared, not left stale: an empty list means the server changed and the old catalog
             // no longer describes it, so offering it would suggest models that will 404.
             modelInput.setAdapter(
@@ -908,8 +844,10 @@ class OpenAiSettingsFragment : Fragment() {
             )
             // Keyed on whether there is a list, not on whether it is live: a remembered list is
             // still a list to tap, and telling the user to test the connection would be wrong.
-            modelHint.text =
-                getString(if (options.models.isEmpty()) picker.helpHint else picker.liveHint)
+            modelHint.text = getString(
+                if (options.models.isEmpty()) R.string.hint_openai_model_help
+                else R.string.hint_openai_model_live
+            )
         }
     }
 
diff --git a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsViewModel.kt b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsViewModel.kt
index b7e56b92..e0fdea80 100644
--- a/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsViewModel.kt
+++ b/plugins/AI-Agent-OpenAI/src/main/kotlin/com/itsaky/androidide/plugins/aiagentopenai/settings/OpenAiSettingsViewModel.kt
@@ -54,7 +54,7 @@ class OpenAiSettingsViewModel(
             "gpt-4o-mini",
         )
 
-        /** The embedding half of [FALLBACK_MODELS], offered under the same conditions. */
+        /** OpenAI's current embedding models, kept to when a lookup on its own API fails. */
         private val FALLBACK_EMBEDDING_MODELS = listOf(
             "text-embedding-3-small",
             "text-embedding-3-large",
@@ -81,19 +81,6 @@ class OpenAiSettingsViewModel(
     private val _modelsLoading = MutableLiveData(false)
     val modelsLoading: LiveData<Boolean> get() = _modelsLoading
 
-    private val _embeddingModels =
-        MutableLiveData(OpenAiModelOptions(emptyList(), isLive = false))
-    val embeddingModels: LiveData<OpenAiModelOptions> get() = _embeddingModels
-
-    /**
-     * The embedding model the field should show, republished on the same terms as [selectedModel].
-     *
-     * Its own stream rather than a second use of [selectedModel]: the two are separate settings and
-     * a server can retire one while still offering the other.
-     */
-    private val _selectedEmbeddingModel = MutableLiveData<String>()
-    val selectedEmbeddingModel: LiveData<String> get() = _selectedEmbeddingModel
-
     // Last, after every stream it publishes to. Kotlin runs initializers in declaration order, so
     // an init block above them would call publishRememberedModels() while their backing fields are
     // still null — which threw inside the ViewModel's constructor and left the pane blank.
@@ -170,7 +157,6 @@ class OpenAiSettingsViewModel(
         if (rememberedFor != getBaseUrl()) {
             // Remembered from a different server, so it says nothing about this one.
             publishModels(OpenAiModelOptions(emptyList(), isLive = false))
-            publishEmbeddingModels(OpenAiModelOptions(emptyList(), isLive = false))
             return
         }
         val remembered =
@@ -183,7 +169,7 @@ class OpenAiSettingsViewModel(
             prefs.getString(OpenAiPreferences.KEY_REMEMBERED_EMBEDDING_MODELS, null)
         )
         if (rememberedEmbedding.isNotEmpty()) {
-            publishEmbeddingModels(OpenAiModelOptions(rememberedEmbedding, isLive = false))
+            retireStaleEmbeddingModel(rememberedEmbedding, isLive = false)
         }
     }
 
@@ -210,19 +196,18 @@ class OpenAiSettingsViewModel(
     }
 
     /**
-     * Publishes [options] to the embedding picker and retires the saved embedding model when it is
-     * not among them.
+     * Retires the saved embedding model when this server's catalog does not offer it: the rule of
+     * [publishModels], since a vector space carried over from another server ranks silently wrong.
+     * The picker is on Vector Search's settings screen; this pane only keeps the value valid.
      *
-     * The same rule as [publishModels], applied to the other setting: a vector space carried over
-     * from another server does not fail, it silently ranks against an index it never shared.
+     * @param models the server's embedding models; empty retires nothing
+     * @param isLive true when [models] was fetched just now, so an absent model is really gone
      */
-    private fun publishEmbeddingModels(options: OpenAiModelOptions) {
-        _embeddingModels.postValue(options)
-
+    private fun retireStaleEmbeddingModel(models: List<String>, isLive: Boolean) {
         val replacement = ModelSelection.adopt(
             current = getEmbeddingModel(),
-            models = options.models,
-            isLive = options.isLive,
+            models = models,
+            isLive = isLive,
             savedForThisServer = embeddingModelBelongsToSavedServer(),
             preferred = OpenAiBackend.DEFAULT_EMBEDDING_MODEL,
         ) ?: return
@@ -231,7 +216,6 @@ class OpenAiSettingsViewModel(
             "$TAG: this server does not offer the saved embedding model; switching to $replacement"
         )
         saveEmbeddingModel(replacement)
-        _selectedEmbeddingModel.postValue(replacement)
     }
 
     /**
@@ -272,7 +256,7 @@ class OpenAiSettingsViewModel(
             return
         }
         publishModels(OpenAiModelOptions(FALLBACK_MODELS, isLive = false))
-        publishEmbeddingModels(OpenAiModelOptions(FALLBACK_EMBEDDING_MODELS, isLive = false))
+        retireStaleEmbeddingModel(FALLBACK_EMBEDDING_MODELS, isLive = false)
     }
 
     /**
@@ -463,7 +447,7 @@ class OpenAiSettingsViewModel(
      * Stores [model] as the embedding model, against the server it was chosen for — see
      * [OpenAiPreferences.KEY_EMBEDDING_MODEL_URL].
      */
-    fun saveEmbeddingModel(model: String) {
+    private fun saveEmbeddingModel(model: String) {
         val trimmed = model.trim()
         if (trimmed.isEmpty()) return
         prefs()?.edit()
@@ -472,7 +456,7 @@ class OpenAiSettingsViewModel(
             ?.apply()
     }
 
-    fun getEmbeddingModel(): String =
+    private fun getEmbeddingModel(): String =
         prefs()?.getString(
             OpenAiPreferences.KEY_EMBEDDING_MODEL,
             OpenAiBackend.DEFAULT_EMBEDDING_MODEL,
@@ -506,9 +490,7 @@ class OpenAiSettingsViewModel(
                             // successful test still finds the list.
                             rememberModels(result.models, result.embeddingModels)
                             publishModels(OpenAiModelOptions(result.models, isLive = true))
-                            publishEmbeddingModels(
-                                OpenAiModelOptions(result.embeddingModels, isLive = true)
-                            )
+                            retireStaleEmbeddingModel(result.embeddingModels, isLive = true)
                         }
                     }
                     // Logged by the gateway; degrade to something the user can override.
diff --git a/plugins/AI-Agent-OpenAI/src/main/res/layout/fragment_openai_settings.xml b/plugins/AI-Agent-OpenAI/src/main/res/layout/fragment_openai_settings.xml
index a6b7c7d8..64fa3100 100644
--- a/plugins/AI-Agent-OpenAI/src/main/res/layout/fragment_openai_settings.xml
+++ b/plugins/AI-Agent-OpenAI/src/main/res/layout/fragment_openai_settings.xml
@@ -242,46 +242,6 @@
         android:text="@string/hint_openai_model_help"
         android:textAppearance="@style/Plugin.Text.Small" />
 
-    <!-- Embedding model. The other half of the same catalog: semantic search embeds with this one,
-         never with the chat model above. -->
-
-    <TextView
-        android:id="@+id/openai_embedding_model_label"
-        style="@style/Plugin.SectionHeader"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="@dimen/space_xl"
-        android:text="@string/label_openai_embedding_model" />
-
-    <com.google.android.material.textfield.TextInputLayout
-        android:id="@+id/openai_embedding_model_box"
-        style="@style/PluginTextInputLayout"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:hint="@string/hint_openai_embedding_model"
-        app:endIconContentDescription="@string/cd_show_embedding_models"
-        app:endIconMode="custom">
-
-        <AutoCompleteTextView
-            android:id="@+id/openai_embedding_model_input"
-            style="@style/PluginTextInputEditText"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:completionThreshold="0"
-            android:imeOptions="actionDone"
-            android:inputType="text"
-            android:maxLines="1"
-            android:popupBackground="@color/plugin_surface" />
-    </com.google.android.material.textfield.TextInputLayout>
-
-    <TextView
-        android:id="@+id/openai_embedding_model_hint_text"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="@dimen/space_xs"
-        android:text="@string/hint_openai_embedding_model_help"
-        android:textAppearance="@style/Plugin.Text.Small" />
-
     <!-- Connection test, which is also what fills the model dropdown: both are GET /v1/models. -->
 
     <com.google.android.material.button.MaterialButton
diff --git a/plugins/AI-Agent-OpenAI/src/main/res/values/strings.xml b/plugins/AI-Agent-OpenAI/src/main/res/values/strings.xml
index a4fa1518..b6169185 100644
--- a/plugins/AI-Agent-OpenAI/src/main/res/values/strings.xml
+++ b/plugins/AI-Agent-OpenAI/src/main/res/values/strings.xml
@@ -108,14 +108,6 @@
     <string name="msg_model_switched">This server doesn\'t offer your previous model. Switched to %1$s — pick another if you prefer.</string>
     <string name="loading">Checking…</string>
 
-    <!-- Settings pane: embedding model. Same control as the chat model, other half of the catalog. -->
-    <string name="label_openai_embedding_model">Embedding Model</string>
-    <string name="hint_openai_embedding_model">text-embedding-3-small, nomic-embed-text, …</string>
-    <string name="cd_show_embedding_models">Show the embedding model list</string>
-    <string name="hint_openai_embedding_model_help">Used by semantic search, never for chat. Test the connection below to list what this server offers.</string>
-    <string name="hint_openai_embedding_model_live">Tap to pick from the embedding models this server reported, or type another name.</string>
-    <string name="msg_embedding_model_switched">This server doesn\'t offer your previous embedding model. Switched to %1$s — anything already indexed will be built again.</string>
-
     <!-- Settings pane: connection test, which also fills the model list -->
     <string name="btn_test_connection">Test Connection &amp; List Models</string>
     <string name="msg_testing_connection">Contacting the server…</string>
diff --git a/plugins/AI-Agent-OpenAI/src/test/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/OpenAiEmbeddingModelSelectionTest.kt b/plugins/AI-Agent-OpenAI/src/test/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/OpenAiEmbeddingModelSelectionTest.kt
new file mode 100644
index 00000000..fbbae9e6
--- /dev/null
+++ b/plugins/AI-Agent-OpenAI/src/test/kotlin/com/itsaky/androidide/plugins/aiagentopenai/backend/OpenAiEmbeddingModelSelectionTest.kt
@@ -0,0 +1,65 @@
+package com.itsaky.androidide.plugins.aiagentopenai.backend
+
+import android.content.SharedPreferences
+import com.itsaky.androidide.plugins.PluginContext
+import com.itsaky.androidide.plugins.aiagentopenai.preferences.OpenAiPreferences
+import com.itsaky.androidide.plugins.aiagentopenai.settings.BaseUrlPolicy
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class OpenAiEmbeddingModelSelectionTest {
+
+    private val editor = mockk<SharedPreferences.Editor>(relaxed = true)
+    private var stampedFor: String? = BaseUrlPolicy.DEFAULT_BASE_URL
+    private val prefs = mockk<SharedPreferences>(relaxed = true) {
+        every { edit() } returns editor
+        every { getString(OpenAiPreferences.KEY_BASE_URL, any()) } returns null
+        every { getString(OpenAiPreferences.KEY_EMBEDDING_MODEL, any()) } returns "text-embedding-3-small"
+        every { getString(OpenAiPreferences.KEY_EMBEDDING_MODEL_URL, any()) } answers { stampedFor }
+    }
+    private val context = mockk<PluginContext>(relaxed = true) {
+        every { getPluginSharedPreferences(any()) } returns prefs
+    }
+    private val backend = OpenAiBackend(context, promptConfig = { null })
+
+    init {
+        every { editor.putString(any(), any()) } returns editor
+    }
+
+    @Test
+    fun givenANewModel_whenSet_thenItIsStoredWithTheServerItWasChosenFor() {
+        backend.setEmbeddingModelId("text-embedding-3-large")
+
+        verify { editor.putString(OpenAiPreferences.KEY_EMBEDDING_MODEL, "text-embedding-3-large") }
+        verify {
+            editor.putString(OpenAiPreferences.KEY_EMBEDDING_MODEL_URL, BaseUrlPolicy.DEFAULT_BASE_URL)
+        }
+    }
+
+    @Test
+    fun givenTheSameModelChosenForAnotherServer_whenSetAgain_thenTheServerIsStampedAgain() {
+        // Left stamped for the old server, the settings pane would later retire the user's pick.
+        stampedFor = "http://localhost:11434/v1"
+
+        backend.setEmbeddingModelId("text-embedding-3-small")
+
+        verify {
+            editor.putString(OpenAiPreferences.KEY_EMBEDDING_MODEL_URL, BaseUrlPolicy.DEFAULT_BASE_URL)
+        }
+    }
+
+    @Test
+    fun givenTheCurrentModelForThisServer_whenSetAgain_thenNothingIsWritten() {
+        backend.setEmbeddingModelId("text-embedding-3-small")
+
+        verify(exactly = 0) { editor.putString(any(), any()) }
+    }
+
+    @Test
+    fun givenABlankModel_whenSet_thenItIsRejected() {
+        assertThrows(IllegalArgumentException::class.java) { backend.setEmbeddingModelId("") }
+    }
+}
diff --git a/plugins/Vector-Search/README.md b/plugins/Vector-Search/README.md
index b2f0d7be..48560fa1 100644
--- a/plugins/Vector-Search/README.md
+++ b/plugins/Vector-Search/README.md
@@ -12,6 +12,12 @@ via `ProjectSearchExtension`.
 > lexical fallback, because word matches presented as semantic ones look like
 > the feature working badly rather than not running.
 
+**Preferences → Configuration → Semantic Search** shows which backend that is,
+whether it supports Vector Search (and how to fix it if not), and picks its
+embedding model through the backend's `EmbeddingModelSelectable`. It also names
+where indexing sends the code, reports the open project's index, and clears the
+index after confirmation. It needs CoGo **26.41+**.
+
 ## Architecture
 
 ```
@@ -63,13 +69,13 @@ Prerequisites: Android SDK (API 33+), JDK 17. Create `local.properties` with
 `sdk.dir=...`. No NDK or native toolchain.
 
 ```bash
-cd Vector-Search
-../gradlew assemblePlugin          # release  -> build/plugin/vector-search.cgp
-../gradlew assemblePluginDebug     # debug variant
-../gradlew testDebugUnitTest       # ranking maths and the reindex decision
+cd plugins/Vector-Search
+../../gradlew assemblePlugin          # release  -> build/plugin/vector-search.cgp
+../../gradlew assemblePluginDebug     # debug variant
+../../gradlew testDebugUnitTest       # ranking, indexing, SQL and settings-screen logic
 ```
 
-The build resolves `plugin-api.jar` from the repo-root `../libs/`.
+The build resolves `plugin-api.jar` from the repo-root `../../libs/`.
 
 ## Installation
 
@@ -83,12 +89,19 @@ The build resolves `plugin-api.jar` from the repo-root `../libs/`.
 
 ## Key classes
 
-- `VectorSearchPlugin.kt` — lifecycle, `ProjectSearchExtension`, search flow
+- `VectorSearchPlugin.kt` — lifecycle, `ProjectSearchExtension`, `SettingsExtension`, search flow
+- `IndexCoordinator.kt` — builds, reuses and clears the index, one operation at a time
+- `VectorSearchHelp.kt` — tooltip tags and entries for the in-app help
+- `BackendWatch.kt` — keeps a `BackendChangeListener` on AI Core across its restarts
+- `settings/BackendCompatibility.kt` — what the screen can say about the selected backend
+- `settings/SemanticSearchSource.kt` — what the screen reads and resets, apart from the plugin
+- `settings/SemanticSearchSettingsFragment.kt` / `…ViewModel.kt` — the Semantic Search screen
 - `EmbedderResolver.kt` — which embedder may be used, and why not when not
 - `EmbedderIdentity.kt` — the provenance stamped onto every stored vector
 - `ReindexDecision.kt` — whether the existing index can answer the query
 - `EmbeddingBatches.kt` — how many chunks go into one call
-- `EmbeddingIndexingService.kt` — file collection, schema, embedding storage (SQLite)
+- `EmbeddingIndexingService.kt` — file collection and embedding storage (SQLite)
+- `EmbeddingsSql.kt` — the schema and every SQL statement, values bound only through `?`
 - `CodeChunker.kt` — splits files into embeddable chunks
 - `VectorSearchService.kt` / `VectorMath.kt` — similarity ranking
 
diff --git a/plugins/Vector-Search/build.gradle.kts b/plugins/Vector-Search/build.gradle.kts
index 4c2744f6..324b2a9e 100644
--- a/plugins/Vector-Search/build.gradle.kts
+++ b/plugins/Vector-Search/build.gradle.kts
@@ -56,13 +56,16 @@ dependencies {
     // SQLite for embeddings storage (Android built-in, but explicit for clarity)
     implementation("androidx.sqlite:sqlite:2.4.0")
 
-    // Material Design
+    // 'implementation' (not 'compileOnly') for the androidx/Material libraries: AAPT2 needs them
+    // at compile time to process the Semantic Search screen's layouts.
     implementation("androidx.appcompat:appcompat:1.6.1")
+    implementation("androidx.fragment:fragment-ktx:1.8.8")
     implementation("com.google.android.material:material:1.10.0")
 
     testImplementation(files("../../libs/plugin-api.jar"))
     testImplementation("junit:junit:4.13.2")
     testImplementation("io.mockk:mockk:1.13.8")
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.1")
 }
 
 tasks.matching {
diff --git a/plugins/Vector-Search/src/main/AndroidManifest.xml b/plugins/Vector-Search/src/main/AndroidManifest.xml
index 5e9ed5df..49c487c5 100644
--- a/plugins/Vector-Search/src/main/AndroidManifest.xml
+++ b/plugins/Vector-Search/src/main/AndroidManifest.xml
@@ -37,9 +37,12 @@
             android:name="plugin.author"
             android:value="App Dev for All" />
 
+        <!-- 26.41: the first release whose plugin-api carries BackendChangeListener,
+             ActiveModelReportingBackend and EmbeddingModelSelectable, which the Semantic Search
+             settings screen reads (ADFA-6303). Do not lower it. -->
         <meta-data
             android:name="plugin.min_ide_version"
-            android:value="26.39" />
+            android:value="26.41" />
 
         <meta-data
             android:name="plugin.max_ide_version"
diff --git a/plugins/Vector-Search/src/main/assets/docs/index.html b/plugins/Vector-Search/src/main/assets/docs/index.html
index d99e758d..4ba6cc6a 100644
--- a/plugins/Vector-Search/src/main/assets/docs/index.html
+++ b/plugins/Vector-Search/src/main/assets/docs/index.html
@@ -47,8 +47,9 @@ <h2>How it works</h2>
     <li>Your query is embedded the same way and compared by cosine similarity;
       the closest chunks are returned.</li>
     <li>Embeddings come from the AI backend you selected in <b>AI settings</b>,
-      using that backend's own embedding-model setting. The backend must be one
-      that produces embeddings, which today means a cloud one.</li>
+      using the embedding model chosen on the <b>Semantic Search</b> screen. The
+      backend must be one that produces embeddings, which today means a cloud
+      one.</li>
   </ul>
 
   <h2>What you need</h2>
@@ -66,6 +67,45 @@ <h2>Using it</h2>
   is active, results include a <b>Semantic Results</b> section alongside the
   normal text matches. Indexing happens on demand for the searched roots.</p>
 
+  <h2>The Semantic Search screen</h2>
+  <p>Open <b>Preferences &rarr; Configuration &rarr; Semantic Search</b>. The
+  screen updates on its own when you switch backend or model in AI settings.</p>
+  <ul>
+    <li><b>AI backend</b> &mdash; the backend selected in AI settings, its chat
+      model, and whether it works with Vector Search. <b>Supported</b> means it
+      can embed your code and offer its embedding models here. <b>Not
+      supported</b> means it cannot, or its plugin is too old to: update its
+      plugin (newer Gemini and OpenAI plugins support Vector Search), or select
+      one that does in AI settings. The on-device Local backend never does. If
+      no backend is selected, or AI Core is not installed, the screen says so
+      instead.</li>
+    <li><b>Embedding model</b> &mdash; the models the backend can embed with
+      right now, for example the Gemini models that support
+      <code>embedContent</code>. Picking one stores it in the backend plugin's own
+      settings, and the next search rebuilds the index with it. If the list
+      cannot load (no API key, no network), the field still shows the model in
+      use and the reason appears beneath it. This setting used to live in the
+      Gemini and OpenAI settings panes; a model chosen there before is the one
+      selected here.</li>
+    <li><b>Privacy line</b> &mdash; names the backend your source code is sent
+      to when the project is indexed.</li>
+    <li><b>Index</b> &mdash; leads with the state of the open project's index:
+      <b>Up to date</b> (built with the selected backend and model),
+      <b>Out of date</b> (built with another model; the next search rebuilds it),
+      <b>Indexing</b> (a build is running, with a progress bar),
+      <b>Last build failed</b> (nothing was stored; fix the backend's key or
+      quota, then clear the index to try again), <b>Not indexed yet</b> (no
+      search has run since the index was built or cleared) or <b>No project
+      open</b>. Below it: the number of chunks and files indexed, the model and
+      vector size, and when the index was last built.</li>
+    <li><b>Clear index</b> &mdash; asks for confirmation, then deletes the index
+      of <b>every</b> project, not only the open one. The next search rebuilds
+      it, which sends the project's source to the selected backend again.
+      Clearing while an index is being built waits for that build to stop first,
+      so no partial index is left behind.</li>
+  </ul>
+  <p>Long-press any control on the screen for a short explanation.</p>
+
   <h2>Changing provider or model</h2>
   <p>Every stored vector records which backend, model and vector width produced
   it, and a search only ever ranks vectors from the embedder it is querying
@@ -85,14 +125,18 @@ <h2>Privacy</h2>
 
   <h2>Troubleshooting</h2>
   <ul>
-    <li><b>No semantic results at all</b> &mdash; check AI settings: AI Core must
-      be installed, a backend selected, and that backend must be one that
-      embeds. The on-device backend does not.</li>
+    <li><b>No semantic results at all</b> &mdash; open the <b>Semantic Search</b>
+      screen: it says whether AI Core is installed, which backend is selected,
+      and whether that backend supports Vector Search, with what to do if it
+      does not.</li>
     <li><b>No results on the first search</b> &mdash; the roots may still be
       indexing; run the search again once it completes.</li>
     <li><b>Results stopped appearing after a settings change</b> &mdash; changing
       the embedding model empties the index and builds it again; the first
-      search afterwards pays for that.</li>
+      search afterwards pays for that, and its results title says the index was
+      rebuilt.</li>
+    <li><b>Results look stale or wrong</b> &mdash; use <b>Clear index</b> on the
+      Semantic Search screen; the next search builds a fresh one.</li>
   </ul>
 </body>
 </html>
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/BackendWatch.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/BackendWatch.kt
new file mode 100644
index 00000000..4b0b3090
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/BackendWatch.kt
@@ -0,0 +1,99 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import com.itsaky.androidide.plugins.PluginContext
+import com.itsaky.androidide.plugins.PluginLifecycleListener
+import com.itsaky.androidide.plugins.ai.LlmBackendRegistration
+import com.itsaky.androidide.plugins.services.LlmInferenceService
+import com.itsaky.androidide.plugins.services.LlmInferenceService.BackendChangeListener
+
+/**
+ * Keeps one [BackendChangeListener] on AI Core's inference service while this plugin is active,
+ * and calls [onChanged] when the selected backend, or the selection, may have changed. Added again
+ * each time AI Core activates, since AI Core restarts on its own and takes its listeners with it.
+ *
+ * @param context this plugin's context
+ * @param resolveService AI Core's inference service, or null while it is not published
+ * @param onChanged called on whichever thread reported the change; must not block
+ */
+class BackendWatch(
+    private val context: PluginContext,
+    private val resolveService: () -> LlmInferenceService?,
+    private val onChanged: () -> Unit,
+) {
+
+    /** The service the listener is on, so [stop] removes it from that one, not a newer one. */
+    @Volatile private var watched: LlmInferenceService? = null
+
+    /** The selection at the last reported change, so a change of selection is never missed. */
+    @Volatile private var lastSelected: String? = null
+
+    /** A field, not a lambda at the call, so [stop] removes the very instance [watch] added. */
+    private val listener = BackendChangeListener { backendId ->
+        if (concernsSelection(backendId)) onChanged()
+    }
+
+    private val providerLifecycle = object : PluginLifecycleListener {
+        override fun onPluginActivated(pluginId: String) {
+            if (pluginId != LlmBackendRegistration.AI_CORE_PLUGIN_ID) return
+            watch()
+            onChanged()
+        }
+
+        override fun onPluginDeactivated(pluginId: String) = forget(pluginId)
+
+        override fun onPluginUninstalled(pluginId: String) = forget(pluginId)
+    }
+
+    /** Starts watching; AI Core need not be active yet. Pairs with the plugin's `activate`. */
+    fun start() {
+        context.addPluginLifecycleListener(providerLifecycle)
+        watch()
+    }
+
+    /** Removes the listener and stops following AI Core. Idempotent; pairs with `deactivate`. */
+    fun stop() {
+        runCatching { context.removePluginLifecycleListener(providerLifecycle) }
+        unwatch()
+    }
+
+    /**
+     * Whether a change to [backendId] matters to the screen: it is the selected backend, it was the
+     * selected one, or the selection itself moved. Other backends' status changes do not.
+     */
+    private fun concernsSelection(backendId: String): Boolean {
+        val selected = runCatching { watched?.preferredBackendId }.getOrNull()
+        val previous = lastSelected
+        lastSelected = selected
+        return backendId == selected || backendId == previous || selected != previous
+    }
+
+    @Synchronized
+    private fun watch() {
+        val service = runCatching { resolveService() }.getOrNull() ?: return
+        if (service === watched) return
+        unwatch()
+        // Set before adding, so a change reported during the add already reads this service.
+        watched = service
+        lastSelected = runCatching { service.preferredBackendId }.getOrNull()
+        try {
+            service.addBackendChangeListener(listener)
+        } catch (e: Exception) {
+            watched = null
+            context.logger.warn("BackendWatch: could not listen for backend changes", e)
+        }
+    }
+
+    @Synchronized
+    private fun unwatch() {
+        val service = watched ?: return
+        watched = null
+        runCatching { service.removeBackendChangeListener(listener) }
+    }
+
+    /** AI Core went away with its listeners; drop ours and say so, since the screen now differs. */
+    private fun forget(pluginId: String) {
+        if (pluginId != LlmBackendRegistration.AI_CORE_PLUGIN_ID) return
+        unwatch()
+        onChanged()
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingCalls.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingCalls.kt
new file mode 100644
index 00000000..f7f68100
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingCalls.kt
@@ -0,0 +1,33 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingBackend
+import java.io.IOException
+import java.util.concurrent.ExecutionException
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.runInterruptible
+
+/**
+ * Embeds [texts] and waits for the vectors, unwrapping the future's failure so the caller sees the
+ * backend's own message. Interruptible and cancels the future with it, so an abandoned index build
+ * does not leave its HTTP requests running for vectors nobody will store.
+ *
+ * @return one vector per text, in order
+ * @throws IOException when the backend failed or answered with the wrong number of vectors
+ */
+internal suspend fun EmbeddingBackend.awaitVectors(texts: List<String>): List<FloatArray> {
+    val future = embed(texts)
+    val vectors = try {
+        runInterruptible { future.get() }
+    } catch (e: CancellationException) {
+        future.cancel(true)
+        throw e
+    } catch (e: ExecutionException) {
+        throw IOException(e.cause?.message ?: "The embedder failed", e.cause ?: e)
+    }
+    if (vectors == null || vectors.size != texts.size) {
+        throw IOException(
+            "The embedder answered with ${vectors?.size ?: 0} vectors for ${texts.size} texts"
+        )
+    }
+    return vectors
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingIndexingService.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingIndexingService.kt
index 6202d1b8..1afa8596 100644
--- a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingIndexingService.kt
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingIndexingService.kt
@@ -1,6 +1,5 @@
 package com.itsaky.androidide.plugins.vectorsearch
 
-import android.content.ContentValues
 import android.database.sqlite.SQLiteDatabase
 import android.database.sqlite.SQLiteOpenHelper
 import android.content.Context
@@ -15,61 +14,32 @@ import java.nio.ByteBuffer
 private const val TAG = "EmbeddingIndexing"
 
 /**
- * Schema version.
+ * How many chunks one embedder holds within a project, as the settings screen reports it.
  *
- * Bumped to 3 by ADFA-6054, which added the provenance and roots columns. Bump it again for any
- * change to the columns below — [EmbeddingsDbHelper.onUpgrade] rebuilds from scratch, so forgetting
- * leaves every existing install querying a table that no longer matches the code reading it.
+ * @param backendId the backend that produced them
+ * @param modelId the embedding model that produced them
+ * @param dimensions the width of its vectors
+ * @param chunkCount how many rows it holds
  */
-private const val DB_VERSION = 3
-
-/** Table holding one row per indexed chunk. */
-private const val TABLE = "embeddings"
-
-/** Columns read back by [EmbeddingIndexingService.getAllEmbeddings], in cursor order. */
-private val COLUMNS = arrayOf(
-    "key", "file_path", "chunk_text", "language", "chunk_index", "start_line", "end_line",
-    "embedding", "embedder_backend", "embedder_model", "embedder_dimensions",
+data class IndexedEmbedder(
+    val backendId: String,
+    val modelId: String,
+    val dimensions: Int,
+    val chunkCount: Int,
 )
 
-/** Selects one embedder's rows within one project's index. */
-private const val IDENTITY_WHERE =
-    "embedder_backend = ? AND embedder_model = ? AND embedder_dimensions = ?"
-
-/**
- * SQLite helper for embeddings storage.
- */
 /**
+ * SQLite helper for embeddings storage; the schema itself is in [EmbeddingsSql].
+ *
  * @param logger the owning plugin's log, or null before the plugin has a context
  */
 class EmbeddingsDbHelper(context: Context, private val logger: PluginLogger?) :
-    SQLiteOpenHelper(context, "embeddings.db", null, DB_VERSION) {
+    SQLiteOpenHelper(context, EmbeddingsSql.DB_NAME, null, EmbeddingsSql.DB_VERSION) {
 
     override fun onCreate(db: SQLiteDatabase) {
-        db.execSQL("""
-            CREATE TABLE IF NOT EXISTS $TABLE (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                key TEXT UNIQUE,
-                file_path TEXT,
-                chunk_text TEXT,
-                language TEXT,
-                chunk_index INTEGER,
-                start_line INTEGER,
-                end_line INTEGER,
-                embedding BLOB,
-                embedder_backend TEXT NOT NULL,
-                embedder_model TEXT NOT NULL,
-                embedder_dimensions INTEGER NOT NULL,
-                roots_key TEXT NOT NULL
-            )
-        """.trimIndent())
-        db.execSQL("CREATE INDEX IF NOT EXISTS idx_file_path ON $TABLE(file_path)")
-        // Every query filters on the roots and the whole identity, so it is one index rather
-        // than four.
-        db.execSQL(
-            "CREATE INDEX IF NOT EXISTS idx_scope ON " +
-                "$TABLE(roots_key, embedder_backend, embedder_model, embedder_dimensions)"
-        )
+        db.execSQL(EmbeddingsSql.CREATE_TABLE)
+        db.execSQL(EmbeddingsSql.CREATE_INDEX_FILE_PATH)
+        db.execSQL(EmbeddingsSql.CREATE_INDEX_SCOPE)
     }
 
     /**
@@ -97,7 +67,7 @@ class EmbeddingsDbHelper(context: Context, private val logger: PluginLogger?) :
     }
 
     private fun recreate(db: SQLiteDatabase) {
-        db.execSQL("DROP TABLE IF EXISTS $TABLE")
+        db.execSQL(EmbeddingsSql.DROP_TABLE)
         onCreate(db)
     }
 }
@@ -174,11 +144,17 @@ class EmbeddingIndexingService(
         val db = dbHelper.readableDatabase
         val embeddings = mutableListOf<CodeEmbedding>()
 
+        val (where, args) =
+            if (rootsKey == null) {
+                EmbeddingsSql.WHERE_IDENTITY to EmbeddingsSql.identityArgs(identity)
+            } else {
+                EmbeddingsSql.WHERE_ROOTS_AND_IDENTITY to EmbeddingsSql.scopedArgs(rootsKey, identity)
+            }
         db.query(
-            TABLE,
-            COLUMNS,
-            whereFor(rootsKey),
-            argsFor(identity, rootsKey),
+            EmbeddingsSql.TABLE,
+            EmbeddingsSql.READ_COLUMNS,
+            where,
+            args,
             null, null, null
         ).use { cursor ->
             while (cursor.moveToNext()) {
@@ -200,10 +176,62 @@ class EmbeddingIndexingService(
      */
     fun countEmbeddings(rootsKey: String, identity: EmbedderIdentity): Int =
         dbHelper.readableDatabase.rawQuery(
-            "SELECT COUNT(*) FROM $TABLE WHERE ${whereFor(rootsKey)}",
-            argsFor(identity, rootsKey),
+            EmbeddingsSql.COUNT_SCOPED,
+            EmbeddingsSql.scopedArgs(rootsKey, identity),
+        ).use { cursor -> if (cursor.moveToFirst()) cursor.getInt(0) else 0 }
+
+    /**
+     * What the index holds for files under [projectRoot], one entry per embedder, largest first.
+     * Counted by path rather than by roots, since a search scoped to one module still indexes the
+     * open project.
+     *
+     * @return the embedders with rows here, empty when nothing under [projectRoot] is indexed
+     */
+    fun summarize(projectRoot: File): List<IndexedEmbedder> {
+        return dbHelper.readableDatabase.rawQuery(
+            EmbeddingsSql.SUMMARIZE_PATH_RANGE,
+            EmbeddingsSql.pathRangeArgs(projectRoot),
+        ).use { cursor ->
+            buildList {
+                while (cursor.moveToNext()) {
+                    add(
+                        IndexedEmbedder(
+                            backendId = cursor.getString(0),
+                            modelId = cursor.getString(1),
+                            dimensions = cursor.getInt(2),
+                            chunkCount = cursor.getInt(3),
+                        )
+                    )
+                }
+            }
+        }
+    }
+
+    /** How many distinct files under [projectRoot] have rows, whichever embedder wrote them. */
+    fun countFiles(projectRoot: File): Int =
+        dbHelper.readableDatabase.rawQuery(
+            EmbeddingsSql.COUNT_FILES_PATH_RANGE,
+            EmbeddingsSql.pathRangeArgs(projectRoot),
         ).use { cursor -> if (cursor.moveToFirst()) cursor.getInt(0) else 0 }
 
+    /** Whether any project has rows, so a clear would delete something. */
+    fun hasAnyRows(): Boolean =
+        dbHelper.readableDatabase.rawQuery(EmbeddingsSql.HAS_ANY_ROW, null)
+            .use { cursor -> cursor.moveToFirst() && cursor.getInt(0) == 1 }
+
+    /**
+     * The embedding models whose rows [rootsKey] holds, so a rebuild can say which one it replaces.
+     *
+     * @return the distinct model ids, empty when [rootsKey] was never indexed
+     */
+    fun storedModels(rootsKey: String): List<String> =
+        dbHelper.readableDatabase.rawQuery(
+            EmbeddingsSql.STORED_MODELS,
+            arrayOf(rootsKey),
+        ).use { cursor ->
+            buildList { while (cursor.moveToNext()) add(cursor.getString(0)) }
+        }
+
     /**
      * Releases the SQLite connection. Call from the plugin's dispose() so the open
      * database handle doesn't outlive the plugin when it is unloaded/reloaded.
@@ -225,23 +253,12 @@ class EmbeddingIndexingService(
     fun clearIndex(rootsKey: String? = null) {
         val db = dbHelper.writableDatabase
         val deleted =
-            if (rootsKey == null) db.delete(TABLE, null, null)
-            else db.delete(TABLE, "roots_key = ?", arrayOf(rootsKey))
+            if (rootsKey == null) db.delete(EmbeddingsSql.TABLE, null, null)
+            else db.delete(EmbeddingsSql.TABLE, EmbeddingsSql.WHERE_ROOTS, arrayOf(rootsKey))
         logger?.info("$TAG: cleared $deleted rows from the index")
     }
 
-    /** The identity filter, narrowed to one project when [rootsKey] names one. */
-    private fun whereFor(rootsKey: String?): String =
-        if (rootsKey == null) IDENTITY_WHERE else "roots_key = ? AND $IDENTITY_WHERE"
-
-    /** The arguments [whereFor] expects, in its order. */
-    private fun argsFor(identity: EmbedderIdentity, rootsKey: String?): Array<String> {
-        val identityArgs =
-            arrayOf(identity.backendId, identity.modelId, identity.dimensions.toString())
-        return if (rootsKey == null) identityArgs else arrayOf(rootsKey) + identityArgs
-    }
-
-    /** Reads one row in [COLUMNS] order. */
+    /** Reads one row in [EmbeddingsSql.READ_COLUMNS] order. */
     private fun readEmbedding(cursor: android.database.Cursor): CodeEmbedding {
         val buffer = cursor.getBlob(7)
         val embedding = FloatArray(buffer.size / Float.SIZE_BYTES)
@@ -267,27 +284,12 @@ class EmbeddingIndexingService(
     }
 
     private fun storeEmbedding(db: SQLiteDatabase, rootsKey: String, embedding: CodeEmbedding) {
-        val buffer = ByteBuffer.allocate(embedding.embedding.size * Float.SIZE_BYTES)
-        for (f in embedding.embedding) {
-            buffer.putFloat(f)
-        }
-
-        val values = ContentValues().apply {
-            put("key", embedding.key)
-            put("file_path", embedding.filePath)
-            put("chunk_text", embedding.chunkText)
-            put("language", embedding.language)
-            put("chunk_index", embedding.chunkIndex)
-            put("start_line", embedding.startLine)
-            put("end_line", embedding.endLine)
-            put("embedding", buffer.array())
-            put("embedder_backend", embedding.identity.backendId)
-            put("embedder_model", embedding.identity.modelId)
-            put("embedder_dimensions", embedding.identity.dimensions)
-            put("roots_key", rootsKey)
-        }
-
-        db.insertWithOnConflict(TABLE, null, values, SQLiteDatabase.CONFLICT_REPLACE)
+        db.insertWithOnConflict(
+            EmbeddingsSql.TABLE,
+            null,
+            EmbeddingsSql.rowValues(rootsKey, embedding),
+            SQLiteDatabase.CONFLICT_REPLACE,
+        )
     }
 
     private fun collectCodeFiles(root: File, maxCount: Int): List<File> {
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingsSql.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingsSql.kt
new file mode 100644
index 00000000..b82f2ea5
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingsSql.kt
@@ -0,0 +1,167 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import android.content.ContentValues
+import java.io.File
+import java.nio.ByteBuffer
+
+/**
+ * Every SQL statement the index runs, and the schema they run against, in one place.
+ *
+ * Each statement is a compile-time constant: values are only ever bound through `?` placeholders,
+ * never spliced into the text, so nothing a project path or model id contains can change a query.
+ */
+internal object EmbeddingsSql {
+
+    /** The database file, in the plugin's own data directory. */
+    const val DB_NAME = "embeddings.db"
+
+    /**
+     * Schema version: 3 since ADFA-6054 added the provenance and roots columns. Bump it for any
+     * column change: [EmbeddingsDbHelper.onUpgrade] rebuilds from scratch, so forgetting leaves
+     * every existing install querying a table that no longer matches this file.
+     */
+    const val DB_VERSION = 3
+
+    /** Table holding one row per indexed chunk. */
+    const val TABLE = "embeddings"
+
+    /** Column names, shared by the statements below and by [rowValues]. */
+    private object Columns {
+        const val KEY = "key"
+        const val FILE_PATH = "file_path"
+        const val CHUNK_TEXT = "chunk_text"
+        const val LANGUAGE = "language"
+        const val CHUNK_INDEX = "chunk_index"
+        const val START_LINE = "start_line"
+        const val END_LINE = "end_line"
+        const val EMBEDDING = "embedding"
+        const val EMBEDDER_BACKEND = "embedder_backend"
+        const val EMBEDDER_MODEL = "embedder_model"
+        const val EMBEDDER_DIMENSIONS = "embedder_dimensions"
+        const val ROOTS_KEY = "roots_key"
+    }
+
+    // --- Schema --------------------------------------------------------------------------------
+
+    const val CREATE_TABLE = """
+        CREATE TABLE IF NOT EXISTS $TABLE (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            ${Columns.KEY} TEXT UNIQUE,
+            ${Columns.FILE_PATH} TEXT,
+            ${Columns.CHUNK_TEXT} TEXT,
+            ${Columns.LANGUAGE} TEXT,
+            ${Columns.CHUNK_INDEX} INTEGER,
+            ${Columns.START_LINE} INTEGER,
+            ${Columns.END_LINE} INTEGER,
+            ${Columns.EMBEDDING} BLOB,
+            ${Columns.EMBEDDER_BACKEND} TEXT NOT NULL,
+            ${Columns.EMBEDDER_MODEL} TEXT NOT NULL,
+            ${Columns.EMBEDDER_DIMENSIONS} INTEGER NOT NULL,
+            ${Columns.ROOTS_KEY} TEXT NOT NULL
+        )
+    """
+
+    /** Serves the per-file deletes and the settings screen's path-range summary. */
+    const val CREATE_INDEX_FILE_PATH =
+        "CREATE INDEX IF NOT EXISTS idx_file_path ON $TABLE(${Columns.FILE_PATH})"
+
+    /** Every ranking query filters on the roots and the whole identity, so it is one index. */
+    const val CREATE_INDEX_SCOPE =
+        "CREATE INDEX IF NOT EXISTS idx_scope ON $TABLE(" +
+            "${Columns.ROOTS_KEY}, ${Columns.EMBEDDER_BACKEND}, " +
+            "${Columns.EMBEDDER_MODEL}, ${Columns.EMBEDDER_DIMENSIONS})"
+
+    const val DROP_TABLE = "DROP TABLE IF EXISTS $TABLE"
+
+    // --- Reads ---------------------------------------------------------------------------------
+
+    /** Columns read back by [EmbeddingIndexingService.getAllEmbeddings]. */
+    val READ_COLUMNS = arrayOf(
+        Columns.KEY, Columns.FILE_PATH, Columns.CHUNK_TEXT, Columns.LANGUAGE, Columns.CHUNK_INDEX,
+        Columns.START_LINE, Columns.END_LINE, Columns.EMBEDDING, Columns.EMBEDDER_BACKEND,
+        Columns.EMBEDDER_MODEL, Columns.EMBEDDER_DIMENSIONS,
+    )
+
+    /** One embedder's rows. Bind [identityArgs]. */
+    const val WHERE_IDENTITY =
+        "${Columns.EMBEDDER_BACKEND} = ? AND ${Columns.EMBEDDER_MODEL} = ? AND " +
+            "${Columns.EMBEDDER_DIMENSIONS} = ?"
+
+    /** One embedder's rows within one project's roots. Bind [scopedArgs]. */
+    const val WHERE_ROOTS_AND_IDENTITY = "${Columns.ROOTS_KEY} = ? AND $WHERE_IDENTITY"
+
+    /** How many rows one embedder holds for one project. Bind [scopedArgs]. */
+    const val COUNT_SCOPED = "SELECT COUNT(*) FROM $TABLE WHERE $WHERE_ROOTS_AND_IDENTITY"
+
+    /**
+     * Chunk counts per embedder for the paths in a half-open range, largest first. Bind
+     * [pathRangeArgs]; a range rather than `LIKE`, so it uses the index and takes no wildcard.
+     */
+    const val SUMMARIZE_PATH_RANGE =
+        "SELECT ${Columns.EMBEDDER_BACKEND}, ${Columns.EMBEDDER_MODEL}, " +
+            "${Columns.EMBEDDER_DIMENSIONS}, COUNT(*) FROM $TABLE " +
+            "WHERE ${Columns.FILE_PATH} >= ? AND ${Columns.FILE_PATH} < ? " +
+            "GROUP BY ${Columns.EMBEDDER_BACKEND}, ${Columns.EMBEDDER_MODEL}, " +
+            "${Columns.EMBEDDER_DIMENSIONS} ORDER BY COUNT(*) DESC"
+
+    /** How many distinct files have rows in a half-open path range. Bind [pathRangeArgs]. */
+    const val COUNT_FILES_PATH_RANGE =
+        "SELECT COUNT(DISTINCT ${Columns.FILE_PATH}) FROM $TABLE " +
+            "WHERE ${Columns.FILE_PATH} >= ? AND ${Columns.FILE_PATH} < ?"
+
+    /** Whether the index holds any row at all, for any project. Binds nothing. */
+    const val HAS_ANY_ROW = "SELECT EXISTS(SELECT 1 FROM $TABLE)"
+
+    /** The embedding models one project's rows came from. Bind the roots key. */
+    const val STORED_MODELS =
+        "SELECT DISTINCT ${Columns.EMBEDDER_MODEL} FROM $TABLE WHERE ${Columns.ROOTS_KEY} = ?"
+
+    // --- Writes --------------------------------------------------------------------------------
+
+    /** One project's rows, for a scoped delete. Bind the roots key. */
+    const val WHERE_ROOTS = "${Columns.ROOTS_KEY} = ?"
+
+    /** The row [embedding] is stored as under [rootsKey], with its vector as big-endian floats. */
+    fun rowValues(rootsKey: String, embedding: CodeEmbedding): ContentValues {
+        val buffer = ByteBuffer.allocate(embedding.embedding.size * Float.SIZE_BYTES)
+        for (f in embedding.embedding) {
+            buffer.putFloat(f)
+        }
+        return ContentValues().apply {
+            put(Columns.KEY, embedding.key)
+            put(Columns.FILE_PATH, embedding.filePath)
+            put(Columns.CHUNK_TEXT, embedding.chunkText)
+            put(Columns.LANGUAGE, embedding.language)
+            put(Columns.CHUNK_INDEX, embedding.chunkIndex)
+            put(Columns.START_LINE, embedding.startLine)
+            put(Columns.END_LINE, embedding.endLine)
+            put(Columns.EMBEDDING, buffer.array())
+            put(Columns.EMBEDDER_BACKEND, embedding.identity.backendId)
+            put(Columns.EMBEDDER_MODEL, embedding.identity.modelId)
+            put(Columns.EMBEDDER_DIMENSIONS, embedding.identity.dimensions)
+            put(Columns.ROOTS_KEY, rootsKey)
+        }
+    }
+
+    // --- Arguments -----------------------------------------------------------------------------
+
+    /** The values [WHERE_IDENTITY] binds, in its order. */
+    fun identityArgs(identity: EmbedderIdentity): Array<String> =
+        arrayOf(identity.backendId, identity.modelId, identity.dimensions.toString())
+
+    /** The values [WHERE_ROOTS_AND_IDENTITY] and [COUNT_SCOPED] bind, in their order. */
+    fun scopedArgs(rootsKey: String, identity: EmbedderIdentity): Array<String> =
+        arrayOf(rootsKey) + identityArgs(identity)
+
+    /**
+     * The half-open range [SUMMARIZE_PATH_RANGE] binds: every path that starts with `root/` sorts
+     * inside it, and `root` itself, `root2` or `root-x` sort outside.
+     *
+     * @return the inclusive lower bound and exclusive upper bound, compared as SQLite BINARY text
+     */
+    fun pathRangeArgs(root: File): Array<String> {
+        val dir = root.absolutePath.trimEnd(File.separatorChar)
+        // The separator's successor is the first character no "dir/..." path can have after dir.
+        return arrayOf("$dir${File.separatorChar}", "$dir${File.separatorChar + 1}")
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexBuildLog.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexBuildLog.kt
new file mode 100644
index 00000000..921dbc03
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexBuildLog.kt
@@ -0,0 +1,52 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import android.content.SharedPreferences
+import java.io.File
+
+/**
+ * When each index build last completed. Kept beside the database rather than in it, so recording
+ * it needs no schema version bump, which would discard every user's paid-for index.
+ */
+interface IndexBuildLog {
+
+    /** Records that the build for [rootsKey] completed at [atMillis]. */
+    fun recordBuilt(rootsKey: String, atMillis: Long)
+
+    /** The latest completion among builds of roots within [projectRoot], or null when none. */
+    fun lastBuiltUnder(projectRoot: File): Long?
+
+    /** Forgets every build, as clearing the whole index does. */
+    fun clear()
+}
+
+/**
+ * [IndexBuildLog] in this plugin's own preferences file, one entry per roots key.
+ *
+ * @param preferences the file, or null when the plugin has no context to open it with
+ */
+class PreferencesIndexBuildLog(
+    private val preferences: () -> SharedPreferences?,
+) : IndexBuildLog {
+
+    override fun recordBuilt(rootsKey: String, atMillis: Long) {
+        preferences()?.edit()?.putLong(KEY_PREFIX + rootsKey, atMillis)?.apply()
+    }
+
+    override fun lastBuiltUnder(projectRoot: File): Long? =
+        preferences()?.all.orEmpty().entries
+            .filter { (key, _) -> key.startsWith(KEY_PREFIX) }
+            .filter { (key, _) -> RootsKey.isUnder(key.removePrefix(KEY_PREFIX), projectRoot) }
+            .mapNotNull { (_, value) -> value as? Long }
+            .maxOrNull()
+
+    override fun clear() {
+        preferences()?.edit()?.clear()?.apply()
+    }
+
+    companion object {
+        /** The preferences file, which holds nothing else. */
+        const val FILE = "vector_search_index_builds"
+
+        private const val KEY_PREFIX = "built_at:"
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexCoordinator.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexCoordinator.kt
new file mode 100644
index 00000000..b3b8e61b
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexCoordinator.kt
@@ -0,0 +1,337 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import com.itsaky.androidide.plugins.PluginLogger
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingBackend
+import java.io.File
+import java.io.IOException
+import kotlin.coroutines.coroutineContext
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/** Names this class in every line it logs; the host's `[pluginId]` prefix names only the plugin. */
+private const val TAG = "IndexCoordinator"
+
+/** What the coordinator is doing, for the settings screen. */
+sealed interface BuildActivity {
+
+    /** No build is running, and the last one did not fail. */
+    data object Idle : BuildActivity
+
+    /**
+     * A build is running.
+     *
+     * @param rootsKey the roots it indexes
+     * @param stored chunks embedded and stored so far
+     * @param total chunks to embed; zero while the files are still being collected
+     */
+    data class Building(val rootsKey: String, val stored: Int, val total: Int) : BuildActivity
+
+    /**
+     * The last build stopped on an error and stored nothing; a search will not retry it until the
+     * index is cleared, so a backend refusing every call is not billed on every query.
+     *
+     * @param rootsKey the roots it was indexing
+     */
+    data class Failed(val rootsKey: String) : BuildActivity
+}
+
+/**
+ * An index build a search may wait for.
+ *
+ * @param job the build
+ * @param replacedModel the embedding model whose rows it replaces, or null for a first build
+ */
+data class IndexBuild(val job: Job, val replacedModel: String?)
+
+/**
+ * Builds, reuses and clears the index, one operation at a time, so no two ever interleave writes.
+ * Owns all build state; the plugin only asks for a build or a clear.
+ *
+ * @param store the index database
+ * @param buildLog where each completed build's time is kept
+ * @param logger this plugin's log, or null before it has a context
+ * @param onIndexChanged called on a background thread after each stored batch, build end and clear
+ * @param clock the current time in milliseconds, injectable for tests
+ */
+class IndexCoordinator(
+    private val store: EmbeddingIndexingService,
+    private val buildLog: IndexBuildLog,
+    private val logger: () -> PluginLogger?,
+    private val onIndexChanged: () -> Unit,
+    private val clock: () -> Long = System::currentTimeMillis,
+) {
+
+    // Background scope for indexing so a large project never stalls a search request.
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    // The build or clear in flight, which the next one cancels and waits for before writing.
+    @Volatile private var current: Job? = null
+
+    // What the last completed build produced; null until one has completed in this session.
+    @Volatile private var indexedState: IndexState? = null
+
+    // What [current] is building; null while it is a clear, or nothing runs.
+    @Volatile private var target: IndexTarget? = null
+
+    // The last clear: a build waits for it but never cancels it, or an unstarted one is skipped.
+    @Volatile private var clearing: Job? = null
+
+    /** What runs now, or how the last build ended; read by the settings screen. */
+    @Volatile
+    var activity: BuildActivity = BuildActivity.Idle
+        private set
+
+    /**
+     * Starts (or reuses) a background build for [roots], or returns null when the index already
+     * answers for these roots and this embedder.
+     *
+     * @param rootsKey the roots being indexed, as one value
+     * @param roots project root directories to index
+     * @param backend the embedder to build with
+     * @param identity what that embedder produces, as the query has just demonstrated
+     * @return the running build, or null if the existing index is reusable
+     */
+    @Synchronized
+    fun buildIfNeeded(
+        rootsKey: String,
+        roots: List<File>,
+        backend: EmbeddingBackend,
+        identity: EmbedderIdentity,
+    ): IndexBuild? {
+        val wanted = IndexTarget(rootsKey, identity)
+        val running = current
+        if (running != null && running.isActive && target == wanted) {
+            return IndexBuild(running, replacedModel = null)
+        }
+        if (running?.isActive != true) {
+            // The marker is per-session but the rows persist: ask the database before re-embedding.
+            if (!ReindexDecision.isReusable(indexedState, rootsKey, identity)) {
+                val stored = store.countEmbeddings(rootsKey, identity)
+                if (stored > 0) indexedState = IndexState(rootsKey, identity, stored)
+            }
+            if (ReindexDecision.isReusable(indexedState, rootsKey, identity)) return null
+        }
+
+        val replaced = store.storedModels(rootsKey).firstOrNull { it != identity.modelId }
+        if (replaced != null) {
+            logger()?.info("$TAG: embedding model changed from $replaced; rebuilding as $identity")
+        }
+
+        // Cancel a build and wait for it to unwind, so builds never interleave writes.
+        if (running !== clearing) running?.cancel()
+        target = wanted
+        val pendingClear = clearing
+        val job = scope.launch {
+            try {
+                // The clear first: a superseded build may have left without waiting for it.
+                pendingClear?.join()
+                running?.join()
+                build(rootsKey, roots, backend, identity)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                logger()?.error("$TAG: background indexing failed", e)
+            }
+            onIndexChanged()
+        }
+        current = job
+        return IndexBuild(job, replaced)
+    }
+
+    /**
+     * Clears every project's index once whatever runs now has unwound, so no row it writes later
+     * survives as a partial index. Never skipped: a search that supersedes it waits for it.
+     *
+     * @return the clear, complete once the index is empty or the delete has failed and been logged
+     */
+    @Synchronized
+    fun clearAll(): Job {
+        val running = current
+        running?.cancel()
+        target = null
+        indexedState = null
+        val job = scope.launch {
+            withContext(NonCancellable) {
+                running?.join()
+                try {
+                    store.clearIndex()
+                    buildLog.clear()
+                    logger()?.info("$TAG: index cleared")
+                } catch (e: Exception) {
+                    // Caught here: nothing above this launch handles it, so it would crash the IDE.
+                    logger()?.error("$TAG: could not clear the index", e)
+                }
+                // Again after the join: the build it waited for may have recorded itself last.
+                indexedState = null
+                // Also forgets a failed build, which is how the user asks for a retry.
+                activity = BuildActivity.Idle
+                onIndexChanged()
+            }
+        }
+        current = job
+        clearing = job
+        return job
+    }
+
+    /** When a build of roots within [projectRoot] last completed, or null when none is recorded. */
+    fun lastBuiltUnder(projectRoot: File): Long? = buildLog.lastBuiltUnder(projectRoot)
+
+    /** Stops every build; the coordinator is unusable afterwards. */
+    fun close() {
+        scope.cancel()
+    }
+
+    /**
+     * Builds the whole index for [roots], batch by batch.
+     *
+     * A failed batch aborts the build and leaves the index empty rather than substituting anything.
+     * A substitute would be stored under the real embedder's identity and ranked beside it.
+     */
+    private suspend fun build(
+        rootsKey: String,
+        roots: List<File>,
+        backend: EmbeddingBackend,
+        identity: EmbedderIdentity,
+    ) {
+        // Reset the marker up front so a mid-build failure doesn't leave a stale "indexed" flag.
+        indexedState = null
+        reportProgress(BuildActivity.Building(rootsKey, stored = 0, total = 0))
+        store.clearIndex(rootsKey)
+
+        var stored = 0
+        var total = 0
+        try {
+            val pending = collectChunks(roots)
+            total = pending.size
+            reportProgress(BuildActivity.Building(rootsKey, stored, total))
+            for (batch in EmbeddingBatches.split(pending) { it.chunkText.length }) {
+                coroutineContext.ensureActive()
+                val vectors = backend.awaitVectors(batch.map { it.chunkText })
+                store.storeEmbeddings(rootsKey, toEmbeddings(batch, vectors, identity))
+                stored += batch.size
+                reportProgress(BuildActivity.Building(rootsKey, stored, total))
+            }
+        } catch (e: CancellationException) {
+            // Superseded or cleared: whatever replaces this build sets the activity next.
+            activity = BuildActivity.Idle
+            throw e
+        } catch (e: Exception) {
+            // Emptied, not left partial: a half-built index reads as bad ranking, not a failure.
+            store.clearIndex(rootsKey)
+            // Recorded as an attempt, so a backend refusing every call is not re-billed per search.
+            indexedState = IndexState(rootsKey, identity, chunkCount = 0)
+            activity = BuildActivity.Failed(rootsKey)
+            logger()?.error("$TAG: indexing aborted after $stored of $total chunks", e)
+            return
+        }
+
+        indexedState = IndexState(rootsKey, identity, stored)
+        activity = BuildActivity.Idle
+        buildLog.recordBuilt(rootsKey, clock())
+        logger()?.info("$TAG: indexed $stored chunks with $identity")
+    }
+
+    /** Publishes [progress] and tells the screen, which reads it without touching the database. */
+    private fun reportProgress(progress: BuildActivity.Building) {
+        activity = progress
+        onIndexChanged()
+    }
+
+    /**
+     * What one build is for, as the one value two builds are compared on.
+     *
+     * @param rootsKey the roots being indexed
+     * @param identity the embedder the vectors will come from
+     */
+    private data class IndexTarget(val rootsKey: String, val identity: EmbedderIdentity)
+
+    /**
+     * One chunk waiting to be embedded. Collected before any embedding, so the loop that calls the
+     * network is about batches rather than about walking a file tree.
+     */
+    private data class PendingChunk(
+        val key: String,
+        val filePath: String,
+        val chunkText: String,
+        val language: String,
+        val chunkIndex: Int,
+        val startLine: Int,
+        val endLine: Int,
+    )
+
+    /** Walks [roots] and chunks every code file it finds. */
+    private suspend fun collectChunks(roots: List<File>): List<PendingChunk> {
+        val pending = mutableListOf<PendingChunk>()
+        var fileCount = 0
+
+        roots.forEach { root ->
+            store.collectFiles(root).forEach { file ->
+                // Bail promptly if this build was superseded by one for different roots.
+                coroutineContext.ensureActive()
+                fileCount++
+                val language = store.languageFor(file)
+                val chunks = try {
+                    CodeChunker.chunkFile(file)
+                } catch (e: Exception) {
+                    logger()?.warn("$TAG: failed to chunk ${file.absolutePath}", e)
+                    emptyList()
+                }
+
+                chunks.forEachIndexed { index, chunk ->
+                    pending.add(
+                        PendingChunk(
+                            key = "${file.absolutePath}:$index",
+                            filePath = file.absolutePath,
+                            chunkText = chunk.content,
+                            language = language,
+                            chunkIndex = index,
+                            startLine = chunk.startLine + 1,
+                            endLine = chunk.endLine + 1,
+                        )
+                    )
+                }
+            }
+        }
+
+        logger()?.info("$TAG: collected ${pending.size} chunks from $fileCount files")
+        return pending
+    }
+
+    /**
+     * Pairs a batch with the vectors it produced.
+     *
+     * @throws IOException when the backend answered with a different width than the index is being
+     *   built in — storing those rows would put two spaces under one identity
+     */
+    private fun toEmbeddings(
+        batch: List<PendingChunk>,
+        vectors: List<FloatArray>,
+        identity: EmbedderIdentity,
+    ): List<CodeEmbedding> = batch.mapIndexed { position, chunk ->
+        val vector = vectors[position]
+        if (vector.size != identity.dimensions) {
+            throw IOException(
+                "The embedder answered with ${vector.size} dimensions, not ${identity.dimensions}"
+            )
+        }
+        CodeEmbedding(
+            key = chunk.key,
+            filePath = chunk.filePath,
+            chunkText = chunk.chunkText,
+            language = chunk.language,
+            chunkIndex = chunk.chunkIndex,
+            startLine = chunk.startLine,
+            endLine = chunk.endLine,
+            embedding = vector,
+            identity = identity,
+        )
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/RootsKey.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/RootsKey.kt
new file mode 100644
index 00000000..3d0230ca
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/RootsKey.kt
@@ -0,0 +1,26 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import java.io.File
+
+/**
+ * The search roots of one index build, as the single value the index stores and compares them by:
+ * their absolute paths, sorted, joined by [SEPARATOR].
+ */
+object RootsKey {
+
+    private const val SEPARATOR = "|"
+
+    /** The key for [roots]; the same set in any order gives the same key. */
+    fun of(roots: List<File>): String =
+        roots.map { it.absolutePath }.sorted().joinToString(SEPARATOR)
+
+    /**
+     * Whether every root in [rootsKey] lies within [projectRoot], so that build belongs to the open
+     * project. A sibling sharing a prefix (`app2` beside `app`) does not.
+     */
+    fun isUnder(rootsKey: String, projectRoot: File): Boolean {
+        val dir = projectRoot.absolutePath.trimEnd(File.separatorChar)
+        val prefix = dir + File.separatorChar
+        return rootsKey.split(SEPARATOR).all { it == dir || it.startsWith(prefix) }
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/SemanticSearchSourceImpl.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/SemanticSearchSourceImpl.kt
new file mode 100644
index 00000000..f163f0ed
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/SemanticSearchSourceImpl.kt
@@ -0,0 +1,72 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import com.itsaky.androidide.plugins.PluginContext
+import com.itsaky.androidide.plugins.PluginLogger
+import com.itsaky.androidide.plugins.services.IdeProjectService
+import com.itsaky.androidide.plugins.services.LlmInferenceService
+import com.itsaky.androidide.plugins.vectorsearch.settings.IndexStatus
+import com.itsaky.androidide.plugins.vectorsearch.settings.SemanticSearchSource
+import java.io.File
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.StateFlow
+
+/** Names this class in every line it logs; the host's `[pluginId]` prefix names only the plugin. */
+private const val TAG = "SemanticSearchSource"
+
+/**
+ * What the settings screen reads and resets, over one activation's index. The plugin builds a new
+ * one with each [IndexCoordinator], so it never outlives the database and coordinator it reads.
+ *
+ * @param context the plugin's context, for the open project and the log
+ * @param store the index database
+ * @param indexing the coordinator that builds and clears [store]
+ * @param inference resolves AI Core's inference service, or null when it is absent
+ * @param backendChanges ticks when the selected backend may have changed
+ * @param indexChanges ticks when [indexing] stored a batch, ended a build or cleared the index
+ */
+internal class SemanticSearchSourceImpl(
+    private val context: PluginContext,
+    private val store: EmbeddingIndexingService,
+    private val indexing: IndexCoordinator,
+    private val inference: () -> LlmInferenceService?,
+    override val backendChanges: StateFlow<Long>,
+    override val indexChanges: StateFlow<Long>,
+) : SemanticSearchSource {
+
+    override fun inferenceService(): LlmInferenceService? = inference()
+
+    override fun clearIndex(): Job = indexing.clearAll()
+
+    override fun indexStatus(): IndexStatus {
+        val root = currentProjectRoot() ?: return IndexStatus.NoProject
+        // From memory, not the database: progress arrives once per stored batch.
+        when (val activity = indexing.activity) {
+            is BuildActivity.Building ->
+                if (RootsKey.isUnder(activity.rootsKey, root)) {
+                    return IndexStatus.Building(activity.stored, activity.total)
+                }
+            is BuildActivity.Failed ->
+                if (RootsKey.isUnder(activity.rootsKey, root)) return IndexStatus.BuildFailed
+            BuildActivity.Idle -> Unit
+        }
+        val embedders = store.summarize(root)
+        if (embedders.isEmpty()) return IndexStatus.NotIndexed
+        return IndexStatus.Indexed(
+            embedders = embedders,
+            fileCount = store.countFiles(root),
+            lastBuiltAt = indexing.lastBuiltUnder(root),
+        )
+    }
+
+    override fun indexHoldsAnything(): Boolean = store.hasAnyRows()
+
+    override fun logger(): PluginLogger? = context.logger
+
+    /** The open project's root, or null when none is open or the project service refused. */
+    private fun currentProjectRoot(): File? = try {
+        context.services.get(IdeProjectService::class.java)?.getCurrentProject()?.rootDir
+    } catch (e: Exception) {
+        context.logger.warn("$TAG: could not read the open project", e)
+        null
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/VectorSearchHelp.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/VectorSearchHelp.kt
new file mode 100644
index 00000000..7d71ca5e
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/VectorSearchHelp.kt
@@ -0,0 +1,127 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import com.itsaky.androidide.plugins.extensions.PluginTooltipButton
+import com.itsaky.androidide.plugins.extensions.PluginTooltipEntry
+
+/**
+ * This plugin's in-app help: the tags its controls carry and the entries the host registers under
+ * them. Kept apart from the plugin so the search code is not interleaved with help copy.
+ */
+object VectorSearchHelp {
+
+    const val TAG_PLUGIN = "plugin_vector_search"
+
+    // Tags for the controls on the Semantic Search screen (see SemanticSearchSettingsFragment).
+    const val TAG_BACK = "vector_search_back"
+    const val TAG_BACKEND = "vector_search_backend"
+    const val TAG_EMBEDDING_MODEL = "vector_search_embedding_model"
+    const val TAG_PRIVACY = "vector_search_privacy"
+    const val TAG_INDEX_STATUS = "vector_search_index_status"
+    const val TAG_CLEAR_INDEX = "vector_search_clear_index"
+
+    /** Every tooltip this plugin registers, under [VectorSearchPlugin.TOOLTIP_CATEGORY]. */
+    fun entries(): List<PluginTooltipEntry> = listOf(
+        PluginTooltipEntry(
+            tag = TAG_PLUGIN,
+            summary = "Vector Search adds semantic, meaning-based matches to project search.",
+            detail = """
+                <p><b>Vector Search</b> chunks project files, embeds them with
+                the AI backend you selected in AI settings, and ranks matches by
+                semantic similarity instead of only exact text.</p>
+                <p>It needs a backend that produces embeddings, which today means
+                a cloud one. With no such backend selected it simply contributes
+                no results, rather than quietly matching on words and presenting
+                that as semantic search.</p>
+                <p>Changing the backend or its embedding model builds the index
+                again: vectors from two different models cannot be compared.</p>
+            """.trimIndent(),
+            buttons = listOf(guideButton()),
+        ),
+        PluginTooltipEntry(
+            tag = TAG_BACK,
+            summary = "Back to Preferences.",
+            detail = """
+                <p>Leaves the Semantic Search screen. Nothing here needs saving:
+                the embedding model is stored as soon as you pick it.</p>
+            """.trimIndent(),
+        ),
+        PluginTooltipEntry(
+            tag = TAG_BACKEND,
+            summary = "The AI backend search embeds with, and whether it supports Vector Search.",
+            detail = """
+                <p>Vector Search uses the backend selected in <b>AI settings</b>,
+                the same one the Agent chats with. This shows its name, its chat
+                model, and whether it can produce embeddings.</p>
+                <p><b>Not supported</b> means the backend cannot embed, or its
+                plugin is too old to offer its embedding models here. Update its
+                plugin, since newer Gemini and OpenAI plugins support this, or
+                select a backend that does in AI settings. Local never embeds.</p>
+                <p>The screen updates on its own when you switch backend.</p>
+            """.trimIndent(),
+            buttons = listOf(guideButton()),
+        ),
+        PluginTooltipEntry(
+            tag = TAG_EMBEDDING_MODEL,
+            summary = "Which model turns your code into vectors for search. Never used for chat.",
+            detail = """
+                <p>The list holds the embedding models your backend can use right
+                now, such as the Gemini models that support
+                <code>embedContent</code>. The choice is stored by the backend
+                plugin itself.</p>
+                <p>Changing it changes the vector space, so the next search builds
+                the index again from scratch with the new model. Vectors from two
+                different models cannot be compared.</p>
+                <p>If the list cannot load (no API key, no network) the field still
+                shows the model in use, with the reason beneath it.</p>
+            """.trimIndent(),
+            buttons = listOf(guideButton()),
+        ),
+        PluginTooltipEntry(
+            tag = TAG_PRIVACY,
+            summary = "Indexing sends your project's source code to the selected backend.",
+            detail = """
+                <p>To embed your code, Vector Search sends each chunk of the
+                project's source files to the provider behind the selected
+                backend. The vectors that come back are stored only on this
+                device.</p>
+                <p>Your query is sent the same way each time you search.</p>
+            """.trimIndent(),
+            buttons = listOf(guideButton()),
+        ),
+        PluginTooltipEntry(
+            tag = TAG_INDEX_STATUS,
+            summary = "Whether the open project's index is ready, and what it holds.",
+            detail = """
+                <p>The first search in a project builds its index, and later
+                searches reuse it.</p>
+                <p><b>Up to date</b>: built with the selected backend and model.
+                <b>Out of date</b>: built with another model, so the next search
+                rebuilds it. <b>Indexing</b>: a build is running; the bar shows how
+                many chunks are embedded. <b>Last build failed</b>: nothing was
+                stored; fix the backend's key or quota, then clear the index to
+                try again. <b>Not indexed yet</b>: no search has run here since the
+                index was built or cleared.</p>
+                <p>Below that: how many chunks and files are indexed, the model and
+                vector size, and when the index was last built.</p>
+            """.trimIndent(),
+        ),
+        PluginTooltipEntry(
+            tag = TAG_CLEAR_INDEX,
+            summary = "Deletes the stored index of every project, after you confirm.",
+            detail = """
+                <p>Clears the index for <b>every</b> project, not only the open
+                one. Nothing is deleted until you confirm.</p>
+                <p>The next search builds the index again, which sends the
+                project's source to the selected backend again.</p>
+            """.trimIndent(),
+            buttons = listOf(guideButton()),
+        ),
+    )
+
+    /** The Tier 3 guide, which covers the settings screen as well as search itself. */
+    private fun guideButton() = PluginTooltipButton(
+        description = "Vector Search guide",
+        uri = "index.html",
+        order = 0,
+    )
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/VectorSearchPlugin.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/VectorSearchPlugin.kt
index 92038c4e..20e60b2e 100644
--- a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/VectorSearchPlugin.kt
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/VectorSearchPlugin.kt
@@ -3,42 +3,35 @@ package com.itsaky.androidide.plugins.vectorsearch
 import com.itsaky.androidide.plugins.IPlugin
 import com.itsaky.androidide.plugins.PluginContext
 import com.itsaky.androidide.plugins.PluginLogger
+import com.itsaky.androidide.plugins.ai.LlmBackendRegistration
 import com.itsaky.androidide.plugins.extensions.DocumentationExtension
-import com.itsaky.androidide.plugins.extensions.PluginTooltipButton
+import com.itsaky.androidide.plugins.extensions.PluginSettingsEntry
 import com.itsaky.androidide.plugins.extensions.PluginTooltipEntry
 import com.itsaky.androidide.plugins.extensions.ProjectSearchExtension
 import com.itsaky.androidide.plugins.extensions.ProjectSearchRequest
 import com.itsaky.androidide.plugins.extensions.ProjectSearchResult
 import com.itsaky.androidide.plugins.extensions.ProjectSearchSection
+import com.itsaky.androidide.plugins.extensions.SettingsExtension
 import com.itsaky.androidide.plugins.services.LlmInferenceService
-import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingBackend
 import com.itsaky.androidide.plugins.services.SharedServices
+import com.itsaky.androidide.plugins.vectorsearch.settings.SemanticSearchSettingsFragment
+import com.itsaky.androidide.plugins.vectorsearch.settings.SemanticSearchSource
+import java.io.File
+import java.util.concurrent.CompletableFuture
 import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.ensureActive
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runInterruptible
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeoutOrNull
-import java.io.File
-import java.io.IOException
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.ExecutionException
-import kotlin.coroutines.coroutineContext
 
 /**
  * Names this class in every line it logs.
  *
  * The host already prefixes each line with `[pluginId]`, which says which `.cgp` wrote it but not
- * which of its classes; this plugin logs from two.
+ * which of its classes.
  */
 private const val TAG = "VectorSearchPlugin"
-private const val AI_CORE_PLUGIN_ID = "com.itsaky.androidide.plugins.aicore"
-private const val SEMANTIC_RESULTS_TITLE = "Semantic Results"
 
 /**
  * How long one search may spend waiting, across every wait it makes.
@@ -63,32 +56,34 @@ private const val SEARCH_BUDGET_MS = 8_000L
  * lexical fallback — one used to fill the index with hashed token bags that were
  * indistinguishable from real vectors once stored, which made the feature look like it worked.
  */
-class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtension {
+class VectorSearchPlugin :
+    IPlugin, ProjectSearchExtension, DocumentationExtension, SettingsExtension {
 
     private lateinit var context: PluginContext
     private lateinit var indexingService: EmbeddingIndexingService
-    @Volatile private var indexingJob: Job? = null
-    // What the last completed build produced; null until one has completed in this session.
-    @Volatile private var indexedState: IndexState? = null
-    // What the in-flight [indexingJob] is building; guards against awaiting a build whose result
-    // this search could not use — another project's roots, or another embedder's vector space.
-    @Volatile private var indexingTarget: IndexTarget? = null
+    private lateinit var indexing: IndexCoordinator
 
-    // Background scope for indexing so a large project never stalls a search request.
-    private val indexingScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    // Watches the selected backend for the settings screen; live from activate to deactivate.
+    private var backendWatch: BackendWatch? = null
+
+    // What the settings screen reads, rebuilt with [indexing] on each activate.
+    @Volatile private var semanticSearch: SemanticSearchSource? = null
 
     /**
      * This plugin's IDE-surfaced log, so indexing diagnostics reach the IDE's own log view rather
-     * than only logcat.
-     *
-     * Null before [initialize], which is the state [dispose] can be called in when the plugin
-     * failed to load — the one path that must not throw on its way out.
+     * than only logcat. Null before [initialize], the state [dispose] runs in after a failed load.
      */
     private val log: PluginLogger?
         get() = if (::context.isInitialized) context.logger else null
 
+    fun logger(): PluginLogger? = log
+
+    /** The settings screen's view of this activation's index, or null before [activate]. */
+    fun semanticSearchSource(): SemanticSearchSource? = semanticSearch
+
     override fun initialize(context: PluginContext): Boolean {
         this.context = context
+        instance = this
         log?.info("$TAG: initialized")
         return true
     }
@@ -96,8 +91,33 @@ class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtensi
     override fun activate(): Boolean {
         log?.info("$TAG: activating...")
 
-        // Initialize indexing service
+        if (::indexing.isInitialized) indexing.close()
+        if (::indexingService.isInitialized) indexingService.close()
         indexingService = EmbeddingIndexingService(context.androidContext, context.logger)
+        val indexChanges = MutableStateFlow(0L)
+        indexing = IndexCoordinator(
+            store = indexingService,
+            buildLog = PreferencesIndexBuildLog {
+                context.getPluginSharedPreferences(PreferencesIndexBuildLog.FILE)
+            },
+            logger = { log },
+            onIndexChanged = { indexChanges.update { it + 1 } },
+        )
+
+        backendWatch?.stop()
+        val backendChanges = MutableStateFlow(0L)
+        backendWatch = BackendWatch(context, ::inferenceService) {
+            backendChanges.update { it + 1 }
+        }.also { it.start() }
+
+        semanticSearch = SemanticSearchSourceImpl(
+            context = context,
+            store = indexingService,
+            indexing = indexing,
+            inference = ::inferenceService,
+            backendChanges = backendChanges.asStateFlow(),
+            indexChanges = indexChanges.asStateFlow(),
+        )
 
         log?.info("$TAG: activated. The first search builds the index.")
         return true
@@ -105,11 +125,17 @@ class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtensi
 
     override fun deactivate(): Boolean {
         log?.info("$TAG: deactivating")
+        backendWatch?.stop()
+        backendWatch = null
         return true
     }
 
     override fun dispose() {
-        indexingScope.cancel()
+        backendWatch?.stop()
+        backendWatch = null
+        if (instance === this) instance = null
+        semanticSearch = null
+        if (::indexing.isInitialized) indexing.close()
         // Release the SQLite connection so it doesn't leak when the plugin unloads.
         if (::indexingService.isInitialized) {
             indexingService.close()
@@ -130,17 +156,17 @@ class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtensi
     override fun searchProject(request: ProjectSearchRequest): CompletableFuture<List<ProjectSearchSection>> {
         log?.info("$TAG: project search requested for '${request.query}'")
         return CompletableFuture.supplyAsync {
-            val results = runBlocking {
-                search(query = request.query, roots = request.roots, topK = 10)
+            val outcome = runBlocking {
+                searchReporting(query = request.query, roots = request.roots, topK = 10)
             }
-            if (results.isEmpty()) {
+            if (outcome.results.isEmpty()) {
                 log?.info("$TAG: no semantic results available for '${request.query}'")
                 emptyList()
             } else {
                 listOf(
                     ProjectSearchSection(
-                        title = SEMANTIC_RESULTS_TITLE,
-                        results = results.map { it.toProjectSearchResult(request.query) },
+                        title = resultsTitle(outcome.rebuiltWith),
+                        results = outcome.results.map { it.toProjectSearchResult(request.query) },
                     )
                 )
             }
@@ -163,30 +189,51 @@ class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtensi
         query: String,
         roots: List<File> = emptyList(),
         topK: Int = 10,
-    ): List<CodeEmbedding> {
-        return try {
+    ): List<CodeEmbedding> = searchReporting(query, roots, topK).results
+
+    /**
+     * One search's answer, and whether answering it replaced the index's embedding model.
+     *
+     * @param results the ranked chunks, empty when there is no answer
+     * @param rebuiltWith the model this search rebuilt the index with, or null when it reused one
+     */
+    private data class SearchOutcome(
+        val results: List<CodeEmbedding>,
+        val rebuiltWith: String? = null,
+    )
+
+    /** [search], also reporting a rebuild so the results can say why the first query was slow. */
+    private suspend fun searchReporting(
+        query: String,
+        roots: List<File>,
+        topK: Int,
+    ): SearchOutcome {
+        var rebuiltWith: String? = null
+        val ranked = try {
             val deadline = System.nanoTime() + SEARCH_BUDGET_MS * 1_000_000
             val embedder = EmbedderResolver.resolve(inferenceService())
             if (embedder !is EmbedderResolution.Ready) {
                 logUnresolved(embedder)
-                return emptyList()
+                return SearchOutcome(emptyList())
             }
 
             // The query is embedded first because its vector is what reports the width: only a
             // vector the backend actually produced can say what space the index must be built in.
             val queryEmbedding = withTimeoutOrNull(remainingMs(deadline)) {
-                embed(embedder.backend, listOf(query)).firstOrNull()
+                embedder.backend.awaitVectors(listOf(query)).firstOrNull()
             }
             if (queryEmbedding == null) {
                 log?.warn("$TAG: no query vector within ${SEARCH_BUDGET_MS}ms; no semantic results")
-                return emptyList()
+                return SearchOutcome(emptyList())
             }
             val identity = EmbedderIdentity(embedder.key, queryEmbedding.size)
 
-            val rootsKey = if (roots.isEmpty()) null else rootsKeyOf(roots)
+            val rootsKey = if (roots.isEmpty()) null else RootsKey.of(roots)
             if (rootsKey != null) {
                 // Wait for an in-flight build so the first query returns real results, not empty.
-                val job = startIndexingIfNeeded(rootsKey, roots, embedder.backend, identity)
+                val build = indexing.buildIfNeeded(rootsKey, roots, embedder.backend, identity)
+                if (build?.replacedModel != null) rebuiltWith = identity.modelId
+                val job = build?.job
                 if (job != null && withTimeoutOrNull(remainingMs(deadline)) { job.join() } == null) {
                     log?.warn("$TAG: indexing outlasted the search budget; using partial index")
                 }
@@ -194,47 +241,66 @@ class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtensi
 
             val comparable = indexingService.getAllEmbeddings(identity, rootsKey)
             if (comparable.isEmpty()) {
-                log?.warn("$TAG: no embeddings from $identity yet; no semantic results for now")
-                return emptyList()
+                val rebuilding = rebuiltWith?.let { " (index rebuilding with $it)" }.orEmpty()
+                log?.warn("$TAG: no embeddings from $identity yet; no semantic results$rebuilding")
+                return SearchOutcome(emptyList(), rebuiltWith)
             }
 
-            val results =
+            val scored =
                 VectorSearchService.searchWithScores(queryEmbedding, comparable, topK = topK)
-            log?.debug("$TAG: search for '$query' returned ${results.size} results")
+            log?.debug("$TAG: search for '$query' returned ${scored.size} results")
 
-            results.map { it.first }
+            scored.map { it.first }
         } catch (e: CancellationException) {
             throw e
         } catch (e: Exception) {
             log?.error("$TAG: error during search", e)
             emptyList()
         }
+        return SearchOutcome(ranked, rebuiltWith)
     }
 
-    /** What is left of the search budget, floored at zero so an expired budget waits no longer. */
-    private fun remainingMs(deadline: Long): Long =
-        ((deadline - System.nanoTime()) / 1_000_000).coerceAtLeast(0)
+    /**
+     * The results section's title, naming the new model when this search rebuilt the index for it.
+     *
+     * @param rebuiltWith the model the index was rebuilt with, or null when it was reused
+     */
+    private fun resultsTitle(rebuiltWith: String?): String =
+        if (rebuiltWith == null) {
+            string(R.string.search_results_title, FALLBACK_RESULTS_TITLE)
+        } else {
+            string(R.string.search_results_title_rebuilt, FALLBACK_RESULTS_TITLE, rebuiltWith)
+        }
 
     /**
-     * Clears the index of every project (e.g., for reindexing after project changes).
+     * Resolves [resId] against this plugin's own resources.
+     *
+     * @param fallback returned when the context is missing or the lookup fails; the host builds
+     *   search results and Preferences on its own schedule and must never see an exception here
      */
-    fun clearIndex() {
-        indexingService.clearIndex()
-        indexedState = null
-        log?.info("$TAG: index cleared")
+    private fun string(resId: Int, fallback: String, vararg args: Any): String = try {
+        context.androidContext.getString(resId, *args)
+    } catch (e: Exception) {
+        fallback
     }
 
+    /** What is left of the search budget, floored at zero so an expired budget waits no longer. */
+    private fun remainingMs(deadline: Long): Long =
+        ((deadline - System.nanoTime()) / 1_000_000).coerceAtLeast(0)
+
     /**
-     * AI Core's inference service, however this host publishes it.
-     *
-     * `context.services` is deliberately not a third fallback: it is this plugin's own registry
-     * and holds only the host's own `Ide*Service`s, so a cross-plugin lookup there never answers.
-     *
-     * @return the service, or null when AI Core is absent or has not published it yet
+     * AI Core's inference service, or null before [initialize], since Preferences may build the
+     * settings screen first. Not `context.services` as a third fallback: that registry holds only
+     * the host's own `Ide*Service`s, so a cross-plugin lookup there never answers.
      */
-    private fun inferenceService(): LlmInferenceService? =
-        SharedServices.get(LlmInferenceService::class.java)
-            ?: context.getPluginService(AI_CORE_PLUGIN_ID, LlmInferenceService::class.java)
+    private fun inferenceService(): LlmInferenceService? {
+        if (!::context.isInitialized) return null
+        return SharedServices.get(LlmInferenceService::class.java)
+            ?: context.getPluginService(
+                LlmBackendRegistration.AI_CORE_PLUGIN_ID,
+                LlmInferenceService::class.java,
+            )
+    }
 
     /**
      * Says why there is no embedder, in the words that name the fix.
@@ -272,227 +338,6 @@ class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtensi
         }
     }
 
-    /**
-     * Starts (or reuses) a background index build for [roots], returning its [Job] so the caller
-     * can await it, or null when the index already answers for these roots and this embedder.
-     *
-     * @param rootsKey the roots being indexed, as one value
-     * @param roots project root directories to index
-     * @param backend the embedder to build with
-     * @param identity what that embedder produces, as the query has just demonstrated
-     * @return the running index-build job, or null if the existing index is reusable
-     */
-    @Synchronized
-    private fun startIndexingIfNeeded(
-        rootsKey: String,
-        roots: List<File>,
-        backend: EmbeddingBackend,
-        identity: EmbedderIdentity,
-    ): Job? {
-        val target = IndexTarget(rootsKey, identity)
-        val running = indexingJob
-        if (running != null && running.isActive && indexingTarget == target) {
-            return running
-        }
-        if (running?.isActive != true) {
-            // The marker is per-session but the rows are not: ask before re-embedding, or a
-            // restart and a project switch each pay for the whole project again.
-            if (!ReindexDecision.isReusable(indexedState, rootsKey, identity)) {
-                val stored = indexingService.countEmbeddings(rootsKey, identity)
-                if (stored > 0) indexedState = IndexState(rootsKey, identity, stored)
-            }
-            if (ReindexDecision.isReusable(indexedState, rootsKey, identity)) return null
-        }
-
-        // Cancel a build for another target and wait for it to unwind, so builds never
-        // interleave writes.
-        val previous = running
-        previous?.cancel()
-        indexingTarget = target
-        val job = indexingScope.launch {
-            try {
-                previous?.join()
-                buildIndex(rootsKey, roots, backend, identity)
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: Exception) {
-                log?.error("$TAG: background indexing failed", e)
-            }
-        }
-        indexingJob = job
-        return job
-    }
-
-    /**
-     * What one index build is for, as the one value two builds are compared on.
-     *
-     * @param rootsKey the roots being indexed
-     * @param identity the embedder the vectors will come from
-     */
-    private data class IndexTarget(val rootsKey: String, val identity: EmbedderIdentity)
-
-    /** The roots, as one value two builds can be compared on. */
-    private fun rootsKeyOf(roots: List<File>): String =
-        roots.map { it.absolutePath }.sorted().joinToString("|")
-
-    /**
-     * Builds the whole index for [roots], batch by batch.
-     *
-     * A failed batch aborts the build and leaves the index empty rather than substituting anything.
-     * A substitute would be stored under the real embedder's identity, so the origin filter could
-     * not tell it apart and every later search would rank it beside genuine vectors.
-     */
-    private suspend fun buildIndex(
-        rootsKey: String,
-        roots: List<File>,
-        backend: EmbeddingBackend,
-        identity: EmbedderIdentity,
-    ) {
-        // Reset the marker up front so a mid-build failure doesn't leave a stale "indexed" flag.
-        indexedState = null
-        indexingService.clearIndex(rootsKey)
-
-        val pending = collectChunks(roots)
-        var stored = 0
-        try {
-            for (batch in EmbeddingBatches.split(pending) { it.chunkText.length }) {
-                coroutineContext.ensureActive()
-                val vectors = embed(backend, batch.map { it.chunkText })
-                indexingService.storeEmbeddings(rootsKey, toEmbeddings(batch, vectors, identity))
-                stored += batch.size
-            }
-        } catch (e: CancellationException) {
-            throw e
-        } catch (e: Exception) {
-            // Emptied, not left partial: a half-built index answers with whatever it happened to
-            // reach first, which reads as bad ranking rather than as a failed build.
-            indexingService.clearIndex(rootsKey)
-            // Recorded as an attempt: a backend that refuses every call — a revoked key, an
-            // exhausted quota — must not be re-tried, and re-billed, by every later search.
-            indexedState = IndexState(rootsKey, identity, chunkCount = 0)
-            log?.error("$TAG: indexing aborted after $stored of ${pending.size} chunks", e)
-            return
-        }
-
-        indexedState = IndexState(rootsKey, identity, stored)
-        log?.info("$TAG: indexed $stored chunks with $identity")
-    }
-
-    /**
-     * One chunk waiting to be embedded.
-     *
-     * Collected before any embedding so the loop that calls the network is about batches rather
-     * than about walking a file tree.
-     */
-    private data class PendingChunk(
-        val key: String,
-        val filePath: String,
-        val chunkText: String,
-        val language: String,
-        val chunkIndex: Int,
-        val startLine: Int,
-        val endLine: Int,
-    )
-
-    /** Walks [roots] and chunks every code file it finds. */
-    private suspend fun collectChunks(roots: List<File>): List<PendingChunk> {
-        val pending = mutableListOf<PendingChunk>()
-        var fileCount = 0
-
-        roots.forEach { root ->
-            indexingService.collectFiles(root).forEach { file ->
-                // Bail promptly if this build was superseded by one for different roots.
-                coroutineContext.ensureActive()
-                fileCount++
-                val language = indexingService.languageFor(file)
-                val chunks = try {
-                    CodeChunker.chunkFile(file)
-                } catch (e: Exception) {
-                    log?.warn("$TAG: failed to chunk ${file.absolutePath}", e)
-                    emptyList()
-                }
-
-                chunks.forEachIndexed { index, chunk ->
-                    pending.add(
-                        PendingChunk(
-                            key = "${file.absolutePath}:$index",
-                            filePath = file.absolutePath,
-                            chunkText = chunk.content,
-                            language = language,
-                            chunkIndex = index,
-                            startLine = chunk.startLine + 1,
-                            endLine = chunk.endLine + 1,
-                        )
-                    )
-                }
-            }
-        }
-
-        log?.info("$TAG: collected ${pending.size} chunks from $fileCount files")
-        return pending
-    }
-
-    /**
-     * Pairs a batch with the vectors it produced.
-     *
-     * @throws IOException when the backend answered with a different width than the index is being
-     *   built in — storing those rows would put two spaces under one identity
-     */
-    private fun toEmbeddings(
-        batch: List<PendingChunk>,
-        vectors: List<FloatArray>,
-        identity: EmbedderIdentity,
-    ): List<CodeEmbedding> = batch.mapIndexed { position, chunk ->
-        val vector = vectors[position]
-        if (vector.size != identity.dimensions) {
-            throw IOException(
-                "The embedder answered with ${vector.size} dimensions, not ${identity.dimensions}"
-            )
-        }
-        CodeEmbedding(
-            key = chunk.key,
-            filePath = chunk.filePath,
-            chunkText = chunk.chunkText,
-            language = chunk.language,
-            chunkIndex = chunk.chunkIndex,
-            startLine = chunk.startLine,
-            endLine = chunk.endLine,
-            embedding = vector,
-            identity = identity,
-        )
-    }
-
-    /**
-     * Embeds [texts] with [backend], unwrapping the future's failure so the caller sees the
-     * backend's own message rather than an [ExecutionException] wrapper.
-     *
-     * The wait is interruptible and cancels the future with it: without that, abandoning an index
-     * build would leave its HTTP requests running to completion for vectors nobody will store.
-     *
-     * @return one vector per text, in order
-     * @throws IOException when the backend failed or answered with the wrong number of vectors
-     */
-    private suspend fun embed(
-        backend: EmbeddingBackend,
-        texts: List<String>,
-    ): List<FloatArray> {
-        val future = backend.embed(texts)
-        val vectors = try {
-            runInterruptible { future.get() }
-        } catch (e: CancellationException) {
-            future.cancel(true)
-            throw e
-        } catch (e: ExecutionException) {
-            throw IOException(e.cause?.message ?: "The embedder failed", e.cause ?: e)
-        }
-        if (vectors == null || vectors.size != texts.size) {
-            throw IOException(
-                "The embedder answered with ${vectors?.size ?: 0} vectors for ${texts.size} texts"
-            )
-        }
-        return vectors
-    }
-
     private fun CodeEmbedding.toProjectSearchResult(query: String): ProjectSearchResult {
         val line = startLine.coerceAtLeast(1) - 1
         return ProjectSearchResult(
@@ -506,36 +351,44 @@ class VectorSearchPlugin : IPlugin, ProjectSearchExtension, DocumentationExtensi
         )
     }
 
-    override fun getTooltipCategory(): String = "plugin_com.itsaky.androidide.plugins.vectorsearch"
-
-    override fun getTooltipEntries(): List<PluginTooltipEntry> = listOf(
-        PluginTooltipEntry(
-            tag = TOOLTIP_TAG_PLUGIN,
-            summary = "Vector Search adds semantic, meaning-based matches to project search.",
-            detail = """
-                <p><b>Vector Search</b> chunks project files, embeds them with
-                the AI backend you selected in AI settings, and ranks matches by
-                semantic similarity instead of only exact text.</p>
-                <p>It needs a backend that produces embeddings, which today means
-                a cloud one. With no such backend selected it simply contributes
-                no results, rather than quietly matching on words and presenting
-                that as semantic search.</p>
-                <p>Changing the backend or its embedding model builds the index
-                again: vectors from two different models cannot be compared.</p>
-            """.trimIndent(),
-            buttons = listOf(
-                PluginTooltipButton(
-                    description = "Vector Search guide",
-                    uri = "index.html",
-                    order = 0
-                )
-            )
+    // --- SettingsExtension: the Semantic Search row in Preferences -> Configuration ---
+
+    override fun getSettingsEntries(): List<PluginSettingsEntry> = listOf(
+        PluginSettingsEntry(
+            id = "semantic_search",
+            title = string(R.string.pref_semantic_search_title, "Semantic Search"),
+            summary = string(
+                R.string.pref_semantic_search_summary,
+                "Embedding model, backend support and index",
+            ),
+            fragmentClassName = SemanticSearchSettingsFragment::class.java.name,
         )
     )
 
+    // --- DocumentationExtension: three-tier in-IDE help ---
+
+    override fun getTooltipCategory(): String = TOOLTIP_CATEGORY
+
+    override fun getTooltipEntries(): List<PluginTooltipEntry> = VectorSearchHelp.entries()
+
     override fun getTier3DocsAssetPath(): String = "docs"
 
-    private companion object {
-        const val TOOLTIP_TAG_PLUGIN = "plugin_vector_search"
+    companion object {
+        const val PLUGIN_ID = "com.itsaky.androidide.plugins.vectorsearch"
+
+        /**
+         * Category the host registers this plugin's tooltips under. Must be `"plugin_"` + the full
+         * plugin id, or a long-press renders the literal string `n/a`.
+         */
+        const val TOOLTIP_CATEGORY = "plugin_$PLUGIN_ID"
+
+        /** The results title when this plugin's own resources cannot be read. */
+        private const val FALLBACK_RESULTS_TITLE = "Semantic Results"
+
+        @Volatile
+        private var instance: VectorSearchPlugin? = null
+
+        /** The live plugin, for the settings screen the host constructs by class name. */
+        fun getInstance(): VectorSearchPlugin? = instance
     }
 }
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/BackendCompatibility.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/BackendCompatibility.kt
new file mode 100644
index 00000000..480161c5
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/BackendCompatibility.kt
@@ -0,0 +1,101 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import com.itsaky.androidide.plugins.services.LlmInferenceService
+import com.itsaky.androidide.plugins.services.LlmInferenceService.ActiveModelReportingBackend
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingModelSelectable
+
+/**
+ * What the settings screen can say about the backend selected for chat, which Vector Search embeds
+ * with. Closed because each case names a different fix, and the screen draws empty fields for none.
+ */
+sealed interface BackendCompatibility {
+
+    /** AI Core is not installed, or has not published its service yet. */
+    data object NoService : BackendCompatibility
+
+    /** No backend has been chosen in AI settings. */
+    data object NoSelection : BackendCompatibility
+
+    /**
+     * A backend was chosen but nothing is registered under its id: its plugin is disabled or gone.
+     *
+     * @param backendId the stored selection
+     */
+    data class NotInstalled(val backendId: String) : BackendCompatibility
+
+    /**
+     * The selected backend, which is registered.
+     *
+     * @param backendId its id
+     * @param backendName its display name
+     * @param chatModel the model a chat turn uses, or null when the backend does not report one
+     * @param support whether, and how far, it serves Vector Search
+     */
+    data class Selected(
+        val backendId: String,
+        val backendName: String,
+        val chatModel: String?,
+        val support: EmbeddingSupport,
+    ) : BackendCompatibility
+}
+
+/** Whether a registered backend serves Vector Search. */
+sealed interface EmbeddingSupport {
+
+    /**
+     * Not supported: it does not embed, or its plugin is too old to list and set its embedding
+     * model here (not [EmbeddingModelSelectable]). Local never embeds; an old plugin is updated.
+     */
+    data object None : EmbeddingSupport
+
+    /**
+     * It embeds and lets this screen list and change its model.
+     *
+     * @param backend the backend to list models from and to set the choice on
+     * @param modelId the embedding model it uses now
+     */
+    data class Selectable(
+        val backend: EmbeddingModelSelectable,
+        val modelId: String,
+    ) : EmbeddingSupport
+}
+
+/**
+ * Reads [BackendCompatibility] from AI Core's inference service, without Android, so each case is
+ * testable. Every call into the backend is guarded: it is another plugin's code, and a throwing
+ * accessor there must cost this screen one line rather than the whole Preferences screen.
+ */
+object BackendCompatibilityResolver {
+
+    /**
+     * @param service AI Core's inference service, or null when it is not published
+     * @return the case that holds now
+     */
+    fun resolve(service: LlmInferenceService?): BackendCompatibility {
+        if (service == null) return BackendCompatibility.NoService
+
+        val backendId = runCatching { service.preferredBackendId }.getOrNull()
+            ?.takeIf { it.isNotBlank() }
+            ?: return BackendCompatibility.NoSelection
+
+        val backend = runCatching { service.getBackend(backendId) }.getOrNull()
+            ?: return BackendCompatibility.NotInstalled(backendId)
+
+        val name = runCatching { backend.name }.getOrNull()?.takeIf { it.isNotBlank() } ?: backendId
+        val chatModel = (backend as? ActiveModelReportingBackend)
+            ?.let { runCatching { it.activeModelName }.getOrNull() }
+            ?.takeIf { it.isNotBlank() }
+
+        return BackendCompatibility.Selected(backendId, name, chatModel, supportOf(backend))
+    }
+
+    /** Asks with `instanceof`, as the contract says a consumer should. */
+    private fun supportOf(backend: LlmInferenceService.LlmBackend): EmbeddingSupport {
+        if (backend !is EmbeddingModelSelectable) return EmbeddingSupport.None
+        // A backend that names no model cannot embed anything, whatever interfaces it carries.
+        val modelId = runCatching { backend.embeddingModelId }.getOrNull()?.trim()
+            ?.takeIf { it.isNotEmpty() }
+            ?: return EmbeddingSupport.None
+        return EmbeddingSupport.Selectable(backend, modelId)
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/IndexStatus.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/IndexStatus.kt
new file mode 100644
index 00000000..55a53c18
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/IndexStatus.kt
@@ -0,0 +1,88 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import com.itsaky.androidide.plugins.vectorsearch.IndexedEmbedder
+
+/** What the index holds, or is doing, for the open project, as the settings screen reports it. */
+sealed interface IndexStatus {
+
+    /** No project is open, so there is nothing to report on. */
+    data object NoProject : IndexStatus
+
+    /** The open project has no rows: never searched, or cleared since. */
+    data object NotIndexed : IndexStatus
+
+    /**
+     * A build for the open project is running.
+     *
+     * @param stored chunks embedded and stored so far
+     * @param total chunks to embed; zero while the files are still being collected
+     */
+    data class Building(val stored: Int, val total: Int) : IndexStatus
+
+    /** The last build for the open project stopped on an error and stored nothing. */
+    data object BuildFailed : IndexStatus
+
+    /**
+     * The open project's rows.
+     *
+     * @param embedders per embedder, largest first; never empty, and more than one only while a
+     *   switched model is half rebuilt
+     * @param fileCount how many files have rows
+     * @param lastBuiltAt when a build of this project last completed, or null when none is recorded
+     */
+    data class Indexed(
+        val embedders: List<IndexedEmbedder>,
+        val fileCount: Int,
+        val lastBuiltAt: Long?,
+    ) : IndexStatus {
+
+        /** Every chunk under the project, whichever embedder produced it. */
+        val chunkCount: Int get() = embedders.sumOf { it.chunkCount }
+    }
+}
+
+/** The one word the screen leads the Index section with. */
+enum class IndexHealth {
+    NO_PROJECT,
+    NOT_INDEXED,
+    INDEXING,
+    BUILD_FAILED,
+
+    /** Rows from exactly the selected backend and model: searches use them as they are. */
+    UP_TO_DATE,
+
+    /** Rows from another backend or model: the next search rebuilds the index. */
+    OUT_OF_DATE,
+
+    /** Rows exist, but the selected backend cannot say which model it would use. */
+    INDEXED;
+
+    companion object {
+
+        /**
+         * @param status what the index holds for the open project
+         * @param compatibility the selected backend, or null before it is read
+         * @return the state to lead with
+         */
+        fun of(status: IndexStatus, compatibility: BackendCompatibility?): IndexHealth =
+            when (status) {
+                IndexStatus.NoProject -> NO_PROJECT
+                IndexStatus.NotIndexed -> NOT_INDEXED
+                is IndexStatus.Building -> INDEXING
+                IndexStatus.BuildFailed -> BUILD_FAILED
+                is IndexStatus.Indexed -> freshness(status, compatibility)
+            }
+
+        private fun freshness(
+            status: IndexStatus.Indexed,
+            compatibility: BackendCompatibility?,
+        ): IndexHealth {
+            val selected = compatibility as? BackendCompatibility.Selected ?: return INDEXED
+            val support = selected.support as? EmbeddingSupport.Selectable ?: return INDEXED
+            val current = status.embedders.all {
+                it.backendId == selected.backendId && it.modelId == support.modelId
+            }
+            return if (current) UP_TO_DATE else OUT_OF_DATE
+        }
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsFragment.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsFragment.kt
new file mode 100644
index 00000000..0fcbda11
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsFragment.kt
@@ -0,0 +1,547 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.os.Bundle
+import android.text.format.DateUtils
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.inputmethod.EditorInfo
+import android.widget.ArrayAdapter
+import android.widget.AutoCompleteTextView
+import android.widget.Filter
+import android.widget.ImageButton
+import android.widget.TextView
+import androidx.appcompat.app.AlertDialog
+import androidx.core.view.ViewCompat
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import com.google.android.material.button.MaterialButton
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.progressindicator.LinearProgressIndicator
+import com.google.android.material.textfield.TextInputLayout
+import com.itsaky.androidide.plugins.base.PluginFragmentHelper
+import com.itsaky.androidide.plugins.services.IdeTooltipService
+import com.itsaky.androidide.plugins.vectorsearch.R
+import com.itsaky.androidide.plugins.vectorsearch.VectorSearchHelp
+import com.itsaky.androidide.plugins.vectorsearch.VectorSearchPlugin
+import java.text.NumberFormat
+import kotlinx.coroutines.launch
+
+/** Material's opacity for a disabled control, applied by hand where `isEnabled` cannot be used. */
+private const val DISABLED_ALPHA = 0.38f
+
+/** Date and time, month abbreviated, in the user's locale: "Oct 5, 2:05 PM". */
+private const val LAST_BUILT_FORMAT =
+    DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_TIME or DateUtils.FORMAT_ABBREV_MONTH
+
+/** Material's pressed-state overlay opacity, out of 255, for the destructive button's ripple. */
+private const val RIPPLE_ALPHA = 0x1F
+
+/**
+ * The Semantic Search screen, opened from Preferences → Configuration → Semantic Search: the
+ * backend Vector Search embeds with and whether it can, its embedding model, where the code goes,
+ * and the index. Loaded by name with this plugin's classloader, inflated against its resources.
+ */
+class SemanticSearchSettingsFragment : Fragment() {
+
+    private lateinit var viewModel: SemanticSearchSettingsViewModel
+    private var tooltipService: IdeTooltipService? = null
+
+    /** The screen's views, bound once per view; null between onDestroyView and the next view. */
+    private var views: Views? = null
+
+    /** The models the dropdown's adapter holds, so a render changing nothing keeps the popup. */
+    private var adapterModels: List<String>? = null
+
+    /** Tracked so a rotation takes it down with the view it was anchored to, not as a leak. */
+    private var clearDialog: AlertDialog? = null
+
+    /** Groups thousands in the user's locale, so 3104 reads as 3,104 or 3.104. */
+    private val numbers: NumberFormat = NumberFormat.getIntegerInstance()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        try {
+            tooltipService = PluginFragmentHelper.getServiceRegistry(VectorSearchPlugin.PLUGIN_ID)
+                ?.get(IdeTooltipService::class.java)
+        } catch (e: Exception) {
+            // Tooltip help is optional; long-press simply shows nothing when it's unavailable.
+            VectorSearchPlugin.getInstance()?.logger()
+                ?.warn("SemanticSearch: no tooltip service", e)
+        }
+    }
+
+    /**
+     * Routes inflation through the host so this screen resolves against *this* plugin's resources
+     * and a Context whose Configuration tracks the IDE's day/night setting.
+     */
+    override fun onGetLayoutInflater(savedInstanceState: Bundle?): LayoutInflater {
+        val inflater = super.onGetLayoutInflater(savedInstanceState)
+        return PluginFragmentHelper.getPluginInflater(VectorSearchPlugin.PLUGIN_ID, inflater)
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?,
+    ): View? = inflater.inflate(R.layout.fragment_semantic_search_settings, container, false)
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        viewModel = ViewModelProvider(
+            this,
+            SemanticSearchSettingsViewModelFactory {
+                VectorSearchPlugin.getInstance()?.semanticSearchSource()
+            },
+        )[SemanticSearchSettingsViewModel::class.java]
+
+        val bound = Views(view)
+        views = bound
+        adapterModels = null
+
+        wireTooltip(bound.back, VectorSearchHelp.TAG_BACK)
+        bound.back.setOnClickListener { leaveScreen() }
+        // The whole-plugin entry, whose guide button opens the Tier 3 page.
+        listOf(bound.title, bound.description)
+            .forEach { wireTooltip(it, VectorSearchHelp.TAG_PLUGIN) }
+
+        listOf(
+            bound.backendLabel, bound.backendMessage, bound.backendName,
+            bound.backendSupport, bound.chatModel, bound.backendHint,
+        ).forEach { wireTooltip(it, VectorSearchHelp.TAG_BACKEND) }
+        wireTooltip(bound.privacy, VectorSearchHelp.TAG_PRIVACY)
+        listOf(
+            bound.indexLabel, bound.indexState, bound.indexMessage,
+            bound.indexProgressGroup, bound.indexDetails,
+        ).forEach { wireTooltip(it, VectorSearchHelp.TAG_INDEX_STATUS) }
+        setupProgress(bound)
+
+        setupModelPicker(bound)
+
+        wireTooltip(bound.clearIndex, VectorSearchHelp.TAG_CLEAR_INDEX)
+        styleAsDestructive(bound.clearIndex)
+        bound.clearIndex.setOnClickListener { confirmClear() }
+
+        // viewLifecycleOwner, not the fragment: the collector holds views and must stop with them.
+        viewLifecycleOwner.lifecycleScope.launch {
+            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                viewModel.state.collect { state -> views?.let { render(it, state) } }
+            }
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        // A search run since the screen was last shown changes the index line.
+        viewModel.refresh()
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        // Anchored to the view being destroyed; see the field's comment.
+        clearDialog?.dismiss()
+        clearDialog = null
+        views = null
+    }
+
+    /**
+     * Leaves this screen. The host mounts a settings pane on its own back stack or as the whole
+     * activity, so both are handled, as on the MCP servers screen.
+     */
+    private fun leaveScreen() {
+        if (parentFragmentManager.backStackEntryCount > 0) {
+            parentFragmentManager.popBackStack()
+        } else {
+            requireActivity().finish()
+        }
+    }
+
+    // --- Embedding model picker ----------------------------------------------------------------
+
+    /**
+     * Picked or typed: the list is filtered by name on OpenAI-compatible servers, so it can miss a
+     * model the backend accepts.
+     */
+    private fun setupModelPicker(bound: Views) {
+        val box = bound.modelBox
+        val input = bound.modelInput
+
+        // In code, not as app:endIconDrawable, which draws blank inside the host.
+        box.endIconMode = TextInputLayout.END_ICON_CUSTOM
+        box.setEndIconDrawable(R.drawable.ic_dropdown)
+        box.endIconContentDescription = getString(R.string.cd_vs_show_embedding_models)
+        box.isEndIconCheckable = false
+
+        listOf(bound.modelLabel, input, bound.modelHint)
+            .forEach { wireTooltip(it, VectorSearchHelp.TAG_EMBEDDING_MODEL) }
+        box.setEndIconOnLongClickListener { icon ->
+            showTooltip(icon, VectorSearchHelp.TAG_EMBEDDING_MODEL)
+        }
+
+        // Rendered from the state on every view creation; a restored setText() would filter.
+        input.isSaveEnabled = false
+        // No adapter means nothing to list, so a tap opens nothing then.
+        input.setOnClickListener { if (input.adapter != null) input.showDropDown() }
+        box.setEndIconOnClickListener { if (input.adapter != null) input.showDropDown() }
+        input.setOnItemClickListener { parent, _, position, _ ->
+            (parent.getItemAtPosition(position) as? String)?.let(viewModel::selectModel)
+        }
+        val commitTyped = {
+            input.text.toString().trim().takeIf { it.isNotEmpty() }?.let(viewModel::selectModel)
+        }
+        input.setOnEditorActionListener { _, actionId, _ ->
+            if (actionId == EditorInfo.IME_ACTION_DONE) commitTyped()
+            false
+        }
+        input.setOnFocusChangeListener { _, hasFocus -> if (!hasFocus) commitTyped() }
+    }
+
+    /** In code: the bar's app: colour attributes are dropped inside the host. */
+    private fun setupProgress(bound: Views) {
+        val context = bound.indexProgress.context
+        bound.indexProgress.setIndicatorColor(context.getColor(R.color.plugin_primary))
+        bound.indexProgress.trackColor = context.getColor(R.color.plugin_outline_variant)
+    }
+
+    /**
+     * Outlined in the error colour, since the button deletes every project's index. In code: the
+     * style's app: items (stroke, ripple) are dropped inside the host, and its roles resolve there.
+     */
+    private fun styleAsDestructive(button: MaterialButton) {
+        val error = ColorStateList.valueOf(button.context.getColor(R.color.plugin_error))
+        button.setTextColor(error)
+        button.strokeColor = error
+        button.strokeWidth = button.resources.getDimensionPixelSize(R.dimen.vs_outline_stroke)
+        button.rippleColor = error.withAlpha(RIPPLE_ALPHA)
+        button.backgroundTintList = ColorStateList.valueOf(Color.TRANSPARENT)
+    }
+
+    // --- Rendering -----------------------------------------------------------------------------
+
+    private fun render(bound: Views, state: SemanticSearchState) {
+        renderBackend(bound, state)
+        renderIndex(bound, state)
+    }
+
+    private fun renderBackend(bound: Views, state: SemanticSearchState) {
+        val selected = state.compatibility as? BackendCompatibility.Selected
+        if (selected == null) {
+            // Null only while the first read runs, when nothing true can be said yet.
+            val text = state.compatibility?.let(::unavailableMessage)
+            bound.backendMessage.text = text
+            bound.backendMessage.visibility = if (text == null) View.GONE else View.VISIBLE
+            bound.backendDetails.visibility = View.GONE
+            return
+        }
+        bound.backendMessage.visibility = View.GONE
+        bound.backendDetails.visibility = View.VISIBLE
+
+        bound.backendName.text = selected.backendName
+        bound.chatModel.text = selected.chatModel?.let { getString(R.string.vs_chat_model, it) }
+        bound.chatModel.visibility = if (selected.chatModel == null) View.GONE else View.VISIBLE
+
+        val supported = selected.support is EmbeddingSupport.Selectable
+        bound.backendSupport.setText(
+            if (supported) R.string.vs_supported else R.string.vs_not_supported
+        )
+        bound.backendSupport.setTextColor(
+            bound.backendSupport.context.getColor(
+                if (supported) R.color.plugin_success else R.color.plugin_error
+            )
+        )
+        bound.backendHint.text =
+            if (supported) null else getString(R.string.vs_hint_not_supported, selected.backendName)
+        bound.backendHint.visibility = if (supported) View.GONE else View.VISIBLE
+
+        bound.privacy.text = getString(R.string.vs_privacy, selected.backendName)
+
+        renderModelPicker(bound, selected.support, state)
+    }
+
+    /** What to say instead of the backend's details when there is no backend to describe. */
+    private fun unavailableMessage(compatibility: BackendCompatibility): String? =
+        when (compatibility) {
+            BackendCompatibility.NoService -> getString(R.string.vs_no_service)
+            BackendCompatibility.NoSelection -> getString(R.string.vs_no_selection)
+            is BackendCompatibility.NotInstalled ->
+                getString(R.string.vs_not_installed, compatibility.backendId)
+            is BackendCompatibility.Selected -> null
+        }
+
+    private fun renderModelPicker(
+        bound: Views,
+        support: EmbeddingSupport,
+        state: SemanticSearchState,
+    ) {
+        val input = bound.modelInput
+        val current = (support as? EmbeddingSupport.Selectable)?.modelId.orEmpty()
+        // The suppressing overload: a filtering write would narrow the list to this one entry.
+        if (!input.hasFocus() && input.text.toString() != current) input.setText(current, false)
+
+        val options = state.selectedModels
+        val models = (options as? ModelOptions.Loaded)?.models.orEmpty()
+        setPickerEnabled(bound, support is EmbeddingSupport.Selectable)
+        if (models != adapterModels) {
+            adapterModels = models
+            input.setAdapter(if (models.isEmpty()) null else DropdownAdapter(input.context, models))
+        }
+
+        var isError = false
+        val hintText: String? = when {
+            support !is EmbeddingSupport.Selectable -> null
+            options is ModelOptions.Failed -> {
+                isError = true
+                options.reason?.let { getString(R.string.vs_models_failed, it) }
+                    ?: getString(R.string.vs_models_failed_unknown)
+            }
+            options !is ModelOptions.Loaded -> getString(R.string.vs_models_loading)
+            options.models.isEmpty() -> getString(R.string.vs_models_empty)
+            state.pickedModel != null -> getString(R.string.vs_model_changed, state.pickedModel)
+            else -> getString(R.string.vs_models_help)
+        }
+        bound.modelHint.text = hintText
+        bound.modelHint.visibility = if (hintText == null) View.GONE else View.VISIBLE
+        bound.modelHint.setTextColor(
+            bound.modelHint.context.getColor(
+                if (isError) R.color.plugin_error else R.color.plugin_text_muted
+            )
+        )
+    }
+
+    /**
+     * Draws the picker as enabled or not without `isEnabled`: a disabled view drops long-presses,
+     * and the field's tooltip has to open in exactly the states that disable it.
+     */
+    private fun setPickerEnabled(bound: Views, enabled: Boolean) {
+        bound.modelBox.alpha = if (enabled) 1f else DISABLED_ALPHA
+        bound.modelInput.isFocusableInTouchMode = enabled
+        ViewCompat.setStateDescription(
+            bound.modelInput,
+            if (enabled) null else getString(R.string.vs_state_unavailable),
+        )
+    }
+
+    private fun renderIndex(bound: Views, state: SemanticSearchState) {
+        val status = state.indexStatus
+        val health = state.indexHealth
+
+        bound.indexState.text = health?.let { getString(stateLabel(it)) }.orEmpty()
+        bound.indexState.setTextColor(bound.indexState.context.getColor(stateColor(health)))
+
+        val message = status?.let { indexMessage(it, health, state.compatibility) }
+        bound.indexMessage.text = message
+        bound.indexMessage.visibility = if (message == null) View.GONE else View.VISIBLE
+
+        renderProgress(bound, status as? IndexStatus.Building)
+        renderDetails(bound, status as? IndexStatus.Indexed, state.compatibility)
+
+        // Not `isEnabled`: a disabled view drops the long-press its tooltip opens on.
+        val canClear = state.canClear && !state.clearing
+        bound.clearIndex.isClickable = canClear
+        bound.clearIndex.alpha = if (canClear) 1f else DISABLED_ALPHA
+        ViewCompat.setStateDescription(
+            bound.clearIndex,
+            if (canClear) null else getString(R.string.vs_state_unavailable),
+        )
+        bound.clearIndex.setText(
+            if (state.clearing) R.string.vs_clearing_index else R.string.vs_clear_index
+        )
+    }
+
+    private fun stateLabel(health: IndexHealth): Int = when (health) {
+        IndexHealth.NO_PROJECT -> R.string.vs_index_no_project
+        IndexHealth.NOT_INDEXED -> R.string.vs_index_not_indexed
+        IndexHealth.INDEXING -> R.string.vs_index_state_indexing
+        IndexHealth.BUILD_FAILED -> R.string.vs_index_state_failed
+        IndexHealth.UP_TO_DATE -> R.string.vs_index_state_up_to_date
+        IndexHealth.OUT_OF_DATE -> R.string.vs_index_state_out_of_date
+        IndexHealth.INDEXED -> R.string.vs_index_state_indexed
+    }
+
+    private fun stateColor(health: IndexHealth?): Int = when (health) {
+        IndexHealth.UP_TO_DATE -> R.color.plugin_success
+        IndexHealth.OUT_OF_DATE -> R.color.plugin_warning
+        IndexHealth.BUILD_FAILED -> R.color.plugin_error
+        IndexHealth.INDEXING -> R.color.plugin_primary
+        else -> R.color.plugin_text_muted
+    }
+
+    /** The sentence under the state that says what follows from it, or null when nothing does. */
+    private fun indexMessage(
+        status: IndexStatus,
+        health: IndexHealth?,
+        compatibility: BackendCompatibility?,
+    ): String? = when (health) {
+        IndexHealth.NOT_INDEXED -> getString(R.string.vs_index_msg_not_indexed)
+        IndexHealth.BUILD_FAILED -> getString(R.string.vs_index_msg_failed)
+        IndexHealth.INDEXED -> getString(R.string.vs_index_msg_indexed)
+        IndexHealth.OUT_OF_DATE -> {
+            val built = (status as IndexStatus.Indexed).embedders.map { it.modelId }.distinct()
+            val selected = (compatibility as BackendCompatibility.Selected).support
+            getString(
+                R.string.vs_index_msg_out_of_date,
+                built.joinToString(", "),
+                (selected as EmbeddingSupport.Selectable).modelId,
+            )
+        }
+        else -> null
+    }
+
+    /** A bar and a count while a build runs; indeterminate while the files are being collected. */
+    private fun renderProgress(bound: Views, building: IndexStatus.Building?) {
+        bound.indexProgressGroup.visibility = if (building == null) View.GONE else View.VISIBLE
+        building ?: return
+
+        val bar = bound.indexProgress
+        val collecting = building.total == 0
+        if (bar.isIndeterminate != collecting) {
+            // Switched while hidden: some Material versions refuse to switch a visible bar's mode.
+            bar.visibility = View.INVISIBLE
+            bar.isIndeterminate = collecting
+            bar.visibility = View.VISIBLE
+        }
+        if (collecting) {
+            bound.indexProgressText.setText(R.string.vs_index_preparing)
+            return
+        }
+        bar.max = building.total
+        bar.setProgressCompat(building.stored, true)
+        bound.indexProgressText.text = resources.getQuantityString(
+            R.plurals.vs_index_progress,
+            building.total,
+            numbers.format(building.stored),
+            numbers.format(building.total),
+        )
+    }
+
+    /** One label and value per fact about the open project's index. */
+    private fun renderDetails(
+        bound: Views,
+        indexed: IndexStatus.Indexed?,
+        compatibility: BackendCompatibility?,
+    ) {
+        bound.indexDetails.visibility = if (indexed == null) View.GONE else View.VISIBLE
+        indexed ?: return
+
+        bound.indexChunks.text = numbers.format(indexed.chunkCount)
+        bound.indexFiles.text = numbers.format(indexed.fileCount)
+        val selected = compatibility as? BackendCompatibility.Selected
+        bound.indexModel.text = indexed.embedders
+            .map { embedder ->
+                val backend = if (embedder.backendId == selected?.backendId) {
+                    selected.backendName
+                } else {
+                    embedder.backendId
+                }
+                getString(
+                    R.string.vs_index_model_value, backend, embedder.modelId, embedder.dimensions,
+                )
+            }
+            .distinct()
+            .joinToString("\n")
+        bound.indexLastBuilt.text = indexed.lastBuiltAt?.let {
+            DateUtils.formatDateTime(bound.indexLastBuilt.context, it, LAST_BUILT_FORMAT)
+        } ?: getString(R.string.vs_index_last_built_unknown)
+    }
+
+    // --- Clear index ---------------------------------------------------------------------------
+
+    /**
+     * Asks before deleting anything. Cancel, Back and a tap outside all dismiss without a callback,
+     * so only the positive button reaches [SemanticSearchSettingsViewModel.clearIndex].
+     */
+    private fun confirmClear() {
+        if (clearDialog != null) return
+        clearDialog = MaterialAlertDialogBuilder(requireContext())
+            .setTitle(R.string.vs_clear_title)
+            .setMessage(R.string.vs_clear_message)
+            .setPositiveButton(R.string.vs_clear_confirm) { _, _ -> viewModel.clearIndex() }
+            .setNegativeButton(R.string.vs_clear_cancel, null)
+            .setOnDismissListener { clearDialog = null }
+            .create()
+            .apply { show() }
+    }
+
+    // --- Tooltips ------------------------------------------------------------------------------
+
+    /** Long-press on [view] shows [tag]'s entry, under this plugin's category (3-arg overload). */
+    private fun wireTooltip(view: View, tag: String) {
+        view.setOnLongClickListener { anchor -> showTooltip(anchor, tag) }
+    }
+
+    private fun showTooltip(anchor: View, tag: String): Boolean {
+        val service = tooltipService ?: return false
+        service.showTooltip(anchor, VectorSearchPlugin.TOOLTIP_CATEGORY, tag)
+        return true
+    }
+
+    /** The screen's views, looked up once per view rather than on every render. */
+    private class Views(root: View) {
+        val back: ImageButton = root.findViewById(R.id.vsBack)
+        val title: TextView = root.findViewById(R.id.vsTitle)
+        val description: TextView = root.findViewById(R.id.vsDescription)
+        val backendLabel: TextView = root.findViewById(R.id.vsBackendLabel)
+        val backendMessage: TextView = root.findViewById(R.id.vsBackendMessage)
+        val backendDetails: View = root.findViewById(R.id.vsBackendDetails)
+        val backendName: TextView = root.findViewById(R.id.vsBackendName)
+        val backendSupport: TextView = root.findViewById(R.id.vsBackendSupport)
+        val chatModel: TextView = root.findViewById(R.id.vsChatModel)
+        val backendHint: TextView = root.findViewById(R.id.vsBackendHint)
+        val modelLabel: TextView = root.findViewById(R.id.vsEmbeddingModelLabel)
+        val modelBox: TextInputLayout = root.findViewById(R.id.vsEmbeddingModelBox)
+        val modelInput: AutoCompleteTextView = root.findViewById(R.id.vsEmbeddingModelInput)
+        val modelHint: TextView = root.findViewById(R.id.vsEmbeddingModelHint)
+        val privacy: TextView = root.findViewById(R.id.vsPrivacy)
+        val indexLabel: TextView = root.findViewById(R.id.vsIndexLabel)
+        val indexState: TextView = root.findViewById(R.id.vsIndexState)
+        val indexMessage: TextView = root.findViewById(R.id.vsIndexMessage)
+        val indexProgressGroup: View = root.findViewById(R.id.vsIndexProgressGroup)
+        val indexProgress: LinearProgressIndicator = root.findViewById(R.id.vsIndexProgress)
+        val indexProgressText: TextView = root.findViewById(R.id.vsIndexProgressText)
+        val indexDetails: View = root.findViewById(R.id.vsIndexDetails)
+        val indexChunks: TextView = root.findViewById(R.id.vsIndexChunks)
+        val indexFiles: TextView = root.findViewById(R.id.vsIndexFiles)
+        val indexModel: TextView = root.findViewById(R.id.vsIndexModel)
+        val indexLastBuilt: TextView = root.findViewById(R.id.vsIndexLastBuilt)
+        val clearIndex: MaterialButton = root.findViewById(R.id.vsClearIndex)
+    }
+}
+
+/**
+ * The dropdown's rows and, more importantly, its filter.
+ *
+ * [ArrayAdapter]'s own filter narrows the list to what is in the field, so after a day/night switch
+ * replays the field's text only the chosen row is left. This one always offers every model.
+ */
+private class DropdownAdapter(
+    context: Context,
+    private val items: List<String>,
+) : ArrayAdapter<String>(context, R.layout.item_dropdown, items.toMutableList()) {
+
+    private val passThrough = object : Filter() {
+        override fun performFiltering(constraint: CharSequence?): FilterResults =
+            FilterResults().apply {
+                values = items
+                count = items.size
+            }
+
+        override fun publishResults(constraint: CharSequence?, results: FilterResults?) =
+            notifyDataSetChanged()
+    }
+
+    override fun getFilter(): Filter = passThrough
+
+    override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
+        val view = super.getView(position, convertView, parent)
+        // Set on every bind rather than once: these rows are recycled.
+        (view as? TextView)?.setTextColor(context.getColor(R.color.plugin_on_surface))
+        return view
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsViewModel.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsViewModel.kt
new file mode 100644
index 00000000..883c3499
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsViewModel.kt
@@ -0,0 +1,261 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.future.await
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+
+/**
+ * Bounds a model listing that never answers, well above a backend's own request timeouts so a slow
+ * but live catalog is not cut short.
+ */
+private const val LIST_MODELS_TIMEOUT_MS = 60_000L
+
+/** The embedding models the dropdown may offer, for one backend. */
+sealed interface ModelOptions {
+
+    /** Nothing to list: the backend is not supported, or has not been read yet. */
+    data object None : ModelOptions
+
+    /** @param backendId the backend being asked */
+    data class Loading(val backendId: String) : ModelOptions
+
+    /**
+     * @param backendId the backend that answered
+     * @param models its embedding models, in its order; possibly empty
+     */
+    data class Loaded(val backendId: String, val models: List<String>) : ModelOptions
+
+    /**
+     * @param backendId the backend that failed
+     * @param reason the backend's own sentence, or null when it gave none
+     */
+    data class Failed(val backendId: String, val reason: String?) : ModelOptions
+}
+
+/**
+ * Everything the Semantic Search screen draws.
+ *
+ * @param compatibility the selected backend, or null until first read
+ * @param models what the embedding model dropdown offers
+ * @param indexStatus what the open project's index holds, or null until first read
+ * @param pickedModel the model the user just picked here, so the screen can say a rebuild follows
+ * @param clearing whether a confirmed clear is still running
+ * @param canClear whether a clear would do anything: some project has rows, or a build is running
+ */
+data class SemanticSearchState(
+    val compatibility: BackendCompatibility? = null,
+    val models: ModelOptions = ModelOptions.None,
+    val indexStatus: IndexStatus? = null,
+    val pickedModel: String? = null,
+    val clearing: Boolean = false,
+    val canClear: Boolean = false,
+) {
+
+    /** The word the Index section leads with, or null until the index has been read. */
+    val indexHealth: IndexHealth?
+        get() = indexStatus?.let { IndexHealth.of(it, compatibility) }
+
+
+    /** [models] when they belong to the selected backend; another backend's are never shown. */
+    val selectedModels: ModelOptions
+        get() {
+            val selectedId = (compatibility as? BackendCompatibility.Selected)?.backendId
+            return if (models.ownerId == selectedId) models else ModelOptions.None
+        }
+}
+
+/** The backend these options were read from, or null when they belong to none. */
+private val ModelOptions.ownerId: String?
+    get() = when (this) {
+        ModelOptions.None -> null
+        is ModelOptions.Loading -> backendId
+        is ModelOptions.Loaded -> backendId
+        is ModelOptions.Failed -> backendId
+    }
+
+/**
+ * Reads the selected backend, its embedding models and the index, and reads them again whenever
+ * the source reports a change, so switching backend in AI settings reaches an open screen.
+ *
+ * @param source what the screen reads and resets, or null before the plugin is activated
+ * @param ioDispatcher where reads that may touch another plugin or the database run
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class SemanticSearchSettingsViewModel(
+    private val source: () -> SemanticSearchSource?,
+    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) : ViewModel() {
+
+    private val _state = MutableStateFlow(SemanticSearchState())
+    val state: StateFlow<SemanticSearchState> = _state.asStateFlow()
+
+    /** Asks for a full read; merged into the backend flow so only one read ever runs. */
+    private val refreshRequests = MutableSharedFlow<Unit>(
+        extraBufferCapacity = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+
+    /**
+     * The source whose changes are watched, re-read on [refresh]: null before the plugin is
+     * activated, and a new instance on each activate, whose flows are not the old one's.
+     */
+    private val owners = MutableStateFlow(source())
+
+    init {
+        viewModelScope.launch {
+            // Latest: a newer change cancels the older read, so its result can never land after.
+            owners
+                .flatMapLatest { owner -> owner?.backendChanges ?: flowOf(0L) }
+                .let { merge(it, refreshRequests) }
+                .collectLatest { reloadAll() }
+        }
+        viewModelScope.launch {
+            owners
+                .flatMapLatest { owner -> owner?.indexChanges ?: emptyFlow() }
+                .collectLatest { reloadIndex() }
+        }
+    }
+
+    /** Reads everything again; for a screen coming back to the foreground. */
+    fun refresh() {
+        owners.value = source()
+        refreshRequests.tryEmit(Unit)
+    }
+
+    /**
+     * Makes [modelId] the backend's embedding model. The backend stores it and notifies AI Core,
+     * whose notice comes back as a backend change.
+     *
+     * @param modelId a model the dropdown offered or the user typed
+     */
+    fun selectModel(modelId: String) {
+        val selectable = selectableOf(_state.value.compatibility) ?: return
+        if (modelId == selectable.modelId) return
+        viewModelScope.launch {
+            try {
+                // Off the main thread: another plugin's setter may load its preferences from disk.
+                withContext(ioDispatcher) { selectable.backend.setEmbeddingModelId(modelId) }
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                log("could not set the embedding model to $modelId", e)
+                return@launch
+            }
+            _state.update { it.copy(pickedModel = modelId) }
+        }
+    }
+
+    /** Clears every project's index; the caller has already asked the user to confirm. */
+    fun clearIndex() {
+        val owner = source() ?: return
+        if (_state.value.clearing) return
+        _state.update { it.copy(clearing = true) }
+        viewModelScope.launch {
+            try {
+                // Off the main thread: the clear queues behind a build holding the index lock.
+                withContext(ioDispatcher) { owner.clearIndex() }.join()
+            } finally {
+                _state.update { it.copy(clearing = false) }
+            }
+            reloadIndex()
+        }
+    }
+
+    private suspend fun reloadAll() {
+        val compatibility = withContext(ioDispatcher) {
+            BackendCompatibilityResolver.resolve(source()?.inferenceService())
+        }
+        val selectable = selectableOf(compatibility)
+        _state.update { current ->
+            current.copy(
+                compatibility = compatibility,
+                models = if (selectable == null) ModelOptions.None else current.models,
+                // Dropped once the backend's model is no longer the pick, e.g. changed elsewhere.
+                pickedModel = current.pickedModel.takeIf { it == selectable?.modelId },
+            )
+        }
+        reloadIndex()
+        if (selectable != null) {
+            loadModels((compatibility as BackendCompatibility.Selected).backendId, selectable)
+        }
+    }
+
+    private suspend fun reloadIndex() {
+        val (indexStatus, holdsAnything) = withContext(ioDispatcher) {
+            try {
+                val owner = source()
+                val status = owner?.indexStatus() ?: IndexStatus.NoProject
+                // Running and failed builds are always clearable: clearing is how a failure retries.
+                val clearable = status is IndexStatus.Building || status is IndexStatus.BuildFailed
+                status to (clearable || owner?.indexHoldsAnything() == true)
+            } catch (e: Exception) {
+                log("could not read the index status", e)
+                IndexStatus.NoProject to false
+            }
+        }
+        _state.update { it.copy(indexStatus = indexStatus, canClear = holdsAnything) }
+    }
+
+    /**
+     * Lists [backendId]'s embedding models on every backend change, since a new server or key
+     * changes them under the same id. A list already shown stays up while the new one loads.
+     */
+    private suspend fun loadModels(backendId: String, selectable: EmbeddingSupport.Selectable) {
+        if (_state.value.selectedModels !is ModelOptions.Loaded) {
+            _state.update { it.copy(models = ModelOptions.Loading(backendId)) }
+        }
+        val options = try {
+            val models = withTimeout(LIST_MODELS_TIMEOUT_MS) {
+                selectable.backend.listEmbeddingModels().await()
+            }
+            ModelOptions.Loaded(backendId, models.filter { it.isNotBlank() }.distinct())
+        } catch (e: TimeoutCancellationException) {
+            ModelOptions.Failed(backendId, reason = null)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            ModelOptions.Failed(backendId, e.message?.takeIf { it.isNotBlank() })
+        }
+        _state.update { it.copy(models = options) }
+    }
+
+    private fun selectableOf(compatibility: BackendCompatibility?): EmbeddingSupport.Selectable? =
+        (compatibility as? BackendCompatibility.Selected)?.support as? EmbeddingSupport.Selectable
+
+    private fun log(message: String, error: Throwable) {
+        source()?.logger()?.warn("SemanticSearchSettings: $message", error)
+    }
+}
+
+/** Builds [SemanticSearchSettingsViewModel] against the live plugin's current source. */
+class SemanticSearchSettingsViewModelFactory(
+    private val source: () -> SemanticSearchSource?,
+) : ViewModelProvider.Factory {
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : ViewModel> create(modelClass: Class<T>): T {
+        if (modelClass.isAssignableFrom(SemanticSearchSettingsViewModel::class.java)) {
+            return SemanticSearchSettingsViewModel(source) as T
+        }
+        throw IllegalArgumentException("Unknown ViewModel class")
+    }
+}
diff --git a/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSource.kt b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSource.kt
new file mode 100644
index 00000000..5debc85a
--- /dev/null
+++ b/plugins/Vector-Search/src/main/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSource.kt
@@ -0,0 +1,34 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import com.itsaky.androidide.plugins.PluginLogger
+import com.itsaky.androidide.plugins.services.LlmInferenceService
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * What the Semantic Search screen reads and resets, so its view model depends on these calls
+ * rather than on the whole plugin, and tests can stand in for it.
+ */
+interface SemanticSearchSource {
+
+    /** Ticks when the selected backend, its models or AI Core itself may have changed. */
+    val backendChanges: StateFlow<Long>
+
+    /** Ticks when an index build ended or the index was cleared. */
+    val indexChanges: StateFlow<Long>
+
+    /** AI Core's inference service, or null when it is absent or not yet published. */
+    fun inferenceService(): LlmInferenceService?
+
+    /** What the index holds for the open project. Reads the database, so not on the main thread. */
+    fun indexStatus(): IndexStatus
+
+    /** Whether any project has rows, so a clear would delete something. Reads the database too. */
+    fun indexHoldsAnything(): Boolean
+
+    /** Clears every project's index; the returned job completes once the index is empty. */
+    fun clearIndex(): Job
+
+    /** This plugin's log, or null before it has a context. */
+    fun logger(): PluginLogger?
+}
diff --git a/plugins/Vector-Search/src/main/res/drawable/ic_arrow_back.xml b/plugins/Vector-Search/src/main/res/drawable/ic_arrow_back.xml
new file mode 100644
index 00000000..1f9e3701
--- /dev/null
+++ b/plugins/Vector-Search/src/main/res/drawable/ic_arrow_back.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Mirrored automatically for right-to-left locales, like the host's own back affordance. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:autoMirrored="true">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M20,11H7.83l5.59,-5.59L12,4l-8,8l8,8l1.41,-1.41L7.83,13H20V11z" />
+
+</vector>
diff --git a/plugins/Vector-Search/src/main/res/drawable/ic_dropdown.xml b/plugins/Vector-Search/src/main/res/drawable/ic_dropdown.xml
new file mode 100644
index 00000000..8a9df932
--- /dev/null
+++ b/plugins/Vector-Search/src/main/res/drawable/ic_dropdown.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M7,10l5,5 5,-5z" />
+</vector>
diff --git a/plugins/Vector-Search/src/main/res/layout/fragment_semantic_search_settings.xml b/plugins/Vector-Search/src/main/res/layout/fragment_semantic_search_settings.xml
new file mode 100644
index 00000000..d92e6a9e
--- /dev/null
+++ b/plugins/Vector-Search/src/main/res/layout/fragment_semantic_search_settings.xml
@@ -0,0 +1,336 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Semantic Search settings screen. Structured like the MCP servers screen beside it in Preferences:
+  a fixed toolbar row, then the scrolling content.
+
+  Only android: attributes: app: ones on library widgets are dropped inside the host, so the
+  dropdown's end icon is set in code. Every colour is a @color/plugin_* reference with a night
+  variant, so the screen follows the IDE's day/night setting.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/plugin_surface"
+    android:orientation="vertical">
+
+    <LinearLayout
+        android:id="@+id/vsToolbar"
+        android:layout_width="match_parent"
+        android:layout_height="@dimen/vs_toolbar_height"
+        android:background="@color/plugin_surface_variant"
+        android:gravity="center_vertical"
+        android:orientation="horizontal"
+        android:paddingStart="4dp"
+        android:paddingEnd="16dp">
+
+        <ImageButton
+            android:id="@+id/vsBack"
+            android:layout_width="@dimen/vs_toolbar_icon_size"
+            android:layout_height="@dimen/vs_toolbar_icon_size"
+            android:background="?android:attr/selectableItemBackgroundBorderless"
+            android:contentDescription="@string/cd_vs_back"
+            android:padding="@dimen/vs_toolbar_icon_padding"
+            android:scaleType="fitCenter"
+            android:src="@drawable/ic_arrow_back"
+            android:tint="@color/plugin_on_surface" />
+
+        <TextView
+            android:id="@+id/vsTitle"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="12dp"
+            android:layout_weight="1"
+            android:text="@string/vs_title"
+            android:textColor="@color/plugin_on_surface"
+            android:textSize="@dimen/vs_title_text_size"
+            android:textStyle="bold" />
+
+    </LinearLayout>
+
+    <ScrollView
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:fillViewport="true">
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:padding="@dimen/space_lg">
+
+            <TextView
+                android:id="@+id/vsDescription"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/vs_description"
+                android:textAppearance="@style/Plugin.Text.Small" />
+
+            <!-- AI backend: the one selected in AI settings, and whether it can embed. -->
+
+            <TextView
+                android:id="@+id/vsBackendLabel"
+                style="@style/Plugin.SectionHeader"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="@dimen/space_xl"
+                android:text="@string/vs_label_backend" />
+
+            <!-- Shown instead of the backend's details when there is no backend to describe. -->
+            <TextView
+                android:id="@+id/vsBackendMessage"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:textAppearance="@style/Plugin.Text.Body"
+                android:visibility="gone" />
+
+            <LinearLayout
+                android:id="@+id/vsBackendDetails"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical">
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:gravity="center_vertical"
+                    android:orientation="horizontal">
+
+                    <TextView
+                        android:id="@+id/vsBackendName"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:textAppearance="@style/Plugin.Text.Body"
+                        android:textStyle="bold" />
+
+                    <TextView
+                        android:id="@+id/vsBackendSupport"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_marginStart="@dimen/space_sm"
+                        android:textAppearance="@style/Plugin.Text.Small"
+                        android:textStyle="bold" />
+
+                </LinearLayout>
+
+                <TextView
+                    android:id="@+id/vsChatModel"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xs"
+                    android:textAppearance="@style/Plugin.Text.Small" />
+
+                <TextView
+                    android:id="@+id/vsBackendHint"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_sm"
+                    android:textAppearance="@style/Plugin.Text.Small"
+                    android:visibility="gone" />
+
+                <!-- Embedding model: listed from, and stored by, the backend itself. -->
+
+                <TextView
+                    android:id="@+id/vsEmbeddingModelLabel"
+                    style="@style/Plugin.SectionHeader"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xl"
+                    android:text="@string/vs_label_embedding_model" />
+
+                <com.google.android.material.textfield.TextInputLayout
+                    android:id="@+id/vsEmbeddingModelBox"
+                    style="@style/PluginTextInputLayout"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:hint="@string/vs_hint_embedding_model">
+
+                    <AutoCompleteTextView
+                        android:id="@+id/vsEmbeddingModelInput"
+                        style="@style/PluginTextInputEditText"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:completionThreshold="0"
+                        android:imeOptions="actionDone"
+                        android:inputType="text"
+                        android:popupBackground="@color/plugin_surface" />
+                </com.google.android.material.textfield.TextInputLayout>
+
+                <TextView
+                    android:id="@+id/vsEmbeddingModelHint"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xs"
+                    android:textAppearance="@style/Plugin.Text.Small" />
+
+                <TextView
+                    android:id="@+id/vsPrivacy"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_lg"
+                    android:textAppearance="@style/Plugin.Text.Body" />
+
+            </LinearLayout>
+
+            <!-- Index: a state first, then progress or the details behind it, then the reset. -->
+
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="@dimen/space_xl"
+                android:gravity="center_vertical"
+                android:orientation="horizontal">
+
+                <TextView
+                    android:id="@+id/vsIndexLabel"
+                    style="@style/Plugin.SectionHeader"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="@string/vs_label_index" />
+
+                <TextView
+                    android:id="@+id/vsIndexState"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginStart="@dimen/space_sm"
+                    android:textAppearance="@style/Plugin.Text.Small"
+                    android:textStyle="bold" />
+
+            </LinearLayout>
+
+            <TextView
+                android:id="@+id/vsIndexMessage"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:textAppearance="@style/Plugin.Text.Small"
+                android:visibility="gone" />
+
+            <!-- Progress, while a build for the open project runs. Colours are set in code. -->
+            <LinearLayout
+                android:id="@+id/vsIndexProgressGroup"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical"
+                android:visibility="gone">
+
+                <com.google.android.material.progressindicator.LinearProgressIndicator
+                    android:id="@+id/vsIndexProgress"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_sm" />
+
+                <TextView
+                    android:id="@+id/vsIndexProgressText"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xs"
+                    android:textAppearance="@style/Plugin.Text.Small" />
+
+            </LinearLayout>
+
+            <!-- What the open project's index holds, once there is one. -->
+            <LinearLayout
+                android:id="@+id/vsIndexDetails"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical"
+                android:visibility="gone">
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xs"
+                    android:orientation="horizontal">
+
+                    <TextView
+                        android:layout_width="@dimen/vs_index_label_width"
+                        android:layout_height="wrap_content"
+                        android:text="@string/vs_index_row_chunks"
+                        android:textAppearance="@style/Plugin.Text.Small" />
+
+                    <TextView
+                        android:id="@+id/vsIndexChunks"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:textAppearance="@style/Plugin.Text.Body" />
+                </LinearLayout>
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xs"
+                    android:orientation="horizontal">
+
+                    <TextView
+                        android:layout_width="@dimen/vs_index_label_width"
+                        android:layout_height="wrap_content"
+                        android:text="@string/vs_index_row_files"
+                        android:textAppearance="@style/Plugin.Text.Small" />
+
+                    <TextView
+                        android:id="@+id/vsIndexFiles"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:textAppearance="@style/Plugin.Text.Body" />
+                </LinearLayout>
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xs"
+                    android:orientation="horizontal">
+
+                    <TextView
+                        android:layout_width="@dimen/vs_index_label_width"
+                        android:layout_height="wrap_content"
+                        android:text="@string/vs_index_row_model"
+                        android:textAppearance="@style/Plugin.Text.Small" />
+
+                    <TextView
+                        android:id="@+id/vsIndexModel"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:textAppearance="@style/Plugin.Text.Body" />
+                </LinearLayout>
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="@dimen/space_xs"
+                    android:orientation="horizontal">
+
+                    <TextView
+                        android:layout_width="@dimen/vs_index_label_width"
+                        android:layout_height="wrap_content"
+                        android:text="@string/vs_index_row_last_built"
+                        android:textAppearance="@style/Plugin.Text.Small" />
+
+                    <TextView
+                        android:id="@+id/vsIndexLastBuilt"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:textAppearance="@style/Plugin.Text.Body" />
+                </LinearLayout>
+
+            </LinearLayout>
+
+            <!-- Outlined in the error colour, set in code: it deletes every project's index. -->
+            <com.google.android.material.button.MaterialButton
+                android:id="@+id/vsClearIndex"
+                style="@style/Widget.Material3.Button.OutlinedButton"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="@dimen/space_md"
+                android:text="@string/vs_clear_index" />
+
+        </LinearLayout>
+
+    </ScrollView>
+
+</LinearLayout>
diff --git a/plugins/Vector-Search/src/main/res/layout/item_dropdown.xml b/plugins/Vector-Search/src/main/res/layout/item_dropdown.xml
new file mode 100644
index 00000000..c8e52369
--- /dev/null
+++ b/plugins/Vector-Search/src/main/res/layout/item_dropdown.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  One row of the embedding model dropdown. The plugin's own item layout rather than
+  android.R.layout.simple_list_item_1, whose text color comes from the framework theme in effect
+  when the popup window is built, which is not reliably the one the screen is drawn in.
+-->
+<TextView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:background="?android:attr/selectableItemBackground"
+    android:gravity="center_vertical"
+    android:minHeight="@dimen/touch_target_min"
+    android:paddingHorizontal="@dimen/space_lg"
+    android:paddingVertical="@dimen/space_md"
+    android:textAppearance="@style/Plugin.Text.Body" />
diff --git a/plugins/Vector-Search/src/main/res/values-night/colors.xml b/plugins/Vector-Search/src/main/res/values-night/colors.xml
new file mode 100644
index 00000000..e832ad1f
--- /dev/null
+++ b/plugins/Vector-Search/src/main/res/values-night/colors.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Dark-mode palette. Mirrors values/colors.xml name-for-name; selected automatically when the
+     IDE is in night mode. See values/colors.xml for the mechanism. -->
+<resources>
+    <color name="plugin_primary">#B1C5FF</color>
+    <color name="plugin_on_primary">#172E60</color>
+    <color name="plugin_primary_container">#304578</color>
+    <color name="plugin_on_primary_container">#DAE2FF</color>
+
+    <color name="plugin_surface">#0A0A0A</color>
+    <color name="plugin_on_surface">#FAFAFA</color>
+    <color name="plugin_surface_variant">#171717</color>
+    <color name="plugin_on_surface_variant">#A3A3A3</color>
+
+    <color name="plugin_outline">#525252</color>
+    <color name="plugin_outline_variant">#262626</color>
+
+    <color name="plugin_error">#FCA5A5</color>
+    <color name="plugin_success">#86EFAC</color>
+    <color name="plugin_warning">#FCD34D</color>
+
+    <color name="plugin_text_muted">#A3A3A3</color>
+</resources>
diff --git a/plugins/Vector-Search/src/main/res/values/colors.xml b/plugins/Vector-Search/src/main/res/values/colors.xml
index 03363c00..8d806d54 100644
--- a/plugins/Vector-Search/src/main/res/values/colors.xml
+++ b/plugins/Vector-Search/src/main/res/values/colors.xml
@@ -1,8 +1,27 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+  Light-mode palette. Semantic names shared with the other CoGo AI plugins (see ai-agent-mcp) so
+  both modes have vetted contrast; the accent keeps the in-tree CodeOnTheGo BlueWave default.
+  values-night/colors.xml holds the dark variants, and the host keeps this plugin's inflation
+  Context in sync with the IDE's day/night setting, so a plain @color/plugin_* reference flips.
+-->
 <resources>
-    <!-- Match the in-tree CodeOnTheGo BlueWave default. -->
     <color name="plugin_primary">#485D92</color>
     <color name="plugin_on_primary">#FFFFFF</color>
     <color name="plugin_primary_container">#DAE2FF</color>
     <color name="plugin_on_primary_container">#001847</color>
+
+    <color name="plugin_surface">#FAFAF9</color>
+    <color name="plugin_on_surface">#0A0A0A</color>
+    <color name="plugin_surface_variant">#F5F5F4</color>
+    <color name="plugin_on_surface_variant">#525252</color>
+
+    <color name="plugin_outline">#A3A3A3</color>
+    <color name="plugin_outline_variant">#E5E5E5</color>
+
+    <color name="plugin_error">#B91C1C</color>
+    <color name="plugin_success">#15803D</color>
+    <color name="plugin_warning">#B45309</color>
+
+    <color name="plugin_text_muted">#737373</color>
 </resources>
diff --git a/plugins/Vector-Search/src/main/res/values/dimens.xml b/plugins/Vector-Search/src/main/res/values/dimens.xml
new file mode 100644
index 00000000..ddbd93a3
--- /dev/null
+++ b/plugins/Vector-Search/src/main/res/values/dimens.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Matches the MCP servers screen beside it in Preferences, so the two read as one family. -->
+<resources>
+    <dimen name="vs_toolbar_height">48dp</dimen>
+    <dimen name="vs_toolbar_icon_size">40dp</dimen>
+    <dimen name="vs_toolbar_icon_padding">8dp</dimen>
+    <dimen name="vs_title_text_size">18sp</dimen>
+
+    <dimen name="space_xs">4dp</dimen>
+    <dimen name="space_sm">8dp</dimen>
+    <dimen name="space_md">12dp</dimen>
+    <dimen name="space_lg">16dp</dimen>
+    <dimen name="space_xl">24dp</dimen>
+
+    <dimen name="radius_md">8dp</dimen>
+    <dimen name="text_small">13sp</dimen>
+    <dimen name="text_body">15sp</dimen>
+    <dimen name="touch_target_min">48dp</dimen>
+    <dimen name="vs_index_label_width">96dp</dimen>
+    <dimen name="vs_outline_stroke">1dp</dimen>
+</resources>
diff --git a/plugins/Vector-Search/src/main/res/values/strings.xml b/plugins/Vector-Search/src/main/res/values/strings.xml
new file mode 100644
index 00000000..24254871
--- /dev/null
+++ b/plugins/Vector-Search/src/main/res/values/strings.xml
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Project search results section -->
+    <string name="search_results_title">Semantic Results</string>
+    <string name="search_results_title_rebuilt">Semantic Results (index rebuilt with %1$s)</string>
+
+    <!-- Preferences row -->
+    <string name="pref_semantic_search_title">Semantic Search</string>
+    <string name="pref_semantic_search_summary">Embedding model, backend support and index</string>
+
+    <!-- Screen chrome -->
+    <string name="vs_title">Semantic Search</string>
+    <string name="cd_vs_back">Back</string>
+    <string name="vs_description">Vector Search ranks project files by meaning, using the AI backend selected in AI settings to embed your code.</string>
+
+    <!-- AI backend section -->
+    <string name="vs_label_backend">AI backend</string>
+    <string name="vs_chat_model">Chat model: %1$s</string>
+    <string name="vs_supported">Supported</string>
+    <string name="vs_not_supported">Not supported</string>
+    <string name="vs_no_service">AI Core isn\'t installed or enabled. Install AI Core and an AI backend plugin such as Gemini or OpenAI to use Vector Search.</string>
+    <string name="vs_no_selection">No AI backend is selected. Choose one that supports Vector Search, such as Gemini or OpenAI, in AI settings.</string>
+    <string name="vs_not_installed">The selected backend, %1$s, isn\'t installed or enabled. Enable its plugin, or select another backend in AI settings.</string>
+    <string name="vs_hint_not_supported">%1$s doesn\'t support Vector Search, or its plugin is too old to offer its embedding models here. Update the %1$s plugin, or select a backend that supports it, such as Gemini or OpenAI, in AI settings.</string>
+
+    <!-- Embedding model section -->
+    <string name="vs_label_embedding_model">Embedding model</string>
+    <string name="vs_hint_embedding_model">Choose a model</string>
+    <string name="cd_vs_show_embedding_models">Show the embedding model list</string>
+    <string name="vs_state_unavailable">Unavailable</string>
+    <string name="vs_models_loading">Loading the embedding models…</string>
+    <string name="vs_models_failed">Couldn\'t load the embedding models: %1$s</string>
+    <string name="vs_models_failed_unknown">Couldn\'t load the embedding models. Check the backend\'s API key and your network connection.</string>
+    <string name="vs_models_empty">This backend lists no embedding models. Type the model\'s name instead.</string>
+    <string name="vs_models_help">Changing the model rebuilds the index on the next search.</string>
+    <string name="vs_model_changed">The next search rebuilds the index with %1$s.</string>
+
+    <!-- Privacy -->
+    <string name="vs_privacy">Indexing sends this project\'s source code to %1$s.</string>
+
+    <!-- Index section -->
+    <string name="vs_label_index">Index</string>
+    <string name="vs_index_no_project">No project open</string>
+    <string name="vs_index_not_indexed">Not indexed yet</string>
+    <string name="vs_index_state_indexing">Indexing…</string>
+    <string name="vs_index_state_failed">Last build failed</string>
+    <string name="vs_index_state_up_to_date">Up to date</string>
+    <string name="vs_index_state_out_of_date">Out of date</string>
+    <string name="vs_index_state_indexed">Indexed</string>
+    <string name="vs_index_msg_not_indexed">The first search in this project builds its index.</string>
+    <string name="vs_index_msg_failed">The last build stopped on an error, so nothing was stored. Check the backend\'s API key and quota, then clear the index so the next search tries again.</string>
+    <string name="vs_index_msg_out_of_date">Built with %1$s. The next search rebuilds it with %2$s.</string>
+    <string name="vs_index_msg_indexed">Searches use this index only while a backend that supports Vector Search is selected.</string>
+    <string name="vs_index_preparing">Collecting files…</string>
+    <plurals name="vs_index_progress">
+        <item quantity="one">%1$s of %2$s chunk embedded</item>
+        <item quantity="other">%1$s of %2$s chunks embedded</item>
+    </plurals>
+    <string name="vs_index_row_chunks">Chunks</string>
+    <string name="vs_index_row_files">Files</string>
+    <string name="vs_index_row_model">Model</string>
+    <string name="vs_index_row_last_built">Last built</string>
+    <string name="vs_index_last_built_unknown">Not recorded</string>
+    <string name="vs_index_model_value">%1$s · %2$s · %3$d dimensions</string>
+    <string name="vs_clear_index">Clear index</string>
+    <string name="vs_clearing_index">Clearing…</string>
+
+    <!-- Clear index confirmation -->
+    <string name="vs_clear_title">Clear the index?</string>
+    <string name="vs_clear_message">This clears the index for every project, not just the open one. The next search rebuilds it, which sends the project\'s source code to the selected backend again.</string>
+    <string name="vs_clear_cancel">Cancel</string>
+    <string name="vs_clear_confirm">Clear index</string>
+</resources>
diff --git a/plugins/Vector-Search/src/main/res/values/styles.xml b/plugins/Vector-Search/src/main/res/values/styles.xml
index 17bb8c55..a25b8c99 100644
--- a/plugins/Vector-Search/src/main/res/values/styles.xml
+++ b/plugins/Vector-Search/src/main/res/values/styles.xml
@@ -1,9 +1,63 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
+
+    <!--
+      DayNight theme applied to the plugin's inflation Context via android:theme on <application>.
+      The host keeps that Context's Configuration in sync with the IDE's day/night setting, so the
+      Semantic Search screen follows the IDE. Colors map to @color/plugin_* with night variants.
+    -->
     <style name="PluginTheme" parent="Theme.Material3.DayNight.NoActionBar">
         <item name="colorPrimary">@color/plugin_primary</item>
         <item name="colorOnPrimary">@color/plugin_on_primary</item>
         <item name="colorPrimaryContainer">@color/plugin_primary_container</item>
         <item name="colorOnPrimaryContainer">@color/plugin_on_primary_container</item>
+
+        <item name="android:colorBackground">@color/plugin_surface</item>
+        <item name="colorSurface">@color/plugin_surface</item>
+        <item name="colorOnSurface">@color/plugin_on_surface</item>
+        <item name="colorSurfaceVariant">@color/plugin_surface_variant</item>
+        <item name="colorOnSurfaceVariant">@color/plugin_on_surface_variant</item>
+
+        <item name="colorOutline">@color/plugin_outline</item>
+        <item name="colorOutlineVariant">@color/plugin_outline_variant</item>
+        <item name="colorError">@color/plugin_error</item>
     </style>
+
+    <!-- Typography -->
+
+    <style name="Plugin.Text.Body" parent="TextAppearance.Material3.BodyMedium">
+        <item name="android:textColor">@color/plugin_on_surface</item>
+        <item name="android:textSize">@dimen/text_body</item>
+    </style>
+
+    <style name="Plugin.Text.Small" parent="TextAppearance.Material3.BodySmall">
+        <item name="android:textColor">@color/plugin_text_muted</item>
+        <item name="android:textSize">@dimen/text_small</item>
+        <item name="android:lineSpacingMultiplier">1.25</item>
+    </style>
+
+    <!-- Eyebrow label above a section, as used by the IDE's own grouped settings. -->
+    <style name="Plugin.SectionHeader" parent="">
+        <item name="android:textAppearance">@style/TextAppearance.Material3.LabelMedium</item>
+        <item name="android:textColor">@color/plugin_text_muted</item>
+        <item name="android:paddingBottom">@dimen/space_xs</item>
+    </style>
+
+    <!--
+      The embedding model box, styled by an explicit style= on the widget rather than the theme's
+      textInputStyle: the host may layer PluginTheme onto its own theme without forcing it, and a
+      theme attribute would then resolve to the host's value.
+    -->
+    <style name="PluginTextInputLayout" parent="Widget.Material3.TextInputLayout.OutlinedBox">
+        <item name="boxStrokeColor">@color/plugin_outline</item>
+        <item name="hintTextColor">@color/plugin_text_muted</item>
+        <item name="android:textColorHint">@color/plugin_text_muted</item>
+        <item name="endIconTint">@color/plugin_on_surface_variant</item>
+    </style>
+
+    <style name="PluginTextInputEditText" parent="Widget.Material3.TextInputEditText.OutlinedBox">
+        <item name="android:textAppearance">@style/Plugin.Text.Body</item>
+        <item name="android:textColor">@color/plugin_on_surface</item>
+    </style>
+
 </resources>
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/BackendWatchTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/BackendWatchTest.kt
new file mode 100644
index 00000000..cb3fb6be
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/BackendWatchTest.kt
@@ -0,0 +1,64 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import com.itsaky.androidide.plugins.PluginContext
+import com.itsaky.androidide.plugins.services.LlmInferenceService
+import com.itsaky.androidide.plugins.services.LlmInferenceService.BackendChangeListener
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.runs
+import io.mockk.slot
+import io.mockk.verify
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class BackendWatchTest {
+
+    private var selected: String? = "gemini"
+    private val listener = slot<BackendChangeListener>()
+    private val service = mockk<LlmInferenceService>(relaxed = true) {
+        every { preferredBackendId } answers { selected }
+        every { addBackendChangeListener(capture(listener)) } just runs
+    }
+    private var changes = 0
+    private val watch = BackendWatch(mockk<PluginContext>(relaxed = true), { service }) { changes++ }
+
+    @Test
+    fun givenAnotherBackendsStatusChange_whenReported_thenTheScreenIsNotTold() {
+        // Local reports its model loading; the screen describes Gemini and has nothing to re-read.
+        watch.start()
+
+        listener.captured.onBackendChanged("local")
+
+        assertEquals(0, changes)
+    }
+
+    @Test
+    fun givenTheSelectedBackendsChange_whenReported_thenTheScreenIsTold() {
+        watch.start()
+
+        listener.captured.onBackendChanged("gemini")
+
+        assertEquals(1, changes)
+    }
+
+    @Test
+    fun givenANewSelection_whenReported_thenTheScreenIsTold() {
+        watch.start()
+        selected = "openai"
+
+        listener.captured.onBackendChanged("openai")
+
+        assertEquals(1, changes)
+    }
+
+    @Test
+    fun givenAWatchingPlugin_whenStopped_thenItsListenerIsRemoved() {
+        // AC6: deactivate() removes the listener.
+        watch.start()
+
+        watch.stop()
+
+        verify { service.removeBackendChangeListener(listener.captured) }
+    }
+}
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingsSqlTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingsSqlTest.kt
new file mode 100644
index 00000000..ceb8d78f
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/EmbeddingsSqlTest.kt
@@ -0,0 +1,70 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class EmbeddingsSqlTest {
+
+    private val identity = EmbedderIdentity(EmbedderKey("gemini", "gemini-embedding-001"), 768)
+    private val root = File("/projects/app")
+
+    @Test
+    fun givenEachBoundStatement_whenItsArgsAreBuilt_thenTheyFillEveryPlaceholder() {
+        // A missing value shifts the rest into the wrong slots: a wrong answer, not an error.
+        assertEquals(
+            placeholders(EmbeddingsSql.WHERE_IDENTITY),
+            EmbeddingsSql.identityArgs(identity).size,
+        )
+        assertEquals(
+            placeholders(EmbeddingsSql.WHERE_ROOTS_AND_IDENTITY),
+            EmbeddingsSql.scopedArgs("roots", identity).size,
+        )
+        assertEquals(
+            placeholders(EmbeddingsSql.COUNT_SCOPED),
+            EmbeddingsSql.scopedArgs("roots", identity).size,
+        )
+        assertEquals(
+            placeholders(EmbeddingsSql.SUMMARIZE_PATH_RANGE),
+            EmbeddingsSql.pathRangeArgs(root).size,
+        )
+        assertEquals(1, placeholders(EmbeddingsSql.STORED_MODELS))
+        assertEquals(1, placeholders(EmbeddingsSql.WHERE_ROOTS))
+    }
+
+    @Test
+    fun givenEveryStatement_whenRead_thenItCarriesNoLiteralValues() {
+        // Values only arrive through placeholders; a quote would mean one was spliced in.
+        listOf(
+            EmbeddingsSql.CREATE_TABLE, EmbeddingsSql.CREATE_INDEX_FILE_PATH,
+            EmbeddingsSql.CREATE_INDEX_SCOPE, EmbeddingsSql.DROP_TABLE, EmbeddingsSql.WHERE_IDENTITY,
+            EmbeddingsSql.WHERE_ROOTS_AND_IDENTITY, EmbeddingsSql.COUNT_SCOPED,
+            EmbeddingsSql.SUMMARIZE_PATH_RANGE, EmbeddingsSql.STORED_MODELS, EmbeddingsSql.WHERE_ROOTS,
+        ).forEach { statement ->
+            assertFalse(statement, statement.contains('\'') || statement.contains('"'))
+        }
+    }
+
+    @Test
+    fun givenAFileUnderTheRoot_whenRanged_thenItIsInside() {
+        assertTrue(inRange("/projects/app/src/Main.kt"))
+    }
+
+    @Test
+    fun givenSiblingsThatShareThePrefix_whenRanged_thenTheyAreOutside() {
+        // A plain prefix match would count another project's rows as this one's.
+        assertFalse(inRange("/projects/app2/Main.kt"))
+        assertFalse(inRange("/projects/app-old/Main.kt"))
+        assertFalse(inRange("/projects/app"))
+    }
+
+    /** Whether SQLite's BINARY comparison, which matches String.compareTo for ASCII, keeps [path]. */
+    private fun inRange(path: String): Boolean {
+        val (from, until) = EmbeddingsSql.pathRangeArgs(root)
+        return path >= from && path < until
+    }
+
+    private fun placeholders(statement: String): Int = statement.count { it == '?' }
+}
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexCoordinatorTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexCoordinatorTest.kt
new file mode 100644
index 00000000..90f9f16a
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/IndexCoordinatorTest.kt
@@ -0,0 +1,173 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingBackend
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import io.mockk.verifyOrder
+import java.io.File
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.atomic.AtomicInteger
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class IndexCoordinatorTest {
+
+    @get:Rule
+    val folder = TemporaryFolder()
+
+    private val identity = EmbedderIdentity(EmbedderKey("gemini", "gemini-embedding-001"), 2)
+    private val store = mockk<EmbeddingIndexingService>(relaxed = true)
+    private val buildLog = FakeBuildLog()
+    private val activities = mutableListOf<BuildActivity>()
+    private val coordinator: IndexCoordinator
+
+    init {
+        coordinator = IndexCoordinator(
+            store = store,
+            buildLog = buildLog,
+            logger = { null },
+            onIndexChanged = { activities += coordinator.activity },
+            clock = { 1_000L },
+        )
+    }
+
+    /** The first embed call never answers, standing for a slow server mid-build. */
+    private val stalled = CompletableFuture<List<FloatArray>>()
+    private val embedCalls = AtomicInteger()
+    private val backend = mockk<EmbeddingBackend> {
+        every { embed(any()) } answers {
+            val texts = firstArg<List<String>>()
+            if (embedCalls.getAndIncrement() == 0) stalled
+            else CompletableFuture.completedFuture(texts.map { floatArrayOf(1f, 0f) })
+        }
+    }
+
+    private fun givenAProjectWithOneFile(storedModels: List<String> = emptyList()): File {
+        val source = folder.newFile("Main.kt").apply { writeText("fun main() {\n    println(1)\n}\n") }
+        every { store.collectFiles(any()) } returns listOf(source)
+        every { store.languageFor(any()) } returns "kotlin"
+        every { store.countEmbeddings(any(), any()) } returns 0
+        every { store.storedModels(any()) } returns storedModels
+        return folder.root
+    }
+
+    @Test
+    fun givenABuildInFlight_whenCleared_thenNothingIsStoredAndEveryRowIsDeleted() = runBlocking {
+        // AC11: the build is stopped before the delete, so none of its rows outlive the clear.
+        val root = givenAProjectWithOneFile()
+        val build = coordinator.buildIfNeeded("roots", listOf(root), backend, identity)!!
+        verify(timeout = 5_000) { backend.embed(any()) }
+
+        withTimeout(5_000) { coordinator.clearAll().join() }
+
+        assertTrue(build.job.isCancelled)
+        assertTrue(stalled.isCancelled)
+        verify(exactly = 0) { store.storeEmbeddings(any(), any()) }
+        verifyOrder {
+            store.clearIndex("roots")
+            store.clearIndex(null)
+        }
+    }
+
+    @Test
+    fun givenAClearInFlight_whenASearchStartsABuild_thenTheBuildWritesOnlyAfterTheDelete() = runBlocking {
+        val root = givenAProjectWithOneFile()
+        coordinator.buildIfNeeded("roots", listOf(root), backend, identity)
+        verify(timeout = 5_000) { backend.embed(any()) }
+
+        coordinator.clearAll()
+        val rebuild = coordinator.buildIfNeeded("roots", listOf(root), backend, identity)!!
+        withTimeout(5_000) { rebuild.job.join() }
+
+        verifyOrder {
+            store.clearIndex(null)
+            store.storeEmbeddings("roots", any())
+        }
+    }
+
+    @Test
+    fun givenABuild_whenItCompletes_thenProgressWasReportedAndItsTimeRecorded() = runBlocking {
+        val root = givenAProjectWithOneFile()
+        // Answered at once, so the build runs to the end.
+        embedCalls.set(1)
+
+        withTimeout(5_000) {
+            coordinator.buildIfNeeded("roots", listOf(root), backend, identity)!!.job.join()
+        }
+
+        assertEquals(BuildActivity.Building("roots", stored = 0, total = 0), activities.first())
+        assertTrue(activities.any { it is BuildActivity.Building && it.stored > 0 })
+        assertEquals(BuildActivity.Idle, coordinator.activity)
+        assertEquals(mapOf("roots" to 1_000L), buildLog.built)
+    }
+
+    @Test
+    fun givenABackendThatRefuses_whenBuilding_thenTheBuildIsReportedFailedAndNotRecorded() =
+        runBlocking {
+            val root = givenAProjectWithOneFile()
+            stalled.completeExceptionally(IllegalStateException("quota exhausted"))
+
+            withTimeout(5_000) {
+                coordinator.buildIfNeeded("roots", listOf(root), backend, identity)!!.job.join()
+            }
+
+            assertEquals(BuildActivity.Failed("roots"), coordinator.activity)
+            assertTrue(buildLog.built.isEmpty())
+        }
+
+    @Test
+    fun givenAFailedBuild_whenCleared_thenTheFailureAndEveryBuildTimeAreForgotten() = runBlocking {
+        val root = givenAProjectWithOneFile()
+        stalled.completeExceptionally(IllegalStateException("quota exhausted"))
+        withTimeout(5_000) {
+            coordinator.buildIfNeeded("roots", listOf(root), backend, identity)!!.job.join()
+        }
+
+        withTimeout(5_000) { coordinator.clearAll().join() }
+
+        assertEquals(BuildActivity.Idle, coordinator.activity)
+        assertTrue(buildLog.cleared)
+    }
+
+    @Test
+    fun givenRowsOfAnotherModel_whenBuilding_thenTheBuildNamesTheModelItReplaces() {
+        val root = givenAProjectWithOneFile(storedModels = listOf("text-embedding-004"))
+
+        val build = coordinator.buildIfNeeded("roots", listOf(root), backend, identity)!!
+
+        assertEquals("text-embedding-004", build.replacedModel)
+    }
+
+    @Test
+    fun givenNoRowsYet_whenBuilding_thenNothingIsReportedReplaced() {
+        val root = givenAProjectWithOneFile()
+
+        val build = coordinator.buildIfNeeded("roots", listOf(root), backend, identity)!!
+
+        assertNull(build.replacedModel)
+    }
+
+    /** Remembers what the coordinator recorded, in memory. */
+    private class FakeBuildLog : IndexBuildLog {
+        val built = mutableMapOf<String, Long>()
+        var cleared = false
+
+        override fun recordBuilt(rootsKey: String, atMillis: Long) {
+            built[rootsKey] = atMillis
+        }
+
+        override fun lastBuiltUnder(projectRoot: File): Long? = built.values.maxOrNull()
+
+        override fun clear() {
+            built.clear()
+            cleared = true
+        }
+    }
+}
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/PreferencesIndexBuildLogTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/PreferencesIndexBuildLogTest.kt
new file mode 100644
index 00000000..dd00d9ce
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/PreferencesIndexBuildLogTest.kt
@@ -0,0 +1,45 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import android.content.SharedPreferences
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class PreferencesIndexBuildLogTest {
+
+    private val editor = mockk<SharedPreferences.Editor>(relaxed = true)
+    private val stored = mutableMapOf<String, Any?>()
+    private val preferences = mockk<SharedPreferences> {
+        every { all } answers { stored.toMap() }
+        every { edit() } returns editor
+    }
+    private val log = PreferencesIndexBuildLog { preferences }
+
+    @Test
+    fun givenBuildsOfThisProjectAndAnother_whenAsked_thenTheLatestOfThisProjectIsReturned() {
+        stored["built_at:/projects/app"] = 100L
+        stored["built_at:/projects/app/core"] = 300L
+        stored["built_at:/projects/app2"] = 900L
+
+        assertEquals(300L, log.lastBuiltUnder(File("/projects/app")))
+    }
+
+    @Test
+    fun givenNoRecordedBuild_whenAsked_thenThereIsNoTime() {
+        // Rows indexed before this was recorded: the screen says "Not recorded", not a wrong date.
+        assertNull(log.lastBuiltUnder(File("/projects/app")))
+    }
+
+    @Test
+    fun givenABuild_whenRecorded_thenItIsStoredUnderItsRootsKey() {
+        every { editor.putLong(any(), any()) } returns editor
+
+        log.recordBuilt("/projects/app", 42L)
+
+        verify { editor.putLong("built_at:/projects/app", 42L) }
+    }
+}
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/RootsKeyTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/RootsKeyTest.kt
new file mode 100644
index 00000000..650287d5
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/RootsKeyTest.kt
@@ -0,0 +1,35 @@
+package com.itsaky.androidide.plugins.vectorsearch
+
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class RootsKeyTest {
+
+    private val project = File("/projects/app")
+
+    @Test
+    fun givenTheSameRootsInAnyOrder_whenKeyed_thenTheKeyIsTheSame() {
+        val a = File("/projects/app/a")
+        val b = File("/projects/app/b")
+
+        assertEquals(RootsKey.of(listOf(a, b)), RootsKey.of(listOf(b, a)))
+    }
+
+    @Test
+    fun givenRootsWithinTheProject_whenChecked_thenTheyAreUnderIt() {
+        assertTrue(RootsKey.isUnder(RootsKey.of(listOf(project)), project))
+        assertTrue(RootsKey.isUnder(RootsKey.of(listOf(File("/projects/app/core"))), project))
+    }
+
+    @Test
+    fun givenASiblingSharingThePrefix_whenChecked_thenItIsNotUnderTheProject() {
+        // Another project's build must not show as progress on this one's screen.
+        assertFalse(RootsKey.isUnder(RootsKey.of(listOf(File("/projects/app2"))), project))
+        assertFalse(
+            RootsKey.isUnder(RootsKey.of(listOf(project, File("/projects/other"))), project)
+        )
+    }
+}
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/BackendCompatibilityResolverTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/BackendCompatibilityResolverTest.kt
new file mode 100644
index 00000000..a4ea117d
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/BackendCompatibilityResolverTest.kt
@@ -0,0 +1,128 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import com.itsaky.androidide.plugins.services.LlmInferenceService
+import com.itsaky.androidide.plugins.services.LlmInferenceService.ActiveModelReportingBackend
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingBackend
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingModelSelectable
+import com.itsaky.androidide.plugins.services.LlmInferenceService.LlmBackend
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkClass
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class BackendCompatibilityResolverTest {
+
+    @Test
+    fun givenNoService_whenResolving_thenAiCoreIsReportedMissing() {
+        assertEquals(BackendCompatibility.NoService, BackendCompatibilityResolver.resolve(null))
+    }
+
+    @Test
+    fun givenNoStoredSelection_whenResolving_thenNoSelectionIsReported() {
+        val resolution = BackendCompatibilityResolver.resolve(service(selected = null))
+
+        assertEquals(BackendCompatibility.NoSelection, resolution)
+    }
+
+    @Test
+    fun givenTheSelectedBackendIsNotRegistered_whenResolving_thenItIsReportedNotInstalled() {
+        val resolution = BackendCompatibilityResolver.resolve(service(selected = "gemini"))
+
+        assertEquals(BackendCompatibility.NotInstalled("gemini"), resolution)
+    }
+
+    @Test
+    fun givenABackendThatDoesNotEmbed_whenResolving_thenItIsNotSupported() {
+        // Local, or a Gemini plugin from before embeddings: the case whose fix is update or switch.
+        val backend = mockk<LlmBackend> { every { name } returns "Local LLM" }
+
+        val selected = selected(service(selected = "local", backend = backend))
+
+        assertEquals(EmbeddingSupport.None, selected.support)
+        assertEquals("Local LLM", selected.backendName)
+    }
+
+    @Test
+    fun givenAnEmbeddingBackendThatIsNotSelectable_whenResolving_thenItIsNotSupported() {
+        // AC4: a plugin too old to list and set its model is "Not supported", even though it embeds.
+        val backend = mockk<EmbeddingBackend> {
+            every { name } returns "Gemini API"
+            every { embeddingModelId } returns "gemini-embedding-001"
+        }
+
+        val selected = selected(service(selected = "gemini", backend = backend))
+
+        assertEquals(EmbeddingSupport.None, selected.support)
+    }
+
+    @Test
+    fun givenASelectableEmbeddingBackend_whenResolving_thenTheScreenMayPickItsModel() {
+        val backend = mockk<EmbeddingModelSelectable> {
+            every { name } returns "OpenAI"
+            every { embeddingModelId } returns " text-embedding-3-small "
+        }
+
+        val selected = selected(service(selected = "openai", backend = backend))
+
+        assertEquals(
+            EmbeddingSupport.Selectable(backend, "text-embedding-3-small"),
+            selected.support,
+        )
+    }
+
+    @Test
+    fun givenABackendThatNamesNoEmbeddingModel_whenResolving_thenItIsNotSupported() {
+        // Nothing can be embedded without a model, whatever interfaces the backend carries.
+        val backend = mockk<EmbeddingModelSelectable> {
+            every { name } returns "OpenAI"
+            every { embeddingModelId } returns " "
+        }
+
+        val selected = selected(service(selected = "openai", backend = backend))
+
+        assertEquals(EmbeddingSupport.None, selected.support)
+    }
+
+    @Test
+    fun givenABackendReportingItsChatModel_whenResolving_thenTheChatModelIsShown() {
+        val backend = mockkClass(
+            EmbeddingModelSelectable::class,
+            moreInterfaces = arrayOf(ActiveModelReportingBackend::class),
+        )
+        every { backend.name } returns "Gemini API"
+        every { backend.embeddingModelId } returns "gemini-embedding-001"
+        every { (backend as ActiveModelReportingBackend).activeModelName } returns "gemini-2.5-flash"
+
+        val selected = selected(service(selected = "gemini", backend = backend))
+
+        assertEquals("gemini-2.5-flash", selected.chatModel)
+    }
+
+    @Test
+    fun givenABackendWhoseAccessorsThrow_whenResolving_thenItsIdStandsInForItsName() {
+        // Another plugin's code; a throwing accessor must cost one line, not the Preferences screen.
+        val backend = mockk<EmbeddingModelSelectable> {
+            every { name } throws IllegalStateException("wedged")
+            every { embeddingModelId } throws IllegalStateException("wedged")
+        }
+
+        val selected = selected(service(selected = "gemini", backend = backend))
+
+        assertEquals("gemini", selected.backendName)
+        assertNull(selected.chatModel)
+        assertEquals(EmbeddingSupport.None, selected.support)
+    }
+
+    /** Resolves [service], which the test set up to have a registered selection. */
+    private fun selected(service: LlmInferenceService) =
+        BackendCompatibilityResolver.resolve(service) as BackendCompatibility.Selected
+
+    /** An inference service answering with [selected] and [backend], and nothing else. */
+    private fun service(selected: String?, backend: LlmBackend? = null) =
+        mockk<LlmInferenceService> {
+            every { preferredBackendId } returns selected
+            every { getBackend(any()) } returns backend
+        }
+}
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/IndexHealthTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/IndexHealthTest.kt
new file mode 100644
index 00000000..dbbc8f92
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/IndexHealthTest.kt
@@ -0,0 +1,71 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingModelSelectable
+import com.itsaky.androidide.plugins.vectorsearch.IndexedEmbedder
+import io.mockk.mockk
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class IndexHealthTest {
+
+    private val selectedGemini = BackendCompatibility.Selected(
+        backendId = "gemini",
+        backendName = "Gemini API",
+        chatModel = null,
+        support = EmbeddingSupport.Selectable(mockk<EmbeddingModelSelectable>(), "gemini-embedding-001"),
+    )
+
+    @Test
+    fun givenRowsFromTheSelectedModel_whenRead_thenTheIndexIsUpToDate() {
+        val status = indexed(IndexedEmbedder("gemini", "gemini-embedding-001", 3072, 40))
+
+        assertEquals(IndexHealth.UP_TO_DATE, IndexHealth.of(status, selectedGemini))
+    }
+
+    @Test
+    fun givenRowsFromAnotherModel_whenRead_thenTheIndexIsOutOfDate() {
+        // AC2 on the screen: the next search rebuilds, and the user sees so before searching.
+        val status = indexed(IndexedEmbedder("gemini", "text-embedding-004", 768, 40))
+
+        assertEquals(IndexHealth.OUT_OF_DATE, IndexHealth.of(status, selectedGemini))
+    }
+
+    @Test
+    fun givenAHalfRebuiltIndex_whenRead_thenItIsStillOutOfDate() {
+        val status = indexed(
+            IndexedEmbedder("gemini", "gemini-embedding-001", 3072, 30),
+            IndexedEmbedder("gemini", "text-embedding-004", 768, 10),
+        )
+
+        assertEquals(IndexHealth.OUT_OF_DATE, IndexHealth.of(status, selectedGemini))
+    }
+
+    @Test
+    fun givenABackendThatIsNotSupported_whenRead_thenFreshnessIsNotClaimed() {
+        val local = selectedGemini.copy(backendId = "local", support = EmbeddingSupport.None)
+        val status = indexed(IndexedEmbedder("gemini", "gemini-embedding-001", 3072, 40))
+
+        assertEquals(IndexHealth.INDEXED, IndexHealth.of(status, local))
+    }
+
+    @Test
+    fun givenEachNonIndexedStatus_whenRead_thenItLeadsWithItsOwnState() {
+        assertEquals(IndexHealth.NO_PROJECT, IndexHealth.of(IndexStatus.NoProject, selectedGemini))
+        assertEquals(IndexHealth.NOT_INDEXED, IndexHealth.of(IndexStatus.NotIndexed, selectedGemini))
+        assertEquals(IndexHealth.INDEXING, IndexHealth.of(IndexStatus.Building(1, 2), selectedGemini))
+        assertEquals(IndexHealth.BUILD_FAILED, IndexHealth.of(IndexStatus.BuildFailed, selectedGemini))
+    }
+
+    @Test
+    fun givenRowsFromTwoModels_whenCounted_thenTheCountCoversBoth() {
+        val status = indexed(
+            IndexedEmbedder("openai", "text-embedding-3-small", 1536, 40),
+            IndexedEmbedder("openai", "text-embedding-3-large", 3072, 2),
+        )
+
+        assertEquals(42, status.chunkCount)
+    }
+
+    private fun indexed(vararg embedders: IndexedEmbedder) =
+        IndexStatus.Indexed(embedders.toList(), fileCount = 3, lastBuiltAt = null)
+}
diff --git a/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsViewModelTest.kt b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsViewModelTest.kt
new file mode 100644
index 00000000..5f754906
--- /dev/null
+++ b/plugins/Vector-Search/src/test/kotlin/com/itsaky/androidide/plugins/vectorsearch/settings/SemanticSearchSettingsViewModelTest.kt
@@ -0,0 +1,194 @@
+package com.itsaky.androidide.plugins.vectorsearch.settings
+
+import com.itsaky.androidide.plugins.PluginLogger
+import com.itsaky.androidide.plugins.services.LlmInferenceService
+import com.itsaky.androidide.plugins.services.LlmInferenceService.EmbeddingModelSelectable
+import com.itsaky.androidide.plugins.services.LlmInferenceService.LlmBackend
+import com.itsaky.androidide.plugins.vectorsearch.IndexedEmbedder
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import java.io.IOException
+import java.util.concurrent.CompletableFuture
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SemanticSearchSettingsViewModelTest {
+
+    private val dispatcher = UnconfinedTestDispatcher()
+
+    @Before
+    fun setUp() {
+        // viewModelScope runs on Dispatchers.Main.
+        Dispatchers.setMain(dispatcher)
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    @Test
+    fun givenTheServerChangedUnderTheSameBackend_whenItReportsAChange_thenItsModelsAreListedAgain() {
+        // A new OpenAI server or Gemini key keeps the backend id but changes what it can embed with.
+        val backend = selectable(lists = listOf(listOf("old-model"), listOf("new-model")))
+        val source = FakeSource(serviceSelecting(backend))
+        val viewModel = viewModel(source)
+        assertEquals(ModelOptions.Loaded("gemini", listOf("old-model")), viewModel.state.value.models)
+
+        source.backendChanges.value = 1
+
+        assertEquals(ModelOptions.Loaded("gemini", listOf("new-model")), viewModel.state.value.models)
+    }
+
+    @Test
+    fun givenModelsOfAnotherBackend_whenTheSelectionHasMoved_thenTheyAreNotOffered() {
+        val state = SemanticSearchState(
+            compatibility = BackendCompatibility.Selected(
+                "openai", "OpenAI", chatModel = null, support = EmbeddingSupport.None,
+            ),
+            models = ModelOptions.Loaded("gemini", listOf("gemini-embedding-001")),
+        )
+
+        assertEquals(ModelOptions.None, state.selectedModels)
+    }
+
+    @Test
+    fun givenTheListingFails_whenLoading_thenTheBackendsOwnReasonIsKept() {
+        val backend = selectable(failure = IOException("No Gemini API key is saved."))
+        val viewModel = viewModel(FakeSource(serviceSelecting(backend)))
+
+        assertEquals(
+            ModelOptions.Failed("gemini", "No Gemini API key is saved."),
+            viewModel.state.value.models,
+        )
+    }
+
+    @Test
+    fun givenAPick_whenTheBackendReportsIt_thenTheModelIsStoredAndTheRebuildStaysAnnounced() {
+        val backend = selectable(lists = listOf(listOf("a", "b")))
+        val source = FakeSource(serviceSelecting(backend))
+        val viewModel = viewModel(source)
+
+        viewModel.selectModel("b")
+        source.backendChanges.value = 1
+
+        verify { backend.setEmbeddingModelId("b") }
+        assertEquals("b", viewModel.state.value.pickedModel)
+    }
+
+    @Test
+    fun givenABackendThatIsNotSelectable_whenRead_thenNothingIsListed() {
+        val backend = mockk<LlmBackend>(relaxed = true) { every { name } returns "Local LLM" }
+        val viewModel = viewModel(FakeSource(serviceSelecting(backend, id = "local")))
+
+        assertEquals(ModelOptions.None, viewModel.state.value.models)
+    }
+
+    @Test
+    fun givenAConfirmedClear_whenItCompletes_thenTheIndexReadsNotIndexed() {
+        val source = FakeSource(service = null).apply {
+            status = IndexStatus.Indexed(
+                listOf(IndexedEmbedder("gemini", "m", 768, 3)), fileCount = 1, lastBuiltAt = null,
+            )
+            holdsAnything = true
+        }
+        val viewModel = viewModel(source)
+
+        viewModel.clearIndex()
+
+        assertEquals(1, source.clears)
+        assertEquals(IndexStatus.NotIndexed, viewModel.state.value.indexStatus)
+        assertFalse(viewModel.state.value.clearing)
+        assertFalse(viewModel.state.value.canClear)
+    }
+
+    @Test
+    fun givenABuildRunning_whenRead_thenItCanBeClearedEvenWithNoRowsYet() {
+        // Clearing stops the build, so there is something to do before a single row is stored.
+        val source = FakeSource(service = null).apply { status = IndexStatus.Building(0, 0) }
+
+        val viewModel = viewModel(source)
+
+        assertTrue(viewModel.state.value.canClear)
+    }
+
+    @Test
+    fun givenNoPluginAtCreation_whenItLoadsAndTheScreenRefreshes_thenItsIndexChangesAreWatched() {
+        var live: FakeSource? = null
+        val viewModel = SemanticSearchSettingsViewModel({ live }, ioDispatcher = dispatcher)
+        val source = FakeSource(service = null).also { live = it }
+
+        viewModel.refresh()
+        source.status = IndexStatus.Building(0, 0)
+        source.indexChanges.value = 1
+
+        assertEquals(IndexStatus.Building(0, 0), viewModel.state.value.indexStatus)
+    }
+
+    private fun viewModel(source: FakeSource) =
+        SemanticSearchSettingsViewModel({ source }, ioDispatcher = dispatcher)
+
+    /** A selectable backend whose model follows its setter, listing [lists] in turn. */
+    private fun selectable(
+        lists: List<List<String>> = emptyList(),
+        failure: Exception? = null,
+    ): EmbeddingModelSelectable {
+        var current = "a"
+        var call = 0
+        return mockk(relaxed = true) {
+            every { name } returns "Gemini API"
+            every { embeddingModelId } answers { current }
+            every { setEmbeddingModelId(any()) } answers { current = firstArg() }
+            every { listEmbeddingModels() } answers {
+                if (failure != null) {
+                    CompletableFuture<List<String>>().apply { completeExceptionally(failure) }
+                } else {
+                    CompletableFuture.completedFuture(lists[minOf(call++, lists.lastIndex)])
+                }
+            }
+        }
+    }
+
+    private fun serviceSelecting(backend: LlmBackend, id: String = "gemini") =
+        mockk<LlmInferenceService> {
+            every { preferredBackendId } returns id
+            every { getBackend(id) } returns backend
+        }
+
+    /** A [SemanticSearchSource] the test drives by hand. */
+    private class FakeSource(private val service: LlmInferenceService?) : SemanticSearchSource {
+        override val backendChanges = MutableStateFlow(0L)
+        override val indexChanges = MutableStateFlow(0L)
+        var status: IndexStatus = IndexStatus.NotIndexed
+        var holdsAnything = false
+        var clears = 0
+
+        override fun inferenceService(): LlmInferenceService? = service
+
+        override fun indexStatus(): IndexStatus = status
+
+        override fun indexHoldsAnything(): Boolean = holdsAnything
+
+        override fun clearIndex(): Job {
+            clears++
+            status = IndexStatus.NotIndexed
+            holdsAnything = false
+            return Job().apply { complete() }
+        }
+
+        override fun logger(): PluginLogger? = null
+    }
+}
diff --git a/plugins/Vector-Search/vector-search.html b/plugins/Vector-Search/vector-search.html
index a7df5638..400523f8 100644
--- a/plugins/Vector-Search/vector-search.html
+++ b/plugins/Vector-Search/vector-search.html
@@ -64,14 +64,22 @@ <h2>Core functionality</h2>
       changing either builds the index again.</li>
     <li><b>Cosine-similarity ranking</b> with a relevance cutoff so only strong
       matches are returned.</li>
+    <li><b>Semantic Search settings screen</b> &mdash; in Preferences &rarr;
+      Configuration: shows the selected backend and whether it supports Vector
+      Search (with how to fix it if not), picks the embedding model, says where
+      the code is sent, reports what is indexed, and clears the index after
+      confirmation.</li>
   </ul>
 
   <h2>Technical architecture</h2>
   <table>
     <tr><th>Component</th><th>Role</th></tr>
     <tr><td><code>VectorSearchPlugin</code></td><td>Entry point. Implements
-      <code>ProjectSearchExtension</code>; runs indexing on a background scope and
-      answers search requests.</td></tr>
+      <code>ProjectSearchExtension</code> and answers search requests, asking
+      <code>IndexCoordinator</code> for an index build when one is needed.</td></tr>
+    <tr><td><code>IndexCoordinator</code></td><td>Builds, reuses and clears the
+      index on a background scope, one operation at a time, so a clear never
+      leaves a partial index behind.</td></tr>
     <tr><td><code>EmbedderResolver</code></td><td>Resolves the selected backend to
       an <code>EmbeddingBackend</code>, or says which of the reasons it could
       not.</td></tr>
@@ -86,6 +94,11 @@ <h2>Technical architecture</h2>
       can answer the query, or has to be built again.</td></tr>
     <tr><td><code>VectorMath</code> / <code>VectorSearchService</code></td><td>Cosine
       similarity and top-K ranking of stored embeddings against the query.</td></tr>
+    <tr><td><code>SemanticSearchSettingsFragment</code></td><td>The settings screen,
+      contributed through <code>SettingsExtension</code>. Lists and sets the model
+      through the backend's <code>EmbeddingModelSelectable</code>.</td></tr>
+    <tr><td><code>BackendWatch</code></td><td>Listens for backend changes on AI
+      Core's inference service, so the screen updates without reopening.</td></tr>
   </table>
   <p>Embeddings are requested through <b>AI Core</b>'s inference service over the
   shared service registry; the plugin contains no model, no HTTP client and no
@@ -98,6 +111,9 @@ <h2>Usage</h2>
       a key.</li>
     <li>Install <b>Vector Search</b> via the Plugin Manager and restart the
       IDE.</li>
+    <li>Optionally open <b>Preferences &rarr; Configuration &rarr; Semantic
+      Search</b> to check the backend is supported and choose its embedding
+      model.</li>
     <li>Use the IDE's <b>project search</b>. Semantic matches appear under a
       <b>"Semantic Results"</b> section. The first search on a project triggers a
       background index build.</li>