chore(release): v0.4.4 — Fit-Korean custom model + Phase B/C lever wiring

## New custom HF model

  Gemma 4 — 26B A4B Fit-Korean (custom, hsng95)
    hsng95/gemma-4-26b-a4b-mlx-fit-korean
    11 GB / 5.057 bpw base / per-layer 79~117 experts (vs 128 source)

  Flagship-KR (HIGH=6 + top4=0.40) with 961 dormant MoE cells (25%)
  pruned via workload-specific imatrix routing analysis. Korean axes
  preserved within stderr (HAERAE 0.683 vs Flagship 0.687, ±0.015);
  English commonsense within stderr (HellaSwag-norm 0.395 vs 0.410).
  Trade-off: English reasoning/factual −13~14% (ARC, TruthfulQA),
  math CoT −80% (GSM8K) — Korean-first deployment trade-off.

  Catalog entry: "Gemma 4 — 26B A4B Fit-Korean (custom, hsng95)" in
  lumen-server, 24 GB min RAM (Mac mini M4 Pro stable).

## Phase B/C lever wiring (landed in prior sessions, now committed)

  * native_cache.rs +3 truncate_to impls for NativeKvCacheQuantized /
    NativeRotatingKvCacheQuantized / NativeRotatingKvCacheTurboQuant —
    unblocks QUANT_KV + prefix cache co-existence (TurboQuant attention
    path requirement for Phase 3 rvLLM PR).

  * gemma4_moe.rs: dispatch the new truncate_to from
    NativeGemma4PromptCache; LUMEN_GEMMA4_TOP_K env override for
    per-decode top_k tuning (default behavior unchanged; opt-in env).

  * gemma4_backend.rs: MTP chat path gated default-OFF behind
    LUMEN_GEMMA4_MTP=1 — Apple Silicon batch=1 MTP n_draft=6 measured
    NET LOSS on conversational workloads; OFF preserves perf-tuned
    custom-FA-2 kernel. Greedy bit-identical NOT guaranteed between
    OFF/ON paths (by-design kernel selection difference).

  * gemma4_backend_prefix_cache_smoke.rs: stale 6-arg call updated to
    8-arg API (tools + tool_choice now required).

  * 3 new examples:
    - gemma4_backend_mtp_chat_smoke.rs (MTP chat A/B harness)
    - gemma4_pruned_token_dump.rs (greedy token A/B for pruned vs
      source verification)
    - gemma4_english_team_recognition.rs (English vocab recognition
      smoke for pruned builds)

  * cargo fmt cleanup across lumen-app, lumen-model.

## Version bump

  crates/lumen-app/Cargo.toml + tauri.conf.json + frontend/package.json
  — 0.4.3 → 0.4.4. Cargo.lock refreshed. OTA auto-update inherits.

Author: rabbitson87

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "lumen-app"
-version = "0.4.3"
+version = "0.4.4"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true

crates/lumen-app/Cargo.toml

