agent: lumotia-rebrand — fix QC blockers for phase 2

Phase 2 QC found three explicit blockers + a broader sweep needed:

Explicit (QC-named):
- crates/mcp/src/lib.rs:15 — SERVER_NAME public MCP wire identity
- crates/transcription/build.rs:59 — panic message prefix
- crates/llm/tests/content_tags_smoke.rs:7 — docstring -p flag

Swept (string literals + dev env vars + doc comments + test fixtures):
- crates/mcp/src/main.rs — eprintln log prefixes
- src-tauri/src/commands/diagnostics.rs — diagnostic filename + MAGNOTIA_VERSION
- src-tauri/src/commands/audio.rs — recording filename pattern lumotia-<secs>-...wav
- src-tauri/src/commands/fs.rs — test placeholder path
- crates/transcription/src/model_manager.rs — .lumotia-verified marker
- crates/storage/src/database.rs — lumotia-storage-ro-<pid> temp dirs + doc comments
- crates/cloud-providers/src/keystore.rs — LUMOTIA_API_KEY_<PROVIDER> env var
- crates/audio/src/{wav,decode}.rs — lumotia_test_* / lumotia_decode_* test fixtures
- crates/core/src/tuning.rs — LUMOTIA_INFERENCE_THREADS env var
- All MAGNOTIA_LLM_TEST_MODEL / MAGNOTIA_WHISPER_TEST_* env vars
- Doc comments referencing crate names

Excluded (intentional Phase 4/5 scope):
- magnotia_preferences, magnotia_history, magnotia_morning_triage_last_shown
  DB setting keys (Phase 5 paths.rs migration)
- magnotia_startup tracing target (Phase 4)
- crates/core/src/paths.rs (Phase 5 wholesale rewrite + migration shim)

cargo build --workspace passes. cargo test --workspace: 330 pass, 0 fail.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

crates/core/examples/tuning_log_demo.rs

@@ -3,7 +3,7 @@
 //! gpu_offloaded) tuples.
 //!
 //! Run with:
-//!   cargo run -p magnotia-core --example tuning_log_demo
+//!   cargo run -p lumotia-core --example tuning_log_demo
 //!
 //! Output is to stderr (tracing's default). Each unique tuple emits
 //! exactly one INFO line; subsequent calls with the same tuple are
