diff --git a/fluxtuner/core/discovery_execution.py b/fluxtuner/core/discovery_execution.py
new file mode 100644
index 0000000..a30f977
--- /dev/null
+++ b/fluxtuner/core/discovery_execution.py
@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+"""Execute desktop discovery with a worker-owned, read-only local connection."""
+
+from __future__ import annotations
+
+import sqlite3
+from contextlib import closing
+from pathlib import Path
+
+from fluxtuner.core import db
+from fluxtuner.core.search_service import SearchRequest, SearchResult, SearchService
+from fluxtuner.players.capabilities import PlayerCapabilities
+
+
+def search_desktop_stations(
+    request: SearchRequest,
+    *,
+    profile_name: str | None = None,
+    capabilities: PlayerCapabilities | None = None,
+    db_path: Path | None = None,
+) -> SearchResult:
+    """Search without creating profiles or sharing SQLite connections across threads."""
+    if request.source == "radio-browser":
+        return SearchService(capabilities=capabilities).search(request)
+
+    if request.source not in ("local", "all"):
+        raise ValueError("Unknown station discovery source.")
+
+    name = db.DEFAULT_PROFILE_NAME if profile_name is None else profile_name.strip()
+    if not name:
+        raise ValueError("An existing profile is required.")
+
+    path = db.DB_FILE if db_path is None else db_path
+    uri = path.resolve().as_uri() + "?mode=ro"
+
+    with closing(sqlite3.connect(uri, uri=True)) as conn:
+        conn.row_factory = sqlite3.Row
+        profile = conn.execute(
+            """
+            SELECT p.id
+            FROM profiles AS p
+            JOIN users AS u ON u.id = p.user_id
+            WHERE lower(u.username) = lower(?)
+              AND lower(p.name) = lower(?)
+            """,
+            (db.DEFAULT_USER_NAME, name),
+        ).fetchone()
+        if profile is None:
+            raise ValueError("The current profile is unavailable.")
+
+        service = SearchService(
+            capabilities=capabilities,
+            local_connection=conn,
+            profile_id=int(profile["id"]),
+        )
+        return service.search(request)
diff --git a/fluxtuner/gui/window.py b/fluxtuner/gui/window.py
index db63897..3602528 100644
--- a/fluxtuner/gui/window.py
+++ b/fluxtuner/gui/window.py
@@ -7,7 +7,7 @@
 from contextlib import suppress
 from pathlib import Path
 from time import monotonic
-from typing import Any
+from typing import Any, Literal
 from uuid import uuid4
 
 import gi
@@ -30,6 +30,7 @@
 )
 from fluxtuner.core.custom_stations import add_custom_station  # noqa: E402
 from fluxtuner.core.data_usage import DataUsageTracker, format_usage_line  # noqa: E402
+from fluxtuner.core.discovery_execution import search_desktop_stations  # noqa: E402
 from fluxtuner.core.favorites import (  # noqa: E402
     add_favorite,
     all_favorite_tags,
@@ -358,6 +359,14 @@ def _build_search_bar(self, root: Gtk.Box) -> None:
         self.min_bitrate_entry.connect("activate", self.on_search_clicked)
         search_bar.append(self.min_bitrate_entry)
 
+        self.search_source_dropdown = Gtk.DropDown.new_from_strings(
+            ["Radio Browser", "Local", "All"]
+        )
+        self.search_source_dropdown.set_selected(0)
+        self.search_source_dropdown.set_tooltip_text("Station discovery source")
+        search_bar.append(self.search_source_dropdown)
+        self.search_source_dropdown.connect("notify::selected", self._on_search_source_changed)
+
         search_button = Gtk.Button(label="Search")
         search_button.connect("clicked", self.on_search_clicked)
         search_bar.append(search_button)
@@ -1354,25 +1363,56 @@ def _set_view_status(
         station_word = "station" if count == 1 else "stations"
         self.status_label.set_text(f"{view_name}{suffix} · {count} {station_word}")
 
+    def _selected_search_source(self) -> Literal["radio-browser", "local", "all"]:
+        sources: tuple[Literal["radio-browser", "local", "all"], ...] = (
+            "radio-browser",
+            "local",
+            "all",
+        )
+        selected = self.search_source_dropdown.get_selected()
+        if selected >= len(sources):
+            raise ValueError("Unknown station discovery source.")
+        return sources[selected]
+
+    def _on_search_source_changed(self, _dropdown: Gtk.DropDown, _param: object) -> None:
+        self._search_lifecycle.invalidate()
+        self._view_state.show_search()
+        self.last_search_results = []
+        self.stations = []
+        self.selected_station = None
+        self._render_results()
+        self._update_playlist_status()
+        self._set_view_status("Search results", 0)
+
     def on_search_clicked(self, _widget: Gtk.Widget) -> None:
         query = self.search_entry.get_text().strip()
         country = self.country_entry.get_text().strip() or None
         min_bitrate_text = self.min_bitrate_entry.get_text().strip()
         min_bitrate = int(min_bitrate_text) if min_bitrate_text.isdigit() else None
 
+        source = self._selected_search_source()
+        profile_name = self.profile_name
+        capabilities = self.player_capabilities
         generation = self._search_lifecycle.begin()
         self.status_label.set_text("Searching…")
 
         def worker() -> None:
             try:
-                result = self.search_service.search(
-                    SearchRequest(
-                        query=query,
-                        country=country,
-                        min_bitrate=min_bitrate,
-                        limit=50,
-                    )
+                request = SearchRequest(
+                    query=query,
+                    country=country,
+                    min_bitrate=min_bitrate,
+                    limit=50,
+                    source=source,
                 )
+                if source == "radio-browser":
+                    result = self.search_service.search(request)
+                else:
+                    result = search_desktop_stations(
+                        request,
+                        profile_name=profile_name,
+                        capabilities=capabilities,
+                    )
                 stations = result.stations
             except Exception as exc:  # noqa: BLE001 - user-facing status in GTK GUI.
                 GLib.idle_add(self._search_failed, generation, str(exc))
diff --git a/fluxtuner/themes/amber.tcss b/fluxtuner/themes/amber.tcss
index 0986a34..16ac0e7 100644
--- a/fluxtuner/themes/amber.tcss
+++ b/fluxtuner/themes/amber.tcss
@@ -67,6 +67,17 @@ Footer .footer--highlight {
     color: #f5e6c8;
 }
 
+#source-filter > SelectCurrent {
+    border: round #e3b241;
+    background: #111111;
+    color: #f5e6c8;
+}
+
+#source-filter:focus > SelectCurrent {
+    border: heavy #e3b241;
+}
+
+
 .filter-label {
     width: 10;
     content-align: right middle;
diff --git a/fluxtuner/themes/default.tcss b/fluxtuner/themes/default.tcss
index b778fed..95a3251 100644
--- a/fluxtuner/themes/default.tcss
+++ b/fluxtuner/themes/default.tcss
@@ -67,6 +67,17 @@ Footer .footer--highlight {
     color: #e5e7eb;
 }
 
+#source-filter > SelectCurrent {
+    border: round #60a5fa;
+    background: #0f172a;
+    color: #e5e7eb;
+}
+
+#source-filter:focus > SelectCurrent {
+    border: heavy #60a5fa;
+}
+
+
 .filter-label {
     width: 10;
     content-align: right middle;
diff --git a/fluxtuner/themes/dracula.tcss b/fluxtuner/themes/dracula.tcss
index f657423..ffc8cc7 100644
--- a/fluxtuner/themes/dracula.tcss
+++ b/fluxtuner/themes/dracula.tcss
@@ -67,6 +67,17 @@ Footer .footer--highlight {
     color: #f8f8f2;
 }
 
+#source-filter > SelectCurrent {
+    border: round #bd93f9;
+    background: #282a36;
+    color: #f8f8f2;
+}
+
+#source-filter:focus > SelectCurrent {
+    border: heavy #bd93f9;
+}
+
+
 .filter-label {
     width: 10;
     content-align: right middle;
diff --git a/fluxtuner/themes/fluxtuner.tcss b/fluxtuner/themes/fluxtuner.tcss
index fa315e0..2ee3903 100644
--- a/fluxtuner/themes/fluxtuner.tcss
+++ b/fluxtuner/themes/fluxtuner.tcss
@@ -68,6 +68,17 @@ Footer .footer--highlight {
     color: #f4f7fb;
 }
 
+#source-filter > SelectCurrent {
+    border: round #6ee7d8;
+    background: #090d14;
+    color: #f4f7fb;
+}
+
+#source-filter:focus > SelectCurrent {
+    border: heavy #6ee7d8;
+}
+
+
 .filter-label {
     width: 10;
     content-align: right middle;
diff --git a/fluxtuner/themes/nord.tcss b/fluxtuner/themes/nord.tcss
index ab3f879..d30418f 100644
--- a/fluxtuner/themes/nord.tcss
+++ b/fluxtuner/themes/nord.tcss
@@ -67,6 +67,17 @@ Footer .footer--highlight {
     color: #eceff4;
 }
 
+#source-filter > SelectCurrent {
+    border: round #88c0d0;
+    background: #2e3440;
+    color: #eceff4;
+}
+
+#source-filter:focus > SelectCurrent {
+    border: heavy #88c0d0;
+}
+
+
 .filter-label {
     width: 10;
     content-align: right middle;
diff --git a/fluxtuner/themes/ptmtrx.tcss b/fluxtuner/themes/ptmtrx.tcss
index bbcb87e..8d8fb2c 100644
--- a/fluxtuner/themes/ptmtrx.tcss
+++ b/fluxtuner/themes/ptmtrx.tcss
@@ -67,6 +67,17 @@ Footer .footer--highlight {
     color: #F8F8F2;
 }
 
+#source-filter > SelectCurrent {
+    border: round #58d68d;
+    background: #1B1D1E;
+    color: #F8F8F2;
+}
+
+#source-filter:focus > SelectCurrent {
+    border: heavy #58d68d;
+}
+
+
 .filter-label {
     width: 10;
     content-align: right middle;
diff --git a/fluxtuner/tui.py b/fluxtuner/tui.py
index 38143b0..f7475f0 100644
--- a/fluxtuner/tui.py
+++ b/fluxtuner/tui.py
@@ -6,14 +6,14 @@
 import time
 from contextlib import suppress
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 from textual import on
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.screen import ModalScreen
-from textual.widgets import Button, DataTable, Footer, Header, Input, Label, Static
+from textual.widgets import Button, DataTable, Footer, Header, Input, Label, Select, Static
 
 from fluxtuner.config import get_playback_state, save_playback_state, set_config_value
 from fluxtuner.core import db
@@ -22,6 +22,7 @@
     station_is_supported,
 )
 from fluxtuner.core.data_usage import DataUsageTracker, format_usage_line
