feat: TTS backend abstraction + 4 'imba' features + Lua packs

Big push driven by user feedback ("делай имбу") and web research on what
voice assistants need to be the ideal:

TTS backend abstraction (P0.1)
  - new module crates/jarvis-core/src/tts/{mod,sapi,piper,silero}.rs
  - TtsBackend trait with SapiBackend (current PowerShell), PiperBackend
    (rhasspy/piper, neural quality), SileroBackend (python subprocess)
  - JARVIS_TTS env var picks (sapi|piper|silero). Auto-detect Piper if
    binary + voice present in tools/piper/. Falls back to SAPI on missing.
  - SpeakOpts {lang, detached, raw} replaces ad-hoc args. text_utils
    sanitiser applied unless raw=true.
  - llm_fallback + lua/api/tts both routed through tts::backend().
  - tools/piper/install.ps1 downloads piper.exe + ru_RU-irina-medium.onnx
    from rhasspy releases + huggingface. Smoke-test included.
  - tools/silero/silero_tts.py helper (PyTorch); rust spawns it as subprocess.

IMBA-1 Agentic LLM router
  - crates/jarvis-app/src/llm_router.rs
  - When fuzzy/intent matcher fails, LLM picks the closest command from the
    full registry. Returns JSON {command_id, confidence, reason}.
  - Threshold-gated re-dispatch via substitute phrase. JARVIS_LLM_ROUTER=1
    enables; JARVIS_LLM_ROUTER_THRESHOLD overrides 0.55 default.
  - Inserted in app.rs::execute_command between "no match" and existing
    llm_fallback chat fallback.

IMBA-2 Long-term memory
  - crates/jarvis-core/src/long_term_memory.rs — JSON store at
    APP_CONFIG_DIR/long_term_memory.json. Atomic write-through.
  - remember/recall/search/forget/all/build_context API.
  - Lua bindings: jarvis.memory.* (5 functions).
  - llm_fallback auto-injects relevant facts (substring search of prompt)
    into system message before LLM call.
  - Pack resources/commands/memory_pack/ with 4 commands: remember, recall,
    forget, list.

IMBA-3 Profile switching (work/game/sleep/driving/default)
  - crates/jarvis-core/src/profiles.rs — JSON profiles at APP_CONFIG_DIR/profiles/
    Auto-seeds 5 defaults on first run with personality + allow/deny lists +
    greetings + emoji icons.
  - active_profile.txt persists choice across restart.
  - Lua bindings: jarvis.profile.{active,set,list,allows,active_name}.
  - llm_fallback prepends profile personality to system prompt.
  - Pack resources/commands/profile_switch/ with 6 voice triggers.

IMBA-4 Multimodal screenshot + vision LLM
  - crates/jarvis-core/src/lua/api/vision.rs — gated on HTTP sandbox.
  - jarvis.vision.screenshot() captures via PowerShell System.Drawing.
  - jarvis.vision.describe(prompt?) sends base64 PNG to Groq vision model
    (default llama-3.2-11b-vision-preview, override via GROQ_VISION_MODEL).
  - Pack resources/commands/vision/ with 2 commands: describe + read_error.

P0.2 Continuous conversation grace window
  - config::CONVERSATION_GRACE_MS = 30_000.
  - app.rs: after command result, if grace_ms > 0 keep listening WITHOUT
    re-wake for the grace duration. Existing CMS_WAIT_DELAY back-dated so
    the existing timeout fires at start + grace_ms.

Tests: 24/24 jarvis-core unit tests pass (including 5 text_utils).
Build: cargo build --release -p jarvis-app and -p jarvis-gui both succeed
on Windows MSVC (VS 2026 Enterprise vcvars64).

Notes for setup:
  - Piper voice install: pwsh tools/piper/install.ps1 (downloads ~90 MB).
  - GROQ_TOKEN needed for IMBA-1 (router) and IMBA-4 (vision).
  - All features are opt-in via env vars or auto-detect; existing SAPI +
    fuzzy match path remains the default.

crates/jarvis-core/src/tts/piper.rs