@@ -28,8 +28,8 @@ fn main() {
         ("No override (real sysfs probe)", None),
     ] {
         match override_value {
-            Some(v) => std::env::set_var("MAGNOTIA_POWER_STATE_OVERRIDE", v),
-            None => std::env::remove_var("MAGNOTIA_POWER_STATE_OVERRIDE"),
+            Some(v) => std::env::set_var("LUMOTIA_POWER_STATE_OVERRIDE", v),
+            None => std::env::remove_var("LUMOTIA_POWER_STATE_OVERRIDE"),
         }
         // Cache invalidation so the live probe re-runs each section.
         // Override paths bypass the cache anyway; this is for the

crates/core/src/power.rs

@@ -101,7 +101,7 @@ pub(crate) fn force_set_cache(state: PowerState) {
 ///
 /// Resolution order (highest to lowest priority):
 /// 1. In-process test override (set via `with_override` from unit tests).
-/// 2. `MAGNOTIA_POWER_STATE_OVERRIDE` env var (`ac` | `battery` | `unknown`,
+/// 2. `LUMOTIA_POWER_STATE_OVERRIDE` env var (`ac` | `battery` | `unknown`,
 ///    case-insensitive). Used by `thread_sweep.rs` integration tests.
 /// 3. Linux: `parse_power_state_from_dir("/sys/class/power_supply")`.
 /// 4. macOS / Windows / other: `Unknown`.
@@ -136,7 +136,7 @@ pub fn probe_power_state() -> PowerState {
 }
 
 fn env_override() -> Option<PowerState> {
-    let raw = std::env::var("MAGNOTIA_POWER_STATE_OVERRIDE").ok()?;
+    let raw = std::env::var("LUMOTIA_POWER_STATE_OVERRIDE").ok()?;
     match raw.trim().to_ascii_lowercase().as_str() {
         "ac" => Some(PowerState::OnAc),
         "battery" => Some(PowerState::OnBattery),
@@ -293,21 +293,21 @@ mod tests {
         // env-var path tested in isolation under TEST_LOCK so it
         // doesn't race with the in-process override tests.
         with_override(None, || {
-            std::env::set_var("MAGNOTIA_POWER_STATE_OVERRIDE", "battery");
+            std::env::set_var("LUMOTIA_POWER_STATE_OVERRIDE", "battery");
             assert_eq!(probe_power_state(), PowerState::OnBattery);
-            std::env::remove_var("MAGNOTIA_POWER_STATE_OVERRIDE");
+            std::env::remove_var("LUMOTIA_POWER_STATE_OVERRIDE");
         });
     }
 
     #[test]
     fn env_var_override_garbage_falls_through() {
         with_override(None, || {
-            std::env::set_var("MAGNOTIA_POWER_STATE_OVERRIDE", "nonsense");
+            std::env::set_var("LUMOTIA_POWER_STATE_OVERRIDE", "nonsense");
             // Garbage value falls through to the platform probe.
             // We can't assert the platform result so just assert it
             // doesn't panic.
             let _ = probe_power_state();
-            std::env::remove_var("MAGNOTIA_POWER_STATE_OVERRIDE");
+            std::env::remove_var("LUMOTIA_POWER_STATE_OVERRIDE");
         });
     }
 

crates/core/src/tuning.rs

@@ -16,7 +16,7 @@ pub const MIN_INFERENCE_THREADS: usize = 2;
 /// 8 is a conservative ceiling that leaves <5% on the table for
 /// big-iron desktops while keeping consumer 6c/12t laptops out of
 /// contention territory. Users can override at runtime via
-/// MAGNOTIA_INFERENCE_THREADS.
+/// LUMOTIA_INFERENCE_THREADS.
 pub const MAX_INFERENCE_THREADS: usize = 8;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -45,13 +45,13 @@ fn log_seen() -> &'static Mutex<HashSet<(Workload, bool, bool)>> {
 /// the battery and GPU-offload heuristics.
 ///
 /// Resolution order:
-/// 1. `MAGNOTIA_INFERENCE_THREADS=N` — absolute bypass, returns N.
+/// 1. `LUMOTIA_INFERENCE_THREADS=N` — absolute bypass, returns N.
 /// 2. base = num_cpus::get_physical() (fallback: available_parallelism).
 /// 3. on battery → base /= 2.
 /// 4. gpu_offloaded → base = min(base, gpu_floor(workload)).
 /// 5. clamp to [MIN_INFERENCE_THREADS, MAX_INFERENCE_THREADS].
 pub fn inference_thread_count(workload: Workload, gpu_offloaded: bool) -> usize {
-    if let Ok(s) = std::env::var("MAGNOTIA_INFERENCE_THREADS") {
+    if let Ok(s) = std::env::var("LUMOTIA_INFERENCE_THREADS") {
         if let Ok(n) = s.parse::<usize>() {
             if n > 0 {
                 return n;
@@ -107,7 +107,7 @@ pub fn inference_thread_count(workload: Workload, gpu_offloaded: bool) -> usize
 mod tests {
     use super::*;
 
-    /// Serialises tests that read/write `MAGNOTIA_INFERENCE_THREADS` so
+    /// Serialises tests that read/write `LUMOTIA_INFERENCE_THREADS` so
     /// they don't race under cargo's parallel test runner.
     /// Mirrors the pattern used by `power::with_override`.
     fn with_thread_env_lock<R>(body: impl FnOnce() -> R) -> R {
@@ -126,7 +126,7 @@ mod tests {
         // We can't pin physical exactly without mocking num_cpus; just
         // assert the result is in range.
         with_thread_env_lock(|| {
-            std::env::remove_var("MAGNOTIA_INFERENCE_THREADS");
+            std::env::remove_var("LUMOTIA_INFERENCE_THREADS");
             let n = inference_thread_count(Workload::Llm, false);
             assert!(
                 (MIN_INFERENCE_THREADS..=MAX_INFERENCE_THREADS).contains(&n),
@@ -138,10 +138,10 @@ mod tests {
     #[test]
     fn env_var_bypasses_clamps() {
         with_thread_env_lock(|| {
-            std::env::set_var("MAGNOTIA_INFERENCE_THREADS", "10");
+            std::env::set_var("LUMOTIA_INFERENCE_THREADS", "10");
             let n = inference_thread_count(Workload::Llm, true);
             assert_eq!(n, 10);
-            std::env::remove_var("MAGNOTIA_INFERENCE_THREADS");
+            std::env::remove_var("LUMOTIA_INFERENCE_THREADS");
         });
     }
 
@@ -153,7 +153,7 @@ mod tests {
     #[test]
     fn battery_halves_thread_count() {
         with_thread_env_lock(|| {
-            std::env::remove_var("MAGNOTIA_INFERENCE_THREADS");
+            std::env::remove_var("LUMOTIA_INFERENCE_THREADS");
             // Measure on battery, then on AC — sequential, not nested,
             // to avoid re-entrant deadlock on power::TEST_LOCK.
             let on_battery = crate::power::with_override(Some(PowerState::OnBattery), || {
@@ -176,7 +176,7 @@ mod tests {
     #[test]
     fn gpu_offload_clamps_llm_to_floor() {
         with_thread_env_lock(|| {
-            std::env::remove_var("MAGNOTIA_INFERENCE_THREADS");
+            std::env::remove_var("LUMOTIA_INFERENCE_THREADS");
             crate::power::with_override(Some(PowerState::OnAc), || {
                 let n = inference_thread_count(Workload::Llm, true);
                 assert!(
@@ -191,7 +191,7 @@ mod tests {
     #[test]
     fn gpu_offload_clamps_whisper_to_floor() {
         with_thread_env_lock(|| {
-            std::env::remove_var("MAGNOTIA_INFERENCE_THREADS");
+            std::env::remove_var("LUMOTIA_INFERENCE_THREADS");
             crate::power::with_override(Some(PowerState::OnAc), || {
                 let n = inference_thread_count(Workload::Whisper, true);
                 // Whisper floor is 4 on machines with >=4 physical cores;
@@ -213,7 +213,7 @@ mod tests {
     #[test]
     fn gpu_offload_off_does_not_clamp_below_battery_calc() {
         with_thread_env_lock(|| {
-            std::env::remove_var("MAGNOTIA_INFERENCE_THREADS");
+            std::env::remove_var("LUMOTIA_INFERENCE_THREADS");
             // Sequential measurements; with_override is non-reentrant.
             crate::power::with_override(Some(PowerState::OnAc), || {
                 let no_gpu = inference_thread_count(Workload::Llm, false);
@@ -230,7 +230,7 @@ mod tests {
         // wired. This is covered by the other tests too, but kept
         // explicitly to document the behaviour.
         with_thread_env_lock(|| {
-            std::env::remove_var("MAGNOTIA_INFERENCE_THREADS");
+            std::env::remove_var("LUMOTIA_INFERENCE_THREADS");
             crate::power::with_override(Some(PowerState::OnBattery), || {
                 let _ = inference_thread_count(Workload::Llm, true);
                 let _ = inference_thread_count(Workload::Whisper, false);