+from fluxtuner.core.discovery_execution import search_desktop_stations
 from fluxtuner.core.favorites import (
     add_favorite,
     all_favorite_tags,
@@ -172,6 +173,13 @@ def close_from_button(self) -> None:
 class FluxTunerTUI(App[None]):
     """Textual application for FluxTuner."""
 
+    CSS = """
+    #source-filter {
+        width: 22;
+        height: 3;
+    }
+    """
+
     BINDINGS = [
         Binding("space", "play_stop", "Play/Stop"),
         Binding("/", "focus_search", "Search"),
@@ -233,6 +241,7 @@ def __init__(self, theme: str | None = None, player_name: str = "mpv") -> None:
         self.restored_muted: bool = False
         self.view_mode = "search"
         self._search_task: asyncio.Task[None] | None = None
+        self._search_generation = 0
         self.pending_input_action: str | None = None
         self.favorite_tag_filter: str | None = None
         self.table_items: dict[str, tuple[str, Any]] = {}
@@ -253,6 +262,17 @@ def compose(self) -> ComposeResult:
             yield Input(placeholder="optional", id="country-filter")
             yield Label("Min kbps", classes="filter-label")
             yield Input(placeholder="0", id="bitrate-filter")
+            yield Label("Source", classes="filter-label")
+            yield Select(
+                [
+                    ("Radio Browser", "radio-browser"),
+                    ("Local", "local"),
+                    ("All sources", "all"),
+                ],
+                value="radio-browser",
+                allow_blank=False,
+                id="source-filter",
+            )
             yield Button(
                 "Clear filters", id="clear-filters", classes="toolbar-button secondary-button"
             )
@@ -566,6 +586,27 @@ def live_search_from_input(self, event: Input.Changed) -> None:
             return
         self.schedule_live_search(event.value)
 
+    def _selected_discovery_source(
+        self,
+    ) -> Literal["radio-browser", "local", "all"]:
+        selected = self.query_one("#source-filter", Select).value
+        if selected == "radio-browser":
+            return "radio-browser"
+        if selected == "local":
+            return "local"
+        if selected == "all":
+            return "all"
+        raise ValueError("Unknown station discovery source.")
+
+    @on(Select.Changed, "#source-filter")
+    def discovery_source_changed(self, _event: Select.Changed) -> None:
+        self.cancel_pending_search()
+        self._set_view_mode("search")
+        self.query_one("#stations", DataTable).clear(columns=True)
+        self._clear_station_view_selection()
+        self.update_mode_title("Search results")
+        self.set_status("Discovery source changed. Search to refresh results.")
+
     @on(Input.Submitted, "#country-filter")
     async def search_from_country_filter(self, _event: Input.Submitted) -> None:
         self.cancel_pending_search()
@@ -649,6 +690,8 @@ def _clear_view_selection(self) -> None:
         self.selected_playlist = None
 
     def _set_view_mode(self, mode: str) -> None:
+        if mode != "search":
+            self.cancel_pending_search()
         self.view_mode = mode
 
     def _clear_station_view_selection(self) -> None:
@@ -657,11 +700,11 @@ def _clear_station_view_selection(self) -> None:
         self.update_details(None)
 
     def _enter_playlists_view(self) -> None:
-        self.view_mode = "playlists"
+        self._set_view_mode("playlists")
         self.active_playlist_name = None
 
     def _enter_playlist_stations_view(self, playlist_name: str) -> None:
-        self.view_mode = "playlist_stations"
+        self._set_view_mode("playlist_stations")
         self.active_playlist_name = playlist_name
 
     def _clear_playlist_station_selection(self, playlist_name: str) -> None:
@@ -672,7 +715,7 @@ def _clear_playlist_station_selection(self, playlist_name: str) -> None:
         self.update_details(None)
 
     def _enter_themes_view(self) -> None:
-        self.view_mode = "themes"
+        self._set_view_mode("themes")
 
     def _clear_theme_selection(self) -> None:
         self.selected_station = None
@@ -755,6 +798,7 @@ def item_selected(self, event: DataTable.RowSelected) -> None:
             self.smart_play_selected_playlist_or_tag()
 
     def cancel_pending_search(self) -> None:
+        self._search_generation = getattr(self, "_search_generation", 0) + 1
         if self._search_task and not self._search_task.done():
             self._search_task.cancel()
         self._search_task = None
@@ -794,6 +838,8 @@ async def search(self, query: str, live: bool = False) -> None:
             self.set_status("Type a station name/genre, or use country/min kbps filters.")
             return
 
+        self._search_generation = getattr(self, "_search_generation", 0) + 1
+        generation = self._search_generation
         self._set_view_mode("search")
         self._search_task = None
         self.update_mode_title("Search results")
@@ -810,22 +856,36 @@ async def search(self, query: str, live: bool = False) -> None:
                 except ValueError:
                     self.set_status("Min kbps must be a number.")
                     return
-            result = await asyncio.to_thread(
-                self.search_service.search,
-                SearchRequest(
-                    query=query,
-                    country=country or None,
-                    min_bitrate=min_bitrate,
-                    limit=50,
-                ),
+            source = self._selected_discovery_source()
+            request = SearchRequest(
+                query=query,
+                country=country or None,
+                min_bitrate=min_bitrate,
+                limit=50,
+                source=source,
             )
+            if source == "radio-browser":
+                result = await asyncio.to_thread(self.search_service.search, request)
+            else:
+                result = await asyncio.to_thread(
+                    search_desktop_stations,
+                    request,
+                    profile_name=self.profile_name,
+                    capabilities=self.player_capabilities,
+                )
+            if generation != self._search_generation or self.view_mode != "search":
+                return
             stations = result.stations
         except Exception as exc:  # noqa: BLE001
+            if generation != self._search_generation or self.view_mode != "search":
+                return
             self.set_status(f"Search failed: {exc}")
             self.notify(f"Search failed: {exc}", severity="error")
             return
 
         await self.populate_station_list(stations)
+        if generation != self._search_generation or self.view_mode != "search":
+            return
         if not live:
             self.query_one("#stations", DataTable).focus()
         filters = []
@@ -1563,7 +1623,7 @@ def prepare_favorite_tags_edit(self) -> None:
         )
 
     def prepare_favorites_tag_filter(self) -> None:
-        self.view_mode = "favorites"
+        self._set_view_mode("favorites")
         query = self.query_one("#query", Input)
         query.value = self.favorite_tag_filter or ""
         query.focus()
diff --git a/fluxtuner/web/library.py b/fluxtuner/web/library.py
index 40adf6f..c22fca0 100644
--- a/fluxtuner/web/library.py
+++ b/fluxtuner/web/library.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Literal
 
 from fluxtuner.core import db
 from fluxtuner.core.api import search_stations_filtered_debug
@@ -18,6 +18,7 @@
     remove_station_from_playlist,
 )
 from fluxtuner.core.profiles import get_profile_by_name
+from fluxtuner.core.search_service import SearchRequest, SearchService
 from fluxtuner.web.payloads import station_payload
 
 SEARCH_STATUS_OK = "ok"
@@ -45,21 +46,75 @@ def search_payload(
     min_bitrate: int,
     limit: int,
     debug: bool = False,
+    source: Literal["radio-browser", "local", "all"] = "radio-browser",
+    user_id: int | None = None,
+    profile_name: str | None = None,
 ) -> dict[str, Any]:
     normalized_query = query.strip()
     country_filter = country.strip() or None
     bitrate_filter = min_bitrate if min_bitrate > 0 else None
 
-    stations, debug_info = search_stations_filtered_debug(
-        query=normalized_query,
-        country=country_filter,
-        min_bitrate=bitrate_filter,
-        limit=limit,
-        use_cache=not debug,
-    )
+    if source == "radio-browser":
+        # Preserve the existing remote search API and diagnostic contract.
+        stations, debug_info = search_stations_filtered_debug(
+            query=normalized_query,
+            country=country_filter,
+            min_bitrate=bitrate_filter,
+            limit=limit,
+            use_cache=not debug,
+        )
+        status = _aggregate_search_status(debug_info)
+    else:
+        if source not in ("local", "all"):
+            raise ValueError("Unknown station discovery source.")
+        if user_id is None:
+            raise ValueError("Authenticated user is required.")
+
+        requested_profile = db.DEFAULT_PROFILE_NAME if profile_name is None else profile_name
+        if not requested_profile:
+            raise ValueError("The requested profile is unavailable.")
+
+        # Only the authenticated Web user's profile is eligible for discovery.
+        # Never use the desktop user or create profiles during search.
+        with db.connect() as conn:
+            profile = get_profile_by_name(conn, requested_profile, user_id=user_id)
+            if profile is None:
+                raise ValueError("The requested profile is unavailable.")
+
+            result = SearchService(
+                local_connection=conn,
+                profile_id=int(profile["id"]),
+            ).search(
+                SearchRequest(
+                    query=normalized_query,
+                    country=country_filter,
+                    min_bitrate=bitrate_filter,
+                    limit=limit,
+                    use_cache=not debug,
+                    source=source,
+                )
+            )
+
+        stations = result.stations
+        if source == "local":
+            status = SEARCH_STATUS_OK
+        elif result.remote_status == "error":
+            status = SEARCH_STATUS_PARTIAL if stations else SEARCH_STATUS_UNAVAILABLE
+        elif result.remote_status == "partial_error":
+            status = SEARCH_STATUS_PARTIAL
+        else:
+            status = SEARCH_STATUS_OK
+
+        debug_info = {
+            "source": source,
+            "total_found": result.total_found,
+            "unsupported_count": result.unsupported_count,
+            "remote_status": result.remote_status,
+            "source_observations": result.source_observations,
+        }
 
     payload = {
-        "status": _aggregate_search_status(debug_info),
+        "status": status,
         "query": normalized_query,
         "country": country_filter or "",
         "min_bitrate": min_bitrate,
diff --git a/fluxtuner/web/routes/library.py b/fluxtuner/web/routes/library.py
index c321157..2c81582 100644
--- a/fluxtuner/web/routes/library.py
+++ b/fluxtuner/web/routes/library.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Literal
 
 from fastapi import APIRouter, Body, HTTPException, Path, Query, Request
 
@@ -55,16 +55,24 @@ def search(
     min_bitrate: int = Query(default=0, ge=0, le=1000),
     limit: int = Query(default=25, ge=1, le=100),
     debug: bool = Query(default=False),
+    source: Literal["radio-browser", "local", "all"] = Query(default="radio-browser"),
+    profile: str | None = Query(default=None, max_length=80),
 ) -> dict[str, Any]:
-    _require_authenticated_user(request)
+    user = _require_authenticated_user(request)
 
-    return library.search_payload(
-        query=q,
-        country=country,
-        min_bitrate=min_bitrate,
-        limit=limit,
-        debug=debug,
-    )
+    try:
+        return library.search_payload(
+            query=q,
+            country=country,
+            min_bitrate=min_bitrate,
+            limit=limit,
+            debug=debug,
+            source=source,
+            user_id=int(user["id"]),
+            profile_name=web_context.effective_profile_name(profile),
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
 
 
 @router.get("/api/history")
diff --git a/fluxtuner/web/static/js/search.js b/fluxtuner/web/static/js/search.js
index a8fc484..658dc0b 100644
--- a/fluxtuner/web/static/js/search.js
+++ b/fluxtuner/web/static/js/search.js
@@ -74,6 +74,32 @@ export function createSearchController({
   let activeSearchController = null;
   let searchRequestId = 0;
 
+  const sourceSelector = searchForm?.querySelector('[name="source"]');
+  const sourceLabels = {
+    "radio-browser": "Radio Browser",
+    local: "Local library",
+    all: "All sources",
+  };
+
+  function selectedSource() {
+    const value = sourceSelector?.value || "radio-browser";
+    return Object.hasOwn(sourceLabels, value) ? value : "radio-browser";
+  }
+
+  sourceSelector?.addEventListener("change", () => {
+    activeSearchController?.abort();
+    activeSearchController = null;
+    ++searchRequestId;
+
+    setSearchView();
+    setResultsHeader(sourceLabels[selectedSource()], "Search stations");
+    if (resultCountNode) resultCountNode.textContent = "No search yet.";
+    if (resultsNode) {
+      resultsNode.innerHTML =
+        '<p class="empty">Search with the selected source to see results.</p>';
+    }
+  });
+
   function renderResults(payload) {
     if (!resultsNode || !resultCountNode) return;
 
@@ -83,7 +109,7 @@ export function createSearchController({
 
     if (status === "unavailable") {
       resultCountNode.textContent = "Search unavailable.";
-      resultsNode.innerHTML = `${debugPanel}<p class="error">Radio Browser is temporarily unavailable. Please try again.</p>`;
+      resultsNode.innerHTML = `${debugPanel}<p class="error">The selected search sources are temporarily unavailable. Please try again.</p>`;
       return;
     }
 
@@ -133,6 +159,7 @@ export function createSearchController({
     const params = new URLSearchParams();
 
     params.set("q", String(formData.get("q") || "").trim());
+    params.set("source", selectedSource());
     params.set("country", String(formData.get("country") || "").trim());
     const minBitrate = String(formData.get("min_bitrate") || "0").trim();
     params.set("min_bitrate", minBitrate || "0");
@@ -147,10 +174,11 @@ export function createSearchController({
       return;
     }
 
+    const sourceLabel = sourceLabels[selectedSource()];
     setSearchView();
-    setResultsHeader("Radio Browser", "Search stations");
+    setResultsHeader(sourceLabel, "Search stations");
     resultCountNode.textContent = "Searching...";
-    resultsNode.innerHTML = '<p class="empty">Searching Radio Browser...</p>';
+    resultsNode.innerHTML = `<p class="empty">Searching ${sourceLabel}...</p>`;
 
     try {
       const response = await fetch(`/api/search?${params.toString()}`, {
diff --git a/fluxtuner/web/static/search.css b/fluxtuner/web/static/search.css
index 9e73d89..cffe02a 100644
--- a/fluxtuner/web/static/search.css
+++ b/fluxtuner/web/static/search.css
@@ -7,7 +7,8 @@
 .search-form {
   display: grid;
   grid-template-columns:
-    minmax(13rem, 1.25fr) minmax(9rem, 0.85fr) minmax(6.5rem, 0.4fr)
+    minmax(9rem, 0.8fr) minmax(13rem, 1.25fr)
+    minmax(9rem, 0.85fr) minmax(6.5rem, 0.4fr)
     minmax(6.5rem, 0.35fr) auto auto;
   gap: 0.75rem;
   align-items: end;
diff --git a/fluxtuner/web/templates/index.html b/fluxtuner/web/templates/index.html
index 55d4e5d..f8bda16 100644
--- a/fluxtuner/web/templates/index.html
+++ b/fluxtuner/web/templates/index.html
@@ -452,6 +452,15 @@ <h2 id="search-title" data-results-title>Search stations</h2>
                 </div>
 
                 <form class="search-form" data-search-form>
+                  <label>
+                    <span>Source</span>
+                    <select name="source" aria-label="Station discovery source">
+                      <option value="radio-browser" selected>Radio Browser</option>
+                      <option value="local">Local library</option>
+                      <option value="all">All sources</option>
+                    </select>
+                  </label>
+
                   <label>
                     <span>Search</span>
                     <input
diff --git a/tests/test_discovery_execution.py b/tests/test_discovery_execution.py
new file mode 100644
index 0000000..eba611a
--- /dev/null
+++ b/tests/test_discovery_execution.py
@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: MIT
+
+import sqlite3
+from concurrent.futures import ThreadPoolExecutor
+
+import pytest
+
+from fluxtuner.core import db
+from fluxtuner.core.discovery_execution import search_desktop_stations
+from fluxtuner.core.search_service import SearchRequest, SearchResult
+
+
+def test_local_search_reads_existing_profile_without_writing(tmp_path):
+    path = tmp_path / "library.db"
+    db.init_db(path)
+
+    with db.connect(path) as conn:
+        before = conn.total_changes
+        count_before = conn.execute("SELECT count(*) FROM profiles").fetchone()[0]
+
+    result = search_desktop_stations(
+        SearchRequest(query="missing", source="local"),
+        db_path=path,
+    )
+
+    with db.connect(path) as conn:
+        count_after = conn.execute("SELECT count(*) FROM profiles").fetchone()[0]
+
+    assert result.stations == []
+    assert count_after == count_before
+    assert before == 0
+
+
+def test_missing_database_is_not_created(tmp_path):
+    path = tmp_path / "missing.db"
+
+    with pytest.raises(sqlite3.OperationalError):
+        search_desktop_stations(SearchRequest(source="local"), db_path=path)
+
+    assert not path.exists()
+
+
+def test_missing_local_profile_is_rejected(tmp_path):
+    path = tmp_path / "library.db"
+    db.init_db(path)
+
+    with pytest.raises(ValueError, match="profile is unavailable"):
+        search_desktop_stations(
+            SearchRequest(source="local"),
+            profile_name="does-not-exist",
+            db_path=path,
+        )
+
+
+def test_invalid_source_is_rejected_before_database_access(tmp_path):
+    with pytest.raises(ValueError, match="Unknown station discovery source"):
+        search_desktop_stations(
+            SearchRequest(source="invalid"),  # type: ignore[arg-type]
+            db_path=tmp_path / "missing.db",
+        )
+
+
+def test_local_search_owns_connection_in_worker_thread(tmp_path):
+    path = tmp_path / "library.db"
+    db.init_db(path)
+
+    with ThreadPoolExecutor(max_workers=1) as pool:
+        result = pool.submit(
+            search_desktop_stations,
+            SearchRequest(source="local"),
+            db_path=path,
+        ).result()
+
+    assert result.stations == []
+    assert result.remote_status == "unknown"
+
+
+def test_remote_search_does_not_open_sqlite(monkeypatch, tmp_path):
+    from fluxtuner.core import discovery_execution
+
+    def forbidden_connection(*args, **kwargs):
+        raise AssertionError("Radio Browser must not open SQLite")
+
+    def fake_search(self, request):
+        assert request.source == "radio-browser"
+        return SearchResult(stations=[])
+
+    monkeypatch.setattr(discovery_execution.sqlite3, "connect", forbidden_connection)
+    monkeypatch.setattr(discovery_execution.SearchService, "search", fake_search)
+
+    result = search_desktop_stations(
+        SearchRequest(query="jazz"),
+        db_path=tmp_path / "does-not-exist.db",
+    )
+    assert result.stations == []
+
+
+def test_local_worker_closes_connection_on_search_error(monkeypatch, tmp_path):
+    from fluxtuner.core import discovery_execution
+
+    path = tmp_path / "library.db"
+    db.init_db(path)
+
+    real_connect = sqlite3.connect
+    opened = []
+
+    def tracked_connect(*args, **kwargs):
+        conn = real_connect(*args, **kwargs)
+        opened.append(conn)
+        return conn
+
+    def failing_search(self, request):
+        assert request.source == "local"
+        raise RuntimeError("simulated search failure")
+
+    monkeypatch.setattr(discovery_execution.sqlite3, "connect", tracked_connect)
+    monkeypatch.setattr(discovery_execution.SearchService, "search", failing_search)
+
+    with pytest.raises(RuntimeError, match="simulated search failure"):
+        search_desktop_stations(
+            SearchRequest(source="local"),
+            db_path=path,
+        )
+
+    assert len(opened) == 1
+    with pytest.raises(sqlite3.ProgrammingError, match="closed"):
+        opened[0].execute("SELECT 1")
diff --git a/tests/test_gtk_discovery_source.py b/tests/test_gtk_discovery_source.py
new file mode 100644
index 0000000..3465512
--- /dev/null
+++ b/tests/test_gtk_discovery_source.py
@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: MIT
+
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+pytest.importorskip("gi", reason="PyGObject is required for GTK tests")
+
+from fluxtuner.core.search_service import SearchResult
+from fluxtuner.gui import window
+from fluxtuner.gui.gtk_search import SearchLifecycle
+
+
+@pytest.mark.parametrize(
+    ("index", "expected"),
+    [
+        (0, "radio-browser"),
+        (1, "local"),
+        (2, "all"),
+    ],
+)
+def test_gtk_source_selector_maps_all_choices(index, expected):
+    harness = SimpleNamespace(search_source_dropdown=SimpleNamespace(get_selected=lambda: index))
+
+    assert window.MainWindow._selected_search_source(harness) == expected
+
+
+def test_gtk_source_selector_rejects_invalid_index():
+    harness = SimpleNamespace(search_source_dropdown=SimpleNamespace(get_selected=lambda: 99))
+
+    with pytest.raises(ValueError, match="Unknown station discovery source"):
+        window.MainWindow._selected_search_source(harness)
+
+
+def test_gtk_source_change_invalidates_results_and_selection():
+    lifecycle = SearchLifecycle()
+    old_generation = lifecycle.begin()
+    view_state = SimpleNamespace(show_search=Mock())
+
+    harness = SimpleNamespace(
+        _search_lifecycle=lifecycle,
+        _view_state=view_state,
+        last_search_results=[{"name": "Old station"}],
+        stations=[{"name": "Old station"}],
+        selected_station={"name": "Old station"},
+        _render_results=Mock(),
+        _update_playlist_status=Mock(),
+        _set_view_status=Mock(),
+    )
+
+    window.MainWindow._on_search_source_changed(harness, Mock(), Mock())
+
+    assert not lifecycle.is_current(old_generation)
+    assert harness.last_search_results == []
+    assert harness.stations == []
+    assert harness.selected_station is None
+    view_state.show_search.assert_called_once_with()
+    harness._render_results.assert_called_once_with()
+    harness._update_playlist_status.assert_called_once_with()
+    harness._set_view_status.assert_called_once_with("Search results", 0)
+
+
+@pytest.mark.parametrize("source", ["local", "all"])
+def test_gtk_local_and_combined_dispatch_to_worker_adapter(monkeypatch, source):
+    idle_add = Mock()
+    monkeypatch.setattr(window.GLib, "idle_add", idle_add, raising=False)
+
+    class ImmediateThread:
+        def __init__(self, *, target, daemon):
+            assert daemon is True
+            self.target = target
+
+        def start(self):
+            self.target()
+
+    monkeypatch.setattr(window.threading, "Thread", ImmediateThread)
+
+    adapter = Mock(return_value=SearchResult(stations=[{"name": "Local radio"}]))
+    monkeypatch.setattr(window, "search_desktop_stations", adapter)
+
+    service_search = Mock(side_effect=AssertionError("Wrong search backend"))
+    lifecycle = SearchLifecycle()
+    capabilities = object()
+
+    harness = SimpleNamespace(
+        _search_lifecycle=lifecycle,
+        _selected_search_source=lambda: source,
+        profile_name="default",
+        player_capabilities=capabilities,
+        search_entry=SimpleNamespace(get_text=lambda: "  rock  "),
+        country_entry=SimpleNamespace(get_text=lambda: "  Spain  "),
+        min_bitrate_entry=SimpleNamespace(get_text=lambda: "128"),
+        status_label=Mock(),
+        search_service=SimpleNamespace(search=service_search),
+        _search_failed=Mock(),
+        _search_finished=Mock(),
+    )
+
+    window.MainWindow.on_search_clicked(harness, Mock())
+
+    adapter.assert_called_once()
+    args, kwargs = adapter.call_args
+    assert args[0].source == source
+    assert args[0].query == "rock"
+    assert args[0].country == "Spain"
+    assert args[0].min_bitrate == 128
+    assert kwargs["profile_name"] == "default"
+    assert kwargs["capabilities"] is capabilities
+    service_search.assert_not_called()
+    idle_add.assert_called_once_with(
+        harness._search_finished,
+        lifecycle.generation,
+        [{"name": "Local radio"}],
+    )
+
+
+def test_gtk_stale_result_cannot_replace_new_source_view():
+    lifecycle = SearchLifecycle()
+    stale_generation = lifecycle.begin()
+    lifecycle.invalidate()
+
+    harness = SimpleNamespace(
+        _search_lifecycle=lifecycle,
+        _view_state=SimpleNamespace(show_search=Mock()),
+        last_search_results=[],
+        stations=[],
+        _render_results=Mock(),
+        _update_playlist_status=Mock(),
+        _set_view_status=Mock(),
+    )
+
+    accepted = window.MainWindow._search_finished(
+        harness, stale_generation, [{"name": "Stale station"}]
+    )
+
+    assert accepted is False
+    assert harness.stations == []
+    assert harness.last_search_results == []
+    harness._render_results.assert_not_called()
+    harness._view_state.show_search.assert_not_called()
+
+
+def test_gtk_source_change_preserves_active_playback():
+    playing = {"name": "Currently playing", "url": "https://example.org/live"}
+    player = Mock()
+    lifecycle = SearchLifecycle()
+    old_generation = lifecycle.begin()
+
+    harness = SimpleNamespace(
+        _search_lifecycle=lifecycle,
+        _view_state=SimpleNamespace(show_search=Mock()),
+        last_search_results=[{"name": "Previous result"}],
+        stations=[{"name": "Previous result"}],
+        selected_station={"name": "Previous result"},
+        current_station=playing,
+        player=player,
+        _render_results=Mock(),
+        _update_playlist_status=Mock(),
+        _set_view_status=Mock(),
+    )
+
+    window.MainWindow._on_search_source_changed(harness, Mock(), Mock())
+
+    assert not lifecycle.is_current(old_generation)
+    assert harness.last_search_results == []
+    assert harness.stations == []
+    assert harness.selected_station is None
+    assert harness.current_station is playing
+    player.stop.assert_not_called()
diff --git a/tests/test_gtk_orchestration.py b/tests/test_gtk_orchestration.py
index cd881e9..c26e0fc 100644
--- a/tests/test_gtk_orchestration.py
+++ b/tests/test_gtk_orchestration.py
@@ -578,6 +578,9 @@ def start(self) -> None:
 
     harness = SimpleNamespace(
         _search_lifecycle=lifecycle,
+        _selected_search_source=lambda: "radio-browser",
+        profile_name="default",
+        player_capabilities=None,
         search_entry=SimpleNamespace(get_text=lambda: " jazz "),
         country_entry=SimpleNamespace(get_text=lambda: " Spain "),
         min_bitrate_entry=SimpleNamespace(get_text=lambda: "128"),
diff --git a/tests/test_tui_discovery_concurrency.py b/tests/test_tui_discovery_concurrency.py
new file mode 100644
index 0000000..b944a16
--- /dev/null
+++ b/tests/test_tui_discovery_concurrency.py
@@ -0,0 +1,184 @@
+"""Concurrency regressions for TUI discovery-source searches."""
+
+import asyncio
+from types import MethodType, SimpleNamespace
+from unittest.mock import AsyncMock, Mock
+
+from fluxtuner import tui
+
+
+def make_app(source="radio-browser"):
+    values = {
+        "#query": SimpleNamespace(value="rock"),
+        "#country-filter": SimpleNamespace(value=""),
+        "#bitrate-filter": SimpleNamespace(value=""),
+        "#source-filter": SimpleNamespace(value=source),
+        "#stations": SimpleNamespace(clear=Mock(), focus=Mock()),
+    }
+    playing = {"name": "Already playing"}
+    app = SimpleNamespace(
+        view_mode="search",
+        _search_task=None,
+        _search_generation=0,
+        profile_name="default",
+        player_capabilities=None,
+        player_backend_name="mpv",
+        playing_station=playing,
+        player=SimpleNamespace(stop=Mock()),
+        restore_active_theme_if_previewing=Mock(),
+        update_mode_title=Mock(),
+        update_details=Mock(),
+        set_status=Mock(),
+        notify=Mock(),
+        populate_station_list=AsyncMock(),
+        selected_station={"name": "Old result"},
+        selected_theme=None,
+        selected_tag=None,
+        selected_playlist=None,
+        active_playlist_name=None,
+        search_service=SimpleNamespace(search=Mock()),
+        query_one=Mock(side_effect=lambda selector, *_args: values[selector]),
+    )
+    for name in (
+        "cancel_pending_search",
+        "_set_view_mode",
+        "_selected_discovery_source",
+        "_clear_view_selection",
+        "_clear_station_view_selection",
+    ):
+        setattr(app, name, MethodType(getattr(tui.FluxTunerTUI, name), app))
+    return app, values
+
+
+def result(name):
+    return SimpleNamespace(stations=[{"name": name}], unsupported_count=0)
+
+
+def test_later_search_wins_even_when_previous_finishes_last(monkeypatch):
+    async def scenario():
+        app, _widgets = make_app()
+        first_started = asyncio.Event()
+        release_first = asyncio.Event()
+
+        async def fake_to_thread(_function, request, **_kwargs):
+            if request.query == "old":
+                first_started.set()
+                await release_first.wait()
+                return result("Old radio")
+            return result("New radio")
+
+        monkeypatch.setattr(tui.asyncio, "to_thread", fake_to_thread)
+
+        old_task = asyncio.create_task(tui.FluxTunerTUI.search(app, "old"))
+        await first_started.wait()
+        new_task = asyncio.create_task(tui.FluxTunerTUI.search(app, "new"))
+        await new_task
+        release_first.set()
+        await old_task
+        await asyncio.sleep(0)
+
+        assert app.populate_station_list.await_count == 1
+        app.populate_station_list.assert_awaited_once_with([{"name": "New radio"}])
+        assert app.view_mode == "search"
+        assert app.playing_station == {"name": "Already playing"}
+        app.player.stop.assert_not_called()
+
+    asyncio.run(scenario())
+
+
+def test_stale_search_failure_does_not_replace_newer_status(monkeypatch):
+    async def scenario():
+        app, _widgets = make_app()
+        first_started = asyncio.Event()
+        release_first = asyncio.Event()
+
+        async def fake_to_thread(_function, request, **_kwargs):
+            if request.query == "old":
+                first_started.set()
+                await release_first.wait()
+                raise RuntimeError("Old backend failure")
+            return result("New radio")
+
+        monkeypatch.setattr(tui.asyncio, "to_thread", fake_to_thread)
+
+        old_task = asyncio.create_task(tui.FluxTunerTUI.search(app, "old"))
+        await first_started.wait()
+        new_task = asyncio.create_task(tui.FluxTunerTUI.search(app, "new"))
+        await new_task
+        last_status = app.set_status.call_args
+        release_first.set()
+        await old_task
+
+        assert app.set_status.call_args == last_status
+        app.notify.assert_not_called()
+        app.populate_station_list.assert_awaited_once_with([{"name": "New radio"}])
+
+    asyncio.run(scenario())
+
+
+def test_source_change_invalidates_search_without_cancelling_event_task(monkeypatch):
+    async def scenario():
+        app, widgets = make_app()
+        started = asyncio.Event()
+        release = asyncio.Event()
+
+        async def fake_to_thread(_function, _request, **_kwargs):
+            started.set()
+            await release.wait()
+            return result("Obsolete radio")
+
+        monkeypatch.setattr(tui.asyncio, "to_thread", fake_to_thread)
+
+        task = asyncio.create_task(tui.FluxTunerTUI.search(app, "rock"))
+        await started.wait()
+
+        generation = app._search_generation
+        widgets["#source-filter"].value = "local"
+        tui.FluxTunerTUI.discovery_source_changed(app, SimpleNamespace())
+
+        assert app._search_generation > generation
+        assert task.cancelling() == 0
+        assert app.view_mode == "search"
+        assert app.selected_station is None
+
+        release.set()
+        await task
+
+        app.populate_station_list.assert_not_awaited()
+        app.player.stop.assert_not_called()
+        assert app.playing_station == {"name": "Already playing"}
+
+    asyncio.run(scenario())
+
+
+def test_navigation_invalidates_search_without_cancelling_event_task(monkeypatch):
+    async def scenario():
+        app, _widgets = make_app()
+        started = asyncio.Event()
+        release = asyncio.Event()
+
+        async def fake_to_thread(_function, _request, **_kwargs):
+            started.set()
+            await release.wait()
+            return result("Obsolete radio")
+
+        monkeypatch.setattr(tui.asyncio, "to_thread", fake_to_thread)
+
+        task = asyncio.create_task(tui.FluxTunerTUI.search(app, "rock"))
+        await started.wait()
+
+        generation = app._search_generation
+        app._set_view_mode("favorites")
+
+        assert app._search_generation > generation
+        assert task.cancelling() == 0
+
+        release.set()
+        await task
+
+        assert app.view_mode == "favorites"
+        app.populate_station_list.assert_not_awaited()
+        assert app.playing_station == {"name": "Already playing"}
+        app.player.stop.assert_not_called()
+
+    asyncio.run(scenario())
diff --git a/tests/test_tui_discovery_events.py b/tests/test_tui_discovery_events.py
new file mode 100644
index 0000000..d9b24a5
--- /dev/null
+++ b/tests/test_tui_discovery_events.py
@@ -0,0 +1,77 @@
+"""Real Textual event coverage for discovery-source selection."""
+
+import asyncio
+from pathlib import Path
+
+from textual.app import App
+from textual.widgets import Select
+
+from fluxtuner.tui import FluxTunerTUI
+
+
+class DiscoveryEventProbe(App[None]):
+    CSS = FluxTunerTUI.CSS
+    discovery_source_changed = FluxTunerTUI.discovery_source_changed
+
+    def __init__(self):
+        css_path = Path(__file__).resolve().parents[1] / "fluxtuner/themes/default.tcss"
+        super().__init__(css_path=str(css_path))
+        self._search_generation = 0
+        self._search_task = None
+        self.view_mode = "favorites"
+        self.selected_station = {"name": "Previous result"}
+        self.playing_station = {"name": "Playing station"}
+        self.cleared = 0
+        self.messages = []
+
+    def compose(self):
+        yield from FluxTunerTUI.compose(self)
+
+    def cancel_pending_search(self):
+        self._search_generation += 1
+        self._search_task = None
+
+    def _set_view_mode(self, mode):
+        self.view_mode = mode
+
+    def _clear_station_view_selection(self):
+        self.selected_station = None
+        self.cleared += 1
+
+    def update_mode_title(self, title):
+        self.messages.append(("title", title))
+
+    def set_status(self, message):
+        self.messages.append(("status", message))
+
+
+def test_real_textual_select_events_invalidate_without_stopping_playback():
+    async def scenario():
+        app = DiscoveryEventProbe()
+
+        async with app.run_test(size=(80, 24)) as pilot:
+            await pilot.pause()
+            selector = app.query_one("#source-filter", Select)
+            assert selector.value == "radio-browser"
+
+            for source in ("local", "all", "radio-browser"):
+                app.selected_station = {"name": "Previous result"}
+                previous_generation = app._search_generation
+                previous_cleared = app.cleared
+
+                selector.value = source
+                await pilot.pause()
+
+                assert selector.value == source
+                assert app._search_generation > previous_generation
+                assert app.cleared > previous_cleared
+                assert app.selected_station is None
+                assert app.view_mode == "search"
+                assert app.playing_station == {"name": "Playing station"}
+
+            assert any(
+                kind == "status" and "Discovery source changed" in message
+                for kind, message in app.messages
+            )
+
+    asyncio.run(scenario())
diff --git a/tests/test_tui_view_state.py b/tests/test_tui_view_state.py
index 4c020bd..f636ec8 100644
--- a/tests/test_tui_view_state.py
+++ b/tests/test_tui_view_state.py
@@ -12,6 +12,8 @@
 def _selection_harness(*, view_mode: str = "search") -> SimpleNamespace:
     harness = SimpleNamespace(
         view_mode=view_mode,
+        _search_generation=0,
+        _search_task=None,
         selected_station={"name": "Old station"},
         selected_theme="old-theme",
         selected_tag="old-tag",
@@ -39,6 +41,7 @@ def _selection_harness(*, view_mode: str = "search") -> SimpleNamespace:
         selected_payload_from_event=Mock(),
     )
     for method_name in (
+        "cancel_pending_search",
         "_clear_view_selection",
         "_set_view_mode",
         "_clear_station_view_selection",
@@ -245,6 +248,9 @@ def test_station_highlight_preserves_parent_playlist_in_playlist_station_view()
 
 def test_search_view_clears_incompatible_selection(monkeypatch) -> None:
     harness = _selection_harness(view_mode="playlist_stations")
+    harness._selected_discovery_source = lambda: tui.FluxTunerTUI._selected_discovery_source(
+        harness
+    )
     query_input = SimpleNamespace(value="Flux")
     country_input = SimpleNamespace(value="")
     bitrate_input = SimpleNamespace(value="")
@@ -254,6 +260,7 @@ def test_search_view_clears_incompatible_selection(monkeypatch) -> None:
         "#query": query_input,
         "#country-filter": country_input,
         "#bitrate-filter": bitrate_input,
+        "#source-filter": SimpleNamespace(value="radio-browser"),
         "#stations": table,
     }
     harness.query_one = Mock(side_effect=lambda selector, *_args: widgets[selector])
diff --git a/tests/test_web_api_private.py b/tests/test_web_api_private.py
index bf0b0a4..4cefcec 100644
--- a/tests/test_web_api_private.py
+++ b/tests/test_web_api_private.py
@@ -428,3 +428,120 @@ def test_web_playlist_path_rejects_oversized_name(tmp_path, monkeypatch) -> None
     )
 
     assert response.status_code == 422
+
+
+def test_web_discovery_sources_are_isolated(tmp_path, monkeypatch) -> None:
+    client = make_client(tmp_path, monkeypatch)
+    create_user("alice")
+    bob_id = create_user("bob")
+
+    # A local search must not implicitly create a missing profile.
+    # Provision Bob's default profile explicitly for the isolation test.
+    with db.connect() as conn:
+        db.ensure_default_profile(conn, user_id=bob_id)
+        conn.commit()
+
+    alice_csrf = login(client, "alice")
+    response = client.post(
+        "/api/favorites",
+        json=station_payload("Alice Private Station", "https://example.com/alice"),
+        headers=csrf_headers(alice_csrf),
+    )
+    assert response.status_code == 200
+
+    alice_local = client.get("/api/search?q=Private&source=local")
+    assert alice_local.status_code == 200
+    assert [item["name"] for item in alice_local.json()["stations"]] == ["Alice Private Station"]
+
+    login(client, "bob")
+    bob_local = client.get("/api/search?q=Private&source=local")
+    assert bob_local.status_code == 200
+    assert bob_local.json()["stations"] == []
+
+
+def test_web_discovery_rejects_invalid_source_and_profile(tmp_path, monkeypatch) -> None:
+    client = make_client(tmp_path, monkeypatch)
+    create_user("alice")
+    login(client, "alice")
+
+    assert client.get("/api/search?q=test&source=invalid").status_code == 422
+    assert client.get("/api/search?q=test&source=local&profile=missing").status_code == 404
+    assert client.get("/api/search?q=test&source=all&profile=missing").status_code == 404
+
+
+def test_web_discovery_local_requires_authentication(tmp_path, monkeypatch) -> None:
+    client = make_client(tmp_path, monkeypatch)
+    assert client.get("/api/search?q=test&source=local").status_code == 401
+    assert client.get("/api/search?q=test&source=all").status_code == 401
+
+
+def test_web_discovery_isolates_profiles_of_same_user(tmp_path, monkeypatch) -> None:
+    from fluxtuner.core.profiles import get_or_create_profile
+
+    client = make_client(tmp_path, monkeypatch)
+    user_id = create_user("alice")
+    csrf_token = login(client, "alice")
+
+    with db.connect() as conn:
+        get_or_create_profile(conn, "secondary", user_id=user_id)
+        conn.commit()
+
+    response = client.post(
+        "/api/favorites",
+        json=station_payload("Default Only Radio", "https://example.com/default-only"),
+        headers=csrf_headers(csrf_token),
+    )
+    assert response.status_code == 200
+
+    response = client.post(
+        "/api/favorites?profile=secondary",
+        json=station_payload("Secondary Only Radio", "https://example.com/secondary-only"),
+        headers=csrf_headers(csrf_token),
+    )
+    assert response.status_code == 200
+
+    default = client.get("/api/search?q=Only&source=local")
+    secondary = client.get("/api/search?q=Only&source=local&profile=secondary")
+
+    assert default.status_code == 200
+    assert secondary.status_code == 200
+    assert [station["name"] for station in default.json()["stations"]] == ["Default Only Radio"]
+    assert [station["name"] for station in secondary.json()["stations"]] == ["Secondary Only Radio"]
+
+
+def test_web_discovery_all_survives_remote_failure(tmp_path, monkeypatch) -> None:
+    from fluxtuner.core.search_service import SearchResult
+
+    client = make_client(tmp_path, monkeypatch)
+    user_id = create_user("alice")
+    with db.connect() as conn:
+        db.ensure_default_profile(conn, user_id=user_id)
+        conn.commit()
+    login(client, "alice")
+
+    def remote_failure_with_local(self, request):
+        assert request.source == "all"
+        return SearchResult(
+            stations=[
+                {
+                    "name": "Local Survivor Radio",
+                    "url": "https://example.com/local-survivor",
+                }
+            ],
+            total_found=1,
+            remote_status="error",
+        )
+
+    monkeypatch.setattr(
+        "fluxtuner.web.library.SearchService.search",
+        remote_failure_with_local,
+    )
+
+    response = client.get("/api/search?q=Survivor&source=all&debug=1")
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["status"] == "partial"
+    assert payload["count"] == 1
+    assert payload["stations"][0]["name"] == "Local Survivor Radio"
+    assert payload["debug"]["remote_status"] == "error"
diff --git a/tests/test_web_discovery_selector.py b/tests/test_web_discovery_selector.py
new file mode 100644
index 0000000..0b64064
--- /dev/null
+++ b/tests/test_web_discovery_selector.py
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: LicenseRef-FluxTuner-Web-NC
+
+from pathlib import Path
+
+
+def test_web_search_form_exposes_all_discovery_sources(web_library) -> None:
+    client, _users = web_library
+    with client:
+        response = client.get("/")
+    assert response.status_code == 200
+    html = response.text
+    assert 'name="source"' in html
+    assert 'value="radio-browser" selected' in html
+    assert 'value="local"' in html
+    assert 'value="all"' in html
+
+
+def test_web_search_controller_invalidates_pending_requests_on_source_change() -> None:
+    script = (Path(__file__).resolve().parents[1] / "fluxtuner/web/static/js/search.js").read_text()
+    assert 'sourceSelector?.addEventListener("change"' in script
+    assert "activeSearchController?.abort();" in script
+    assert "++searchRequestId;" in script
+    assert 'params.set("source", selectedSource());' in script
+    assert 'setResultsHeader(sourceLabel, "Search stations");' in script
diff --git a/tests/test_web_static_js_sanity.py b/tests/test_web_static_js_sanity.py
index cf8779e..32c7062 100644
--- a/tests/test_web_static_js_sanity.py
+++ b/tests/test_web_static_js_sanity.py
@@ -54,7 +54,10 @@ def test_web_search_module_handles_status_and_concurrency() -> None:
     assert 'const status = payload.status || "ok";' in response.text
     assert 'status === "partial"' in response.text
     assert 'status === "unavailable"' in response.text
-    assert "Radio Browser is temporarily unavailable. Please try again." in response.text
+    assert (
+        "The selected search sources are temporarily unavailable. Please try again."
+        in response.text
+    )
     assert "Some search sources were unavailable. Showing available results." in response.text
     assert "let activeSearchController = null;" in response.text
     assert "let searchRequestId = 0;" in response.text