feat: persist LLM/TTS backend choice + reset/repeat context + quick-search + diagnostics

Closes the UX hole I created in 5c72450: voice-swap to Ollama used to vanish
after restart. Plus P0.3 (long-standing roadmap item) and two new packs.

Persistent backend choice (crates/jarvis-core/src/db/structs.rs)
  - Settings struct gains llm_backend + tts_backend fields (both String,
    "" / "auto" = follow env/auto-detect).
  - set("llm_backend", "groq"|"ollama"|"auto") validates input.
  - llm::init_global() reads DB first, then JARVIS_LLM env, then auto-detect.
  - llm::swap_to() now persists the choice via db::save_settings.
  - Voice swap "переключись на локальный" now survives restart.

Shared conversation history (P0.3, crates/jarvis-core/src/llm/mod.rs)
  - HISTORY: Lazy<RwLock<Option<ConversationHistory>>> singleton.
  - Helpers: init_history, history_push_user, history_push_assistant,
    history_snapshot, history_clear, history_pop_last_user, history_last_assistant.
  - llm_fallback migrated off its own Mutex<History> — now reads/writes shared.
  - ConversationHistory gains last_assistant() method.

New Lua APIs
  - jarvis.llm_reset()        → clear conversation turns (keeps system prompt).
  - jarvis.llm_last_reply()   → string or nil (last assistant message text).
  - jarvis.health()           → debug table {tts_backend, llm_backend, llm_model,
                                  active_profile, memory_facts, scheduled_tasks,
                                  language, voice, microphone, vosk_model,
                                  noise_suppression}. No secrets included.

New voice packs
  - resources/commands/llm_context/   (P0.3)
    * "сбрось контекст" / "забудь разговор"     → llm.reset
    * "повтори последнее" / "повтори ответ"     → llm.repeat (uses last_assistant)
  - resources/commands/quick_search/   (imba P1 item)
    * "найди в гугле <X>" / "загугли <X>"
    * Uses DuckDuckGo Instant Answer API (api.duckduckgo.com, no key required).
      Pulls AbstractText or RelatedTopics into LLM prompt; falls back to pure
      LLM knowledge if DDG returns nothing useful. Speaks 2-4 sentence answer.
  - resources/commands/diagnostics/
    * "диагностика" / "доложи о себе" / "статус"
    * Reads jarvis.health() and speaks a one-line summary. Useful when
      debugging — user can read out their current state for a bug report.

Build: cargo build --release -p jarvis-app -p jarvis-gui green.
Tests: 52/52 jarvis-core unit tests pass.

crates/jarvis-core/src/llm/history.rs

@@ -58,6 +58,11 @@ impl ConversationHistory {
         }
     }
 