@@ -0,0 +1,185 @@
+//! Piper neural TTS backend (rhasspy/piper).
+//!
+//! Discovery order for binary:
+//!   1. env `JARVIS_TTS_PIPER_BIN`
+//!   2. `<exe_dir>/tools/piper/piper.exe`
+//!   3. `<APP_DIR>/tools/piper/piper.exe`
+//!
+//! Discovery order for voice:
+//!   1. env `JARVIS_TTS_PIPER_VOICE` (absolute path to .onnx)
+//!   2. `<piper_dir>/voices/ru_RU-irina-medium.onnx`
+//!   3. first `*.onnx` found in `<piper_dir>/voices/`
+
+use std::path::{Path, PathBuf};
+
+use super::{SpeakOpts, TtsBackend};
+use crate::APP_DIR;
+
+pub struct PiperBackend {
+    binary: PathBuf,
+    voice: PathBuf,
+}
+
+impl PiperBackend {
+    pub fn try_new() -> Result<Self, String> {
+        let binary = find_binary().ok_or_else(|| "piper.exe not found".to_string())?;
+        let voice_dir = binary
+            .parent()
+            .map(|p| p.join("voices"))
+            .unwrap_or_else(|| PathBuf::from("voices"));
+        let voice = find_voice(&voice_dir).ok_or_else(|| {
+            format!("no .onnx voice in {}", voice_dir.display())
+        })?;
+        Ok(Self { binary, voice })
+    }
+
+    pub fn binary_display(&self) -> String {
+        self.binary.display().to_string()
+    }
+
+    pub fn voice_display(&self) -> String {
+        self.voice
+            .file_name()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_else(|| self.voice.display().to_string())
+    }
+}
+
+impl TtsBackend for PiperBackend {
+    fn name(&self) -> &'static str { "piper" }
+
+    fn speak(&self, text: &str, opts: &SpeakOpts) {
+        if text.trim().is_empty() {
+            return;
+        }
+        let binary = self.binary.clone();
+        let voice = self.voice.clone();
+        let text = text.to_string();
+        let detached = opts.detached;
+
+        let run = move || synth_and_play(&binary, &voice, &text);
+
+        if detached {
+            std::thread::spawn(run);
+        } else {
+            run();
+        }
+    }
+}
+
+fn synth_and_play(binary: &Path, voice: &Path, text: &str) {
+    let tmp = match tempfile::Builder::new()
+        .prefix("jarvis-tts-")
+        .suffix(".wav")
+        .tempfile()
+    {
+        Ok(f) => f,
+        Err(e) => {
+            log::warn!("Piper: cannot create temp wav: {}", e);
+            return;
+        }
+    };
+    let wav_path = tmp.path().to_path_buf();
+    drop(tmp);
+
+    let mut child = match std::process::Command::new(binary)
+        .arg("--model").arg(voice)
+        .arg("--output_file").arg(&wav_path)
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+    {
+        Ok(c) => c,
+        Err(e) => {
+            log::warn!("Piper spawn failed: {}", e);
+            return;
+        }
+    };
+
+    if let Some(mut stdin) = child.stdin.take() {
+        use std::io::Write;
+        if let Err(e) = stdin.write_all(text.as_bytes()) {
+            log::warn!("Piper stdin write failed: {}", e);
+        }
+    }
+
+    match child.wait() {
+        Ok(status) if status.success() => {
+            play_wav(&wav_path);
+        }
+        Ok(status) => log::warn!("Piper exited with status {}", status),
+        Err(e) => log::warn!("Piper wait failed: {}", e),
+    }
+
+    let _ = std::fs::remove_file(&wav_path);
+}
+
+#[cfg(target_os = "windows")]
+fn play_wav(path: &Path) {
+    let escaped = path.display().to_string().replace('\'', "''");
+    let ps = format!(
+        "$p = New-Object System.Media.SoundPlayer '{}'; $p.PlaySync()",
+        escaped
+    );
+    let _ = std::process::Command::new("powershell")
+        .args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &ps])
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status();
+}
+
+#[cfg(not(target_os = "windows"))]
+fn play_wav(path: &Path) {
+    log::info!("[Piper non-Windows stub] would play: {}", path.display());
+}
+
+fn find_binary() -> Option<PathBuf> {
+    if let Ok(p) = std::env::var("JARVIS_TTS_PIPER_BIN") {
+        let candidate = PathBuf::from(p);
+        if candidate.is_file() {
+            return Some(candidate);
+        }
+    }
+
+    let bin_name = if cfg!(target_os = "windows") { "piper.exe" } else { "piper" };
+
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(dir) = exe.parent() {
+            let c = dir.join("tools").join("piper").join(bin_name);
+            if c.is_file() {
+                return Some(c);
+            }
+        }
+    }
+
+    let c = APP_DIR.join("tools").join("piper").join(bin_name);
+    if c.is_file() {
+        return Some(c);
+    }
+
+    None
+}
+
+fn find_voice(voice_dir: &Path) -> Option<PathBuf> {
+    if let Ok(p) = std::env::var("JARVIS_TTS_PIPER_VOICE") {
+        let candidate = PathBuf::from(p);
+        if candidate.is_file() {
+            return Some(candidate);
+        }
+    }
+
+    let preferred = voice_dir.join("ru_RU-irina-medium.onnx");
+    if preferred.is_file() {
+        return Some(preferred);
+    }
+
+    let entries = std::fs::read_dir(voice_dir).ok()?;
+    for entry in entries.flatten() {
+        let p = entry.path();
+        if p.extension().and_then(|s| s.to_str()) == Some("onnx") {
+            return Some(p);
+        }
+    }
+    None
+}