feat: refine native iOS chat experience

Sources/Features/Settings/ConnectionTestView.swift

@@ -37,7 +37,7 @@ struct ConnectionTestView: View {
             if let result {
                 switch result {
                 case .success(let response):
-                    Section("Success") {
+                    Section("Server access verified") {
                         LabeledContent("Room") {
                             Text(response.room)
                                 .font(.footnote.monospaced())
@@ -45,8 +45,9 @@ struct ConnectionTestView: View {
                         LabeledContent("User") {
                             Text(response.user.displayName ?? response.user.id)
                         }
-                        Label("Connected to your server. Start a conversation to check Hope’s voice and replies.", systemImage: "checkmark.circle")
+                        Label("Account access and session setup verified. This does not test microphone permission, secure voice transport, or spoken replies.", systemImage: "checkmark.circle")
                             .foregroundStyle(.green)
+                        Text("Start a conversation to verify live voice and replies.").font(.footnote).foregroundStyle(.secondary)
                     }
                 case .failure(let error):
                     Section("Error") {

Sources/Features/Settings/SettingsView.swift

@@ -13,6 +13,7 @@ struct SettingsView: View {
     @State private var urlError: String?
     @State private var showVoicePicker = false
     @State private var savedURLConfirmation: String?
+    @State private var pendingServerChange: String?
     @FocusState private var urlFocused: Bool
     init(settings: SettingsStore, session: VoiceSession) {
         self.settings = settings
@@ -82,7 +83,7 @@ struct SettingsView: View {
                         .foregroundStyle(Nearlight.quiet)
                         .accessibilityIdentifier("settings.server.saved")
                 }
-                Button("Save server address") { applyServerURL() }
+                Button("Change server") { requestServerURLChange() }
                     .disabled(!canApplyServerURL || urlText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || urlText == settings.serverURL)
                 if !canApplyServerURL {
                     Text(session.state == .tearingDown
@@ -108,6 +109,15 @@ struct SettingsView: View {
         .sheet(isPresented: $showVoicePicker) {
             VoicePickerView(settings: settings, session: session)
         }
+        .confirmationDialog("Change Hope server?", isPresented: Binding(get: { pendingServerChange != nil }, set: { if !$0 { pendingServerChange = nil } }), titleVisibility: .visible) {
+            Button("Change server and sign out", role: .destructive) {
+                if let pendingServerChange { applyServerURL(pendingServerChange) }
+                pendingServerChange = nil
+            }
+            Button("Cancel", role: .cancel) { pendingServerChange = nil }
+        } message: {
+            Text("Changing servers signs you out and ends the current session. Conversations and account data remain with the current server.")
+        }
 
     }
 
@@ -115,47 +125,106 @@ struct SettingsView: View {
     /// draft stays in the field with an inline error; `settings.serverURL` is
     /// left untouched so the active session keeps using its original URL.
     /// Guarded: only applies when the session is idle (no active call).
-    private func applyServerURL() {
+    private func requestServerURLChange() {
         savedURLConfirmation = nil
-        guard canApplyServerURL else {
-            urlError = "End the conversation before changing servers."
-            return
-        }
+        guard canApplyServerURL else { urlError = "End the conversation before changing servers."; return }
         let trimmed = urlText.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !trimmed.isEmpty else {
-            urlError = "Enter a server URL."
-            return
-        }
+        guard !trimmed.isEmpty else { urlError = "Enter a server URL."; return }
         switch ServerConfig.parse(trimmed) {
-        case .success:
-            settings.serverURL = trimmed
-            urlText = trimmed
+        case .success(let config):
+            pendingServerChange = config.baseURL.absoluteString
             urlError = nil
-            savedURLConfirmation = trimmed
-            urlFocused = false
         case .failure(let error):
             urlError = error.localizedDescription
             urlFocused = true
         }
     }
+    private func applyServerURL(_ canonicalURL: String) {
+        settings.serverURL = canonicalURL
+        urlText = canonicalURL
+        savedURLConfirmation = canonicalURL
+        urlError = nil
+        urlFocused = false
+    }
 }
 
 struct VoicePickerView: View {
     @ObservedObject var settings: SettingsStore
     @ObservedObject var session: VoiceSession
     @Environment(\.dismiss) private var dismiss
+    @State private var voices = Voices.all
+    @State private var search = ""
+    @State private var loading = false
+    @State private var catalogMessage: String?
+    @State private var catalogAvailable = false
+    @State private var requestID = UUID()
+    @State private var applyingVoiceID: String?
+    @State private var voiceError: String?
+
+    private var filteredVoices: [VoiceOption] {
+        let query = search.trimmingCharacters(in: .whitespacesAndNewlines)
+        return voices.filter { query.isEmpty || "\($0.name) \($0.details)".localizedCaseInsensitiveContains(query) }
+    }
+
+    @MainActor private func loadVoices() async {
+        guard !loading else { return }
+        loading = true
+        let id = UUID()
+        requestID = id
+        defer { if requestID == id { loading = false } }
+        do {
+            guard case .success(let config) = ServerConfig.parse(settings.serverURL) else { throw AuthError.invalidResponse }
+            let response = try await AuthClient(config: config).voices(token: session.bootstrapBearerToken)
+            try Task.checkCancellation()
+            guard requestID == id else { return }
+            let valid = response.voices.filter { $0.id.range(of: "^[A-Za-z0-9:_-]{1,120}$", options: .regularExpression) != nil }
+            guard !valid.isEmpty else { throw AuthError.invalidResponse }
+            voices = valid
+            catalogAvailable = response.catalogAvailable
+            catalogMessage = response.catalogAvailable ? nil : response.message
+        } catch is CancellationError {
+            return
+        } catch {
+            guard !Task.isCancelled, requestID == id else { return }
+            catalogAvailable = false
+            catalogMessage = "Couldn’t load all English voices. Your current choices remain available. Check your sign-in and server update, then retry."
+        }
+    }
 
     var body: some View {
         NavigationStack {
             List {
-                ForEach(Voices.all, id: \.id) { voice in
+                Section {
+                    Text("Ava Dragon HD Omni is the recommended female default. Search by name, locale, gender, or model.")
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                    if loading { ProgressView("Loading English voices…") }
+                    if let catalogMessage { Text(catalogMessage).font(.footnote).foregroundStyle(.secondary) }
+                    if let voiceError { Label(voiceError, systemImage: "exclamationmark.circle").font(.footnote).foregroundStyle(.red) }
+                    if !catalogAvailable && !loading {
+                        Button("Retry voice catalog") { Task { await loadVoices() } }
+                    }
+                }
+                if filteredVoices.isEmpty {
+                    Text("No matching voices. Try another name or locale.").foregroundStyle(.secondary)
+                }
+                ForEach(filteredVoices, id: \.id) { voice in
                     Button {
-                        settings.voiceID = voice.id
-                        Task { await session.selectVoice(voice.id) }
-                        dismiss()
+                        guard applyingVoiceID == nil else { return }
+                        applyingVoiceID = voice.id
+                        voiceError = nil
+                        Task {
+                            let applied = await session.selectVoice(voice.id)
+                            applyingVoiceID = nil
+                            if applied { dismiss() }
+                            else { voiceError = "Couldn’t apply this voice to the live conversation. Your previous voice is still selected." }
+                        }
                     } label: {
                         HStack {
-                            Text(voice.displayName)
+                            VStack(alignment: .leading, spacing: 3) {
+                                Text(voice.name)
+                                Text(voice.details).font(.caption).foregroundStyle(.secondary)
+                            }
                             if settings.voiceID == voice.id {
                                 Spacer()
                                 Image(systemName: "checkmark")
@@ -163,10 +232,14 @@ struct VoicePickerView: View {
                             }
                         }
                     }
+                    .disabled(applyingVoiceID != nil)
                     .accessibilityAddTraits(settings.voiceID == voice.id ? .isSelected : [])
                 }
             }
-            .navigationTitle("Voice")
+            .navigationTitle("English voices")
+            .searchable(text: $search, prompt: "Name, locale, gender, or Omni")
+            .task { await loadVoices() }
+            .onDisappear { requestID = UUID(); loading = false }
             .toolbar {
                 ToolbarItem(placement: .cancellationAction) {
                     Button("Cancel") { dismiss() }