+    /// Return the most recent assistant message, or None if none yet.
+    pub fn last_assistant(&self) -> Option<&ChatMessage> {
+        self.turns.iter().rev().find(|m| m.role == "assistant")
+    }
+
     fn truncate(&mut self) {
         if self.turns.len() > self.max_turns {
             let drop = self.turns.len() - self.max_turns;

crates/jarvis-core/src/llm/mod.rs

@@ -12,6 +12,52 @@ use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 use std::sync::Arc;
 
+// ─── Shared conversation history ───────────────────────────────────────────
+//
+// Single global history so the LLM fallback chat, the Lua reset/repeat helpers,
+// and any future IPC handler all operate on the same buffer. Initialised on
+// boot via `init_history(system_prompt, max_turns)`.
+
+static HISTORY: Lazy<RwLock<Option<ConversationHistory>>> = Lazy::new(|| RwLock::new(None));
+
+pub fn init_history(system_prompt: impl Into<String>, max_turns: usize) {
+    *HISTORY.write() = Some(ConversationHistory::new(system_prompt, max_turns));
+}
+
+pub fn history_push_user(content: impl Into<String>) {
+    if let Some(h) = HISTORY.write().as_mut() {
+        h.push_user(content);
+    }
+}
+
+pub fn history_push_assistant(content: impl Into<String>) {
+    if let Some(h) = HISTORY.write().as_mut() {
+        h.push_assistant(content);
+    }
+}
+
+pub fn history_snapshot() -> Vec<ChatMessage> {
+    HISTORY.read().as_ref().map(|h| h.snapshot()).unwrap_or_default()
+}
+
+pub fn history_clear() {
+    if let Some(h) = HISTORY.write().as_mut() {
+        h.clear();
+    }
+}
+
+pub fn history_pop_last_user() {
+    if let Some(h) = HISTORY.write().as_mut() {
+        h.pop_last_user();
+    }
+}
+
+/// Return the most recent assistant message text, or None.
+pub fn history_last_assistant() -> Option<String> {
+    HISTORY.read().as_ref()
+        .and_then(|h| h.last_assistant().map(|m| m.content.clone()))
+}
+
 /// Shared mutable LLM client. Modules read via `current()`; the user can
 /// hot-swap backends at runtime via `swap_to(LlmBackend::Ollama)` etc.
 ///
@@ -19,12 +65,28 @@ use std::sync::Arc;
 /// `init_global()` was never called).
 static GLOBAL: Lazy<RwLock<Option<Arc<LlmClient>>>> = Lazy::new(|| RwLock::new(None));
 
-/// Initialise the global client from env vars (`JARVIS_LLM`, `GROQ_TOKEN`, ...).
+/// Initialise the global client. Precedence:
+///   1. Settings DB `llm_backend` field (if non-empty)
+///   2. `JARVIS_LLM` env var
+///   3. Auto-detect (Groq if `GROQ_TOKEN`, else Ollama)
+///
 /// Idempotent — replaces any previous global. Returns Ok even when the chosen
 /// backend can't be probed: an Ollama server may not be running yet but we
 /// stash the client anyway and let calls fail on first request.
 pub fn init_global() -> Result<(), ConfigError> {
-    let c = LlmClient::from_env()?;
+    // Try DB-persisted choice first.
+    let persisted = crate::DB.get().and_then(|db| {
+        let s = db.read();
+        let backend = s.llm_backend.trim().to_string();
+        if backend.is_empty() { None } else { parse_backend(&backend) }
+    });
+
+    let c = match persisted {
+        Some(LlmBackend::Groq) => LlmClient::groq()?,
+        Some(LlmBackend::Ollama) => LlmClient::ollama(),
+        None => LlmClient::from_env()?,
+    };
+
     log::info!("LLM global initialised: backend={}, model={}", c.backend().name(), c.model());
     *GLOBAL.write() = Some(Arc::new(c));
     Ok(())
@@ -45,6 +107,7 @@ pub fn current_backend_name() -> &'static str {
 }
 
 /// Hot-swap to a different backend. Returns the new backend's name on success.
+/// Persists the choice to the settings DB so it survives restart.
 pub fn swap_to(backend: LlmBackend) -> Result<&'static str, ConfigError> {
     let c = match backend {
         LlmBackend::Groq => LlmClient::groq()?,
@@ -53,6 +116,21 @@ pub fn swap_to(backend: LlmBackend) -> Result<&'static str, ConfigError> {
     let name = c.backend().name();
     log::info!("LLM swapped → backend={}, model={}", name, c.model());
     *GLOBAL.write() = Some(Arc::new(c));
+
+    // Persist to settings DB (best-effort — log on failure, don't propagate).
+    if let Some(db) = crate::DB.get() {
+        let snapshot = {
+            let mut s = db.write();
+            s.llm_backend = name.to_string();
+            s.clone()
+        };
+        if let Err(e) = crate::db::save_settings(&snapshot) {
+            log::warn!("LLM swap: failed to persist to settings DB: {}", e);
+        } else {
+            log::info!("LLM choice persisted: {}", name);
+        }
+    }
+
     Ok(name)
 }