@@ -1,7 +1,7 @@
 {
   "name": "lumen-app-frontend",
   "private": true,
-  "version": "0.4.3",
+  "version": "0.4.4",
   "type": "module",
   "scripts": {
     "predev": "cargo build --manifest-path ../../../Cargo.toml -p lumen-server --release",

crates/lumen-app/frontend/package.json

@@ -38,7 +38,9 @@ fn main() {
     };
     match hf_token_src {
         Some(name) => {
-            eprintln!("[lumen-app] HuggingFace token detected via ${name} — gated repos accessible");
+            eprintln!(
+                "[lumen-app] HuggingFace token detected via ${name} — gated repos accessible"
+            );
         }
         None => {
             eprintln!(

crates/lumen-app/src/main.rs

@@ -465,8 +465,8 @@ pub fn hf_client(timeout: Option<std::time::Duration>) -> Result<reqwest::Client
         .or_else(|| std::env::var("HUGGING_FACE_HUB_TOKEN").ok())
         .map(|t| t.trim().to_string())
         .filter(|t| !t.is_empty());
-    let mut builder = reqwest::Client::builder()
-        .user_agent(concat!("lumen-app/", env!("CARGO_PKG_VERSION")));
+    let mut builder =
+        reqwest::Client::builder().user_agent(concat!("lumen-app/", env!("CARGO_PKG_VERSION")));
     if let Some(d) = timeout {
         builder = builder.timeout(d);
     }

crates/lumen-app/src/models.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lumen",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "identifier": "ai.lumen.app",
   "build": {
     "frontendDist": "frontend/dist",

crates/lumen-app/tauri.conf.json

@@ -0,0 +1,170 @@
+//! End-to-end smoke for `Gemma4Backend::chat_streaming` with the MTP
+//! decode branch wired through `mtp_step()` (Phase 3 landed 2026-05-24).
+//!
+//! Two runs against the same chat-templated prompt:
+//!   1. `LUMEN_GEMMA4_MTP=0` (baseline, async-pipelined per-token loop)
+//!   2. `LUMEN_GEMMA4_MTP=1` (routes through mtp_step → committed batch)
+//!
+//! At temperature=0 (greedy), Google's assistant-drafter MTP guarantees
+//! byte-identical visible output. We assert the two runs produce the same
+//! `ParsedResponse.visible` string and log per-run wall-clock for an A/B
+//! comparison.
+//!
+//! Run:
+//!   MLX_LOCAL_SOURCE_DIR=/Users/sonheesung/Documents/GitHub/mlx \
+//!   MODEL_ID=/Users/sonheesung/models/hsng95--gemma-4-26b-a4b-mlx-imatrix3plus-awq \
+//!   DRAFTER_DIR=/Users/sonheesung/models/gemma-4-26B-A4B-it-assistant-bf16 \
+//!   cargo run --release -p lumen-mlx \
+//!       --example gemma4_backend_mtp_chat_smoke --features mlx-native
+
+use std::path::Path;
+use std::time::Instant;
+
+use anyhow::{Context, Result};
+
+#[cfg(feature = "mlx-native")]
+use lumen_mlx::chat_io::{BackendStreamEvent, ResolvedToolChoice};
+#[cfg(feature = "mlx-native")]
+use lumen_mlx::gemma4::{Gemma4Backend, ToolDef};
+
+#[cfg(feature = "mlx-native")]
+fn run_once(
+    backend: &mut Gemma4Backend,
+    messages: &[(String, String)],
+    max_new_tokens: usize,
+    tools: &[ToolDef<'_>],
+    tool_choice: &ResolvedToolChoice<'_>,
+    label: &str,
+) -> Result<(String, f64)> {
+    let mut buf = String::new();
+    let t0 = Instant::now();
+    let resp = backend.chat_streaming(
+        messages,
+        max_new_tokens,
+        /* temperature */ 0.0,
+        /* top_p */ 1.0,
+        /* thinking */ false,
+        tools,
+        tool_choice,
+        |ev| {
+            if let BackendStreamEvent::Text(t) = ev {
+                buf.push_str(t);
+            }
+            Ok(())
+        },
+    )?;
+    let wall_ms = t0.elapsed().as_secs_f64() * 1e3;
+    eprintln!(
+        "[mtp-chat-smoke:{label}] visible={:?} wall={:.0}ms",
+        resp.visible, wall_ms
+    );
+    Ok((resp.visible, wall_ms))
+}
+
+#[cfg(feature = "mlx-native")]
+fn main() -> Result<()> {
+    let model_id = std::env::var("MODEL_ID").unwrap_or_else(|_| {
+        "/Users/sonheesung/models/hsng95--gemma-4-26b-a4b-mlx-imatrix3plus-awq".into()
+    });
+    let drafter_dir = std::env::var("DRAFTER_DIR")
+        .unwrap_or_else(|_| "/Users/sonheesung/models/gemma-4-26B-A4B-it-assistant-bf16".into());
+    let max_new_tokens: usize = std::env::var("MAX_NEW_TOKENS")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(256);
+
+    eprintln!("[mtp-chat-smoke] loading trunk {model_id}");
+    let mut backend = Gemma4Backend::from_dir("gemma4-mtp-chat-smoke", Path::new(&model_id))
+        .context("backend load")?;
+
+    eprintln!("[mtp-chat-smoke] enabling MTP from {drafter_dir}");
+    let enabled = backend
+        .try_enable_mtp(Path::new(&drafter_dir))
+        .context("try_enable_mtp")?;
+    if !enabled {
+        return Err(anyhow::anyhow!(
+            "try_enable_mtp returned false (backbone_hidden_size mismatch)"
+        ));
+    }
+
+    let messages = vec![
+        (
+            "system".to_string(),
+            "당신은 한국어로 정중히 답하는 어시스턴트입니다.".to_string(),
+        ),
+        (
+            "user".to_string(),
+            "한국의 4대 명승지를 각각 한 문단씩 설명해주세요. 역사, 위치, 특징을 포함해서.".to_string(),
+        ),
+    ];
+
+    let tools: &[ToolDef<'_>] = &[];
+    let tool_choice = ResolvedToolChoice::Auto;
+
+    // ── Warmup pass (MTP off, throwaway) so MLX kernel / graph cache and
+    //    native runner fast-mode are warmed before we measure either path.
+    //    Without this, the OFF run pays cold-start cost and the ON run
+    //    inherits the warmth — net 8× per-token regression in the OFF
+    //    measurement vs documented 73 tok/s steady state. ──
+    unsafe {
+        std::env::set_var("LUMEN_GEMMA4_MTP", "0");
+    }
+    eprintln!("[mtp-chat-smoke] warmup pass (max_new_tokens=16)");
+    let _ = run_once(&mut backend, &messages, 16, tools, &tool_choice, "warmup")?;
+
+    // ── Run 1: MTP OFF ──
+    unsafe {
+        std::env::set_var("LUMEN_GEMMA4_MTP", "0");
+    }
+    let (visible_off, wall_off) = run_once(
+        &mut backend,
+        &messages,
+        max_new_tokens,
+        tools,
+        &tool_choice,
+        "off",
+    )?;
+
+    // ── Run 2: MTP ON ──
+    unsafe {
+        std::env::set_var("LUMEN_GEMMA4_MTP", "1");
+    }
+    let (visible_on, wall_on) = run_once(
+        &mut backend,
+        &messages,
+        max_new_tokens,
+        tools,
+        &tool_choice,
+        "on",
+    )?;
+
+    println!("\n=== Gemma4Backend MTP chat A/B ===");
+    println!("max_new_tokens = {max_new_tokens}");
+    println!("OFF visible: {:?}", visible_off);
+    println!("ON  visible: {:?}", visible_on);
+    println!("OFF wall: {:.0} ms", wall_off);
+    println!("ON  wall: {:.0} ms", wall_on);
+    let speedup = if wall_on > 0.0 {
+        wall_off / wall_on
+    } else {
+        0.0
+    };
+    println!("speedup ON / OFF = {:.2}x (wall-clock)", speedup);
+
+    if visible_off != visible_on {
+        eprintln!(
+            "WARNING: MTP-on visible differs from MTP-off — greedy bit-identical guarantee violated"
+        );
+        eprintln!("  off len chars = {}", visible_off.chars().count());
+        eprintln!("  on  len chars = {}", visible_on.chars().count());
+    } else {
+        println!("\n✓ bit-identical visible string (greedy guarantee holds)");
+    }
+
+    Ok(())
+}
+
+#[cfg(not(feature = "mlx-native"))]
+fn main() {
+    eprintln!("build with --features mlx-native to run this example");
+}

crates/lumen-mlx/examples/gemma4_backend_mtp_chat_smoke.rs

@@ -21,7 +21,8 @@ use anyhow::{Context, Result};
 
 #[cfg(feature = "mlx-native")]
 fn main() -> Result<()> {
-    use lumen_mlx::gemma4::Gemma4Backend;
+    use lumen_mlx::chat_io::ResolvedToolChoice;
+    use lumen_mlx::gemma4::{Gemma4Backend, ToolDef};
 
     let model_id = std::env::var("MODEL_ID")
         .unwrap_or_else(|_| "/path/to/models/gemma-4-26b-a4b-mlx-3bit".into());
@@ -62,6 +63,8 @@ fn main() -> Result<()> {
 
     let max_new_tokens = 200;
     let prefix_key = "moltis-sports-batch-001";
+    let tools: &[ToolDef<'_>] = &[];
+    let tool_choice = ResolvedToolChoice::Auto;
 
     println!("\n=== Gemma4Backend prefix_cache end-to-end smoke ===\n");
     for (i, query) in queries.iter().enumerate() {
@@ -79,6 +82,8 @@ fn main() -> Result<()> {
                 /* top_p */ 1.0,
                 /* thinking */ false,
                 prefix_key,
+                tools,
+                &tool_choice,
             )
             .with_context(|| format!("request {} failed", i + 1))?;
         let wall_ms = t0.elapsed().as_secs_f64() * 1e3;

crates/lumen-mlx/examples/gemma4_backend_prefix_cache_smoke.rs

@@ -0,0 +1,91 @@
+//! Verify pruned Gemma 4 recognizes English sport team / league names.
+//!
+//! Probes the Moltis matching workload: Korean query → JSON tool call
+//! using English team & league names. The token output is decoded and
+//! printed for both source & pruned model comparison.
+//!
+//! Run:
+//!   MODEL_ID=/path/to/model cargo run --release --features mlx-native \
+//!     -p lumen-mlx --example gemma4_english_team_recognition
+
+use std::path::Path;
+
+use anyhow::{Context, Result};
+
+#[cfg(feature = "mlx-native")]
+fn main() -> Result<()> {
+    use lumen_mlx::gemma4::{GenerateConfig, NativeGemma4Model};
+
+    // 4 Moltis-style queries each naming a different English team. The
+    // model should produce a JSON tool_call containing the canonical
+    // English team name + league name. Each prompt is chat-templated.
+    let queries: &[(&str, &[u32])] = &[
+        // "Liverpool 이 어느 리그 소속인지 알려줘"
+        (
+            "Liverpool",
+            &[
+                2, 105, 2364, 107, 98125, 4214, 107561, 225183, 18004, 238701, 93860, 88440,
+                242332, 106, 107, 105, 4368, 107, 100, 45518, 107, 101,
+            ],
+        ),
+        // "Real Madrid 가 어느 리그?"
+        (
+            "Real Madrid",
+            &[
+                2, 105, 2364, 107, 20235, 19627, 8486, 107561, 225183, 236881, 106, 107, 105, 4368,
+                107, 100, 45518, 107, 101,
+            ],
+        ),
+        // "Manchester City 의 리그명을 말해줘"
+        (
+            "Manchester City",
+            &[
+                2, 105, 2364, 107, 74246, 4085, 18132, 225183, 127500, 18906, 237578, 242332, 106,
+                107, 105, 4368, 107, 100, 45518, 107, 101,
+            ],
+        ),
+        // "Bayern Munich 어느 리그?"
+        (
+            "Bayern Munich",
+            &[
+                2, 105, 2364, 107, 218437, 46566, 107561, 225183, 236881, 106, 107, 105, 4368,
+                107, 100, 45518, 107, 101,
+            ],
+        ),
+    ];
+
+    let model_id = std::env::var("MODEL_ID").context("MODEL_ID env required")?;
+    eprintln!("[probe] loading {model_id}");
+    let model = NativeGemma4Model::load(Path::new(&model_id)).context("load")?;
+
+    let cfg = GenerateConfig {
+        max_new_tokens: 24,
+        stop_on_eos: true,
+        sampling: None,
+    };
+
+    unsafe {
+        std::env::set_var("LUMEN_GEMMA4_LOOKUP_SPEC", "0");
+    }
+
+    // Warm
+    let _ = model.generate(queries[0].1, &cfg).context("warm")?;
+
+    for (label, prompt) in queries {
+        let stats = model.generate(prompt, &cfg).context("gen")?;
+        println!("=== query={label} ({} tok generated) ===", stats.generated_tokens.len());
+        for (i, t) in stats.generated_tokens.iter().enumerate() {
+            print!("{t}");
+            if i + 1 < stats.generated_tokens.len() {
+                print!(",");
+            }
+        }
+        println!();
+    }
+    Ok(())
+}
+
+#[cfg(not(feature = "mlx-native"))]
+fn main() -> Result<()> {
+    Err(anyhow::anyhow!("build with --features mlx-native"))
+}