Grade muse-glimmer-28b full 7-prompt battery — new benchmark leader

7 entries (30→37 total). Muse Glimmer 28B (GGUF) avg 80.7 — the strongest
model in the benchmark, 6/7 prompts Minor Logic Flaws:
  lfu 76 | webhook 81 | automation 89 | rust 85 | data 88 | tts 58 | mcp 88

Standout results:
- rust 85 (KAT 36, Qwen3-Coder 54) — real tokio channels (mpsc::channel, not
  hallucinated mpsc::bounded), two-tier CancellationToken, zero clippy lints;
  one-line E0507 compile fix.
- automation 89 — first model to print a correct summary (98/2/0/100);
  atomic temp+fsync+rename checkpointing.
- data 88 edges out Gemma-26B's 86; mcp 88 sets the bar on a new prompt.
Only weak spot: tts 58 (backpressure raises instead of awaits, like Qwen3-Coder).

Captured via the native /api/v1/chat fix (real tok/sec + TTFT). Slow
deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning.

Also gitignore checkpoint.json (automation test runtime artifact).

Co-Authored-By: Claude <noreply@anthropic.com>

outputs/muse-glimmer-28b-gguf-rust.rs

@@ -0,0 +1,266 @@
+// Cargo.toml
+// tokio = { version = "1", features = ["full"] }
+// tokio-util = "0.7"
+// serde = { version = "1", features = ["derive"] }
+// thiserror = "1"
+// rand = "0.9"
+
+use rand::Rng;
+use serde::Serialize;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+use thiserror::Error;
+use tokio::sync::{mpsc, Mutex};
+use tokio::task::JoinHandle;
+use tokio_util::sync::CancellationToken;
+
+#[derive(Error, Debug)]
+enum FetchError {
+    #[error("transient")]
+    Transient,
+    #[error("always fail")]
+    AlwaysFail,
+}
+
+async fn mock_fetch(id: u32) -> Result<Vec<String>, FetchError> {
+    tokio::time::sleep(Duration::from_millis(10)).await;
+    if id == 999 {
+        return Err(FetchError::AlwaysFail);
+    }
+    let mut rng = rand::rng();
+    if rng.random_bool(0.15) {
+        Err(FetchError::Transient)
+    } else {
+        Ok((0..rng.random_range(0..4))
+            .map(|i| format!("item-{}-{}", id, i))
+            .collect())
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+struct Item {
+    watcher_id: u32,
+    items: Vec<String>,
+    ts: u64,
+}
+
+#[derive(Debug, Serialize, Default, Clone)]
+struct Aggregated {
+    items: Vec<Item>,
+    total_count: usize,
+}
+
+struct WatcherMeta {
+    token: CancellationToken,
+    handle: JoinHandle<()>,
+    consecutive_failures: Arc<Mutex<u32>>,
+    healthy: Arc<Mutex<bool>>,
+}
+
+pub struct WatcherManager {
+    pub(crate) tx: mpsc::Sender<Item>,
+    pub(crate) aggregated: Arc<Mutex<Aggregated>>,
+    pub(crate) watchers: Arc<Mutex<HashMap<u32, WatcherMeta>>>,
+    pub(crate) next_id: Arc<Mutex<u32>>,
+    pub(crate) shutdown_token: CancellationToken,
+    pub(crate) consumer_handle: JoinHandle<Aggregated>,
+}
+
+impl WatcherManager {
+    pub async fn new(num_watchers: usize) -> Self {
+        let (tx, rx) = mpsc::channel(32); // bounded -> backpressure
+        let aggregated = Arc::new(Mutex::new(Aggregated::default()));
+        let shutdown_token = CancellationToken::new();
+        let watchers = Arc::new(Mutex::new(HashMap::new()));
+        let next_id = Arc::new(Mutex::new(1));
+        let consumer_handle = tokio::spawn(consumer_task(rx, shutdown_token.clone(), aggregated.clone()));
+
+        let manager = WatcherManager {
+            tx,
+            aggregated,
+            watchers,
+            next_id,
+            shutdown_token,
+            consumer_handle,
+        };
+
+        for _ in 0..num_watchers {
+            manager.add_watcher().await;
+        }
+        manager
+    }
+
+    pub async fn add_watcher(&self) -> u32 {
+        let mut id_guard = self.next_id.lock().await;
+        let id = *id_guard;
+        *id_guard += 1;
+        drop(id_guard);
+        self.add_watcher_with_id(id).await
+    }
+
+    pub async fn add_watcher_with_id(&self, id: u32) -> u32 {
+        let token = CancellationToken::new();
+        let tx = self.tx.clone();
+        let shutdown_token = self.shutdown_token.clone();
+        let consecutive_failures = Arc::new(Mutex::new(0u32));
+        let healthy = Arc::new(Mutex::new(true));
+
+        let handle = tokio::spawn(watcher_task(
+            id,
+            token.clone(),
+            shutdown_token,
+            tx,
+            consecutive_failures.clone(),
+            healthy.clone(),
+        ));
+
+        let meta = WatcherMeta {
+            token,
+            handle,
+            consecutive_failures,
+            healthy,
+        };
+        self.watchers.lock().await.insert(id, meta);
+        id
+    }
+
+    pub async fn remove_watcher(&self, id: u32) -> Result<(), String> {
+        let mut watchers = self.watchers.lock().await;
+        if let Some(meta) = watchers.remove(&id) {
+            meta.token.cancel();
+            drop(watchers);
+            let _ = meta.handle.await;
+            Ok(())
+        } else {
+            Err("not found".into())
+        }
+    }
+
+    pub async fn shutdown(&mut self) -> Aggregated {
+        self.shutdown_token.cancel();
+        let mut watchers = self.watchers.lock().await;
+        let mut handles = Vec::new();
+        for (_, meta) in watchers.drain() {
+            meta.token.cancel();
+            handles.push(meta.handle);
+        }
+        drop(watchers);
+        for h in handles {
+            let _ = h.await;
+        }
+        self.consumer_handle.await.unwrap()
+    }
+}
+
+async fn watcher_task(
+    id: u32,
+    token: CancellationToken,
+    shutdown_token: CancellationToken,
+    tx: mpsc::Sender<Item>,
+    consecutive_failures: Arc<Mutex<u32>>,
+    healthy: Arc<Mutex<bool>>,
+) {
+    let mut interval = tokio::time::interval(Duration::from_millis(100));
+    interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+    loop {
+        tokio::select! {
+            _ = token.cancelled() => break,
+            _ = shutdown_token.cancelled() => break,
+            _ = interval.tick() => {}
+        }
+        match mock_fetch(id).await {
+            Ok(items) => {
+                *consecutive_failures.lock().await = 0;
+                *healthy.lock().await = true;
+                if !items.is_empty() {
+                    let item = Item {
+                        watcher_id: id,
+                        items,
+                        ts: tokio::time::Instant::now().elapsed().as_millis() as u64,
+                    };
+                    // backpressure: await if channel full
+                    if tx.send(item).await.is_err() {
+                        break;
+                    }
+                }
+            }
+            Err(e) => {
+                let mut fails = consecutive_failures.lock().await;
+                *fails += 1;
+                if *fails > 5 {
+                    *healthy.lock().await = false;
+                }
+                eprintln!("watcher {} error: {:?}", id, e);
+            }
+        }
+    }
+}
+
+async fn consumer_task(
+    mut rx: mpsc::Receiver<Item>,
+    shutdown_token: CancellationToken,
+    aggregated: Arc<Mutex<Aggregated>>,
+) -> Aggregated {
+    let mut agg = Aggregated::default();
+    loop {
+        tokio::select! {
+            _ = shutdown_token.cancelled() => break,
+            maybe_item = rx.recv() => {
+                match maybe_item {
+                    Some(item) => {
+                        agg.items.push(item);
+                        agg.total_count += 1;
+                        *aggregated.lock().await = agg.clone();
+                    }
+                    None => break,
+                }
+            }
+        }
+    }
+    agg
+}
+
+#[tokio::test]
+async fn test_manager_runs_and_shuts_down() {
+    let mut manager = WatcherManager::new(4).await;
+    tokio::time::sleep(Duration::from_millis(500)).await;
+    let agg = manager.shutdown().await;
+    assert!(agg.total_count > 0, "consumer should have received items");
+}
+
+#[tokio::test]
+async fn test_unhealthy_watcher() {
+    let mut manager = WatcherManager::new(0).await;
+    let id = manager.add_watcher_with_id(999).await;
+    tokio::time::sleep(Duration::from_millis(800)).await;
+    let watchers = manager.watchers.lock().await;
+    let meta = watchers.get(&id).expect("watcher exists");
+    let healthy = *meta.healthy.lock().await;
+    assert!(!healthy, "watcher should be marked unhealthy after >5 failures");
+    drop(watchers);
+    let _ = manager.shutdown().await;
+}
+
+#[tokio::test]
+async fn test_add_remove_concurrent() {
+    use std::sync::Arc;
+    let manager = Arc::new(Mutex::new(WatcherManager::new(0).await));
+    let mut handles = Vec::new();
+    for _ in 0..20 {
+        let m = manager.clone();
+        handles.push(tokio::spawn(async move {
+            let mut mgr = m.lock().await;
+            let id = mgr.add_watcher().await;
+            drop(mgr);
+            tokio::time::sleep(Duration::from_millis(5)).await;
+            let mut mgr = m.lock().await;
+            let _ = mgr.remove_watcher(id).await;
+        }));
+    }
+    for h in handles {
+        h.await.unwrap();
+    }
+    let mgr = manager.lock().await;
+    assert_eq!(mgr.watchers.lock().await.len(), 0);
+}