refactor(runtime): retire runtime console prints for the writer, tracing, and typed events

crates/mesh-client/src/models/catalog.rs

@@ -1,4 +1,5 @@
 use serde::Deserialize;
+use std::io::Write;
 use std::sync::LazyLock;
 
 #[derive(Clone, Debug, Deserialize)]
@@ -106,17 +107,21 @@ pub fn huggingface_repo_url(url: &str) -> Option<String> {
 }
 
 pub fn list_models() {
-    eprintln!("Available models:");
-    eprintln!();
+    let _ = writeln!(std::io::stderr(), "Available models:");
+    let _ = writeln!(std::io::stderr());
     for m in MODEL_CATALOG.iter() {
         let draft_info = if let Some(d) = m.draft.as_deref() {
             format!(" (draft: {})", d)
         } else {
             String::new()
         };
-        eprintln!(
+        let _ = writeln!(
+            std::io::stderr(),
             "  {:40} {:>6}  {}{}",
-            m.name, m.size, m.description, draft_info
+            m.name,
+            m.size,
+            m.description,
+            draft_info
         );
     }
 }

crates/mesh-llm-events/src/lib.rs

@@ -571,6 +571,13 @@ pub enum OutputEvent {
         model: String,
         target: String,
     },
+    NostrPublishing {
+        message: String,
+    },
+    AutoUpdate {
+        message: String,
+        version: Option<String>,
+    },
     Warning {
         message: String,
         context: Option<String>,
@@ -636,6 +643,8 @@ impl OutputEvent {
             OutputEvent::RuntimeReady { .. } => "ready",
             OutputEvent::ModelDownloadProgress { .. } => "model_download_progress",
             OutputEvent::RequestRouted { .. } => "request_routed",
+            OutputEvent::NostrPublishing { .. } => "nostr_publishing",
+            OutputEvent::AutoUpdate { .. } => "auto_update",
             OutputEvent::Warning { .. } => "warning",
             OutputEvent::Error { .. } => "error",
             OutputEvent::Fatal { .. } => "fatal",
@@ -657,6 +666,8 @@ impl OutputEvent {
             OutputEvent::Warning { .. } => OutputLevel::Warn,
             OutputEvent::Error { .. } => OutputLevel::Error,
             OutputEvent::Fatal { .. } => OutputLevel::Fatal,
+            OutputEvent::NostrPublishing { .. } => OutputLevel::Info,
+            OutputEvent::AutoUpdate { .. } => OutputLevel::Info,
             _ => OutputLevel::Info,
         }
     }
@@ -815,6 +826,8 @@ impl OutputEvent {
             OutputEvent::RequestRouted { model, target } => {
                 format!("routed request for {model} to {target}")
             }
+            OutputEvent::NostrPublishing { message } => message.clone(),
+            OutputEvent::AutoUpdate { message, .. } => message.clone(),
             OutputEvent::Warning { message, .. } => message.clone(),
             OutputEvent::Error { message, .. } => message.clone(),
             OutputEvent::Fatal { message, .. } => message.clone(),

crates/mesh-llm-host-runtime/src/inference/skippy/materialization/package_download.rs

@@ -156,11 +156,13 @@ impl LayerPackageDownloadScope {
         bytes_per_sec: Option<f64>,
         force: bool,
     ) {
+        let mut err = mesh_llm_events::console_err();
         let Ok(mut scope_state) = self.state.lock() else {
             return;
         };
         if !scope_state.announced {
-            eprintln!(
+            let _ = writeln!(
+                err,
                 "\r\x1b[K📦 Downloading layer package {} ({} file(s))",
                 self.package, self.total_files
             );
@@ -204,11 +206,11 @@ impl LayerPackageDownloadScope {
             ),
             3,
         );
-        eprint!("\r\x1b[K   {gauge}");
-        let _ = std::io::stderr().flush();
+        let _ = write!(err, "\r\x1b[K   {gauge}");
+        let _ = err.flush();
         scope_state.drawn_line = true;
         if force {
-            eprintln!();
+            let _ = writeln!(err);
             scope_state.drawn_line = false;
         }
     }
@@ -275,6 +277,7 @@ impl LayerPackageDownloadProgress {
     }
 
     fn emit_ready(&self, path: &Path) {
+        let mut err = mesh_llm_events::console_err();
         let total = fs::metadata(path)
             .ok()
             .map(|metadata| metadata.len())
@@ -313,12 +316,17 @@ impl LayerPackageDownloadProgress {
         if !showed_progress {
             let file = layer_package_artifact_display(&self.label, &self.file);
             match total {
-                Some(total) if total > 0 => eprintln!(
-                    "   ✅ Ready {} ({})",
-                    file,
-                    format_layer_package_download_bytes(total)
-                ),
-                _ => eprintln!("   ✅ Ready {}", file),
+                Some(total) if total > 0 => {
+                    let _ = writeln!(
+                        err,
+                        "   ✅ Ready {} ({})",
+                        file,
+                        format_layer_package_download_bytes(total)
+                    );
+                }
+                _ => {
+                    let _ = writeln!(err, "   ✅ Ready {}", file);
+                }
             }
         }
     }
@@ -479,6 +487,7 @@ fn draw_layer_package_file_progress(
     bytes_per_sec: Option<f64>,
     force: bool,
 ) {
+    let mut err = mesh_llm_events::console_err();
     let percent = if total == 0 {
         0
     } else {
@@ -515,10 +524,10 @@ fn draw_layer_package_file_progress(
         ),
         3,
     );
-    eprint!("\r\x1b[K   {gauge}");
-    let _ = std::io::stderr().flush();
+    let _ = write!(err, "\r\x1b[K   {gauge}");
+    let _ = err.flush();
     if force {
-        eprintln!();
+        let _ = writeln!(err);
     }
 }
 

crates/mesh-llm-host-runtime/src/models/catalog.rs

@@ -357,6 +357,7 @@ impl MeshDownloadProgress {
     }
 
     fn draw(state: &mut MeshDownloadProgressState, force: bool) {
+        let mut err = mesh_llm_events::console_err();
         if !force && state.downloaded == 0 && state.total == 0 {
             return;
         }
@@ -408,7 +409,8 @@ impl MeshDownloadProgress {
             ),
         };
         let bar = render_inline_progress_bar(ratio, DOWNLOAD_PROGRESS_BAR_WIDTH);
-        eprint!(
+        let _ = write!(
+            err,
             "\r\x1b[KDownloading  {:>3}.{:01}%  {}  {} / {}{}",
             percent_major,
             percent_minor,
@@ -418,7 +420,7 @@ impl MeshDownloadProgress {
             speed_suffix,
         );
         state.drawn_line = true;
-        let _ = std::io::stderr().flush();
+        let _ = err.flush();
     }
 
     fn apply_download_event(state: &mut MeshDownloadProgressState, event: &DownloadEvent) {
@@ -566,6 +568,7 @@ fn download_hf_assets_sync(
     assets: Vec<HfAsset>,
     progress: bool,
 ) -> Result<HfAssetsDownload> {
+    let mut console = mesh_llm_events::console_err();
     let api = super::build_hf_api(false)?;
     let mut download_plan = initial_download_plan_for_assets(assets)?;
     let current_plan: Vec<(bool, HfAsset)> = download_plan.iter().cloned().collect();
@@ -592,7 +595,9 @@ fn download_hf_assets_sync(
             None,
             None,
             ModelProgressStatus::Ensuring,
-            || eprintln!("📥 Ensuring {} is available locally...", label),
+            || {
+                let _ = writeln!(console, "📥 Ensuring {} is available locally...", label);
+            },
         );
     }
 
@@ -649,7 +654,9 @@ fn download_hf_assets_sync(
                 None,
                 None,
                 ModelProgressStatus::Ensuring,
-                || eprintln!("   📥 Ensuring model {}", asset.file),
+                || {
+                    let _ = writeln!(console, "   📥 Ensuring model {}", asset.file);
+                },
             );
         }
         let visible_tracker = if progress && required {
@@ -743,6 +750,7 @@ fn emit_completed_asset_progress(
     path: &Path,
     visible_tracker: Option<&Arc<MeshDownloadProgress>>,
 ) {
+    let mut err = mesh_llm_events::console_err();
     if required && interactive_tui_active() {
         emit_required_asset_ready_progress(label, asset_file, path, visible_tracker);
     } else if interactive_tui_active() {
@@ -752,7 +760,9 @@ fn emit_completed_asset_progress(
             None,
             None,
             ModelProgressStatus::Ready,
-            || eprintln!("   Downloaded model metadata {asset_file}"),
+            || {
+                let _ = writeln!(err, "   Downloaded model metadata {asset_file}");
+            },
         );
     }
 }
@@ -763,6 +773,7 @@ fn emit_required_asset_ready_progress(
     path: &Path,
     visible_tracker: Option<&Arc<MeshDownloadProgress>>,
 ) {
+    let mut err = mesh_llm_events::console_err();
     let showed_progress =
         visible_tracker.is_some_and(|tracker| tracker.showed_meaningful_progress());
     if showed_progress {
@@ -772,7 +783,9 @@ fn emit_required_asset_ready_progress(
             None,
             None,
             ModelProgressStatus::Ready,
-            || eprintln!("   ✅ Ready {asset_file}"),
+            || {
+                let _ = writeln!(err, "   ✅ Ready {asset_file}");
+            },
         );
     } else if let Ok(meta) = std::fs::metadata(path) {
         emit_or_print_model_progress(
@@ -782,11 +795,12 @@ fn emit_required_asset_ready_progress(
             Some(meta.len()),
             ModelProgressStatus::Ready,
             || {
-                eprintln!(
+                let _ = writeln!(
+                    err,
                     "   ✅ Ready {} ({})",
                     asset_file,
                     format_download_bytes(meta.len())
-                )
+                );
             },
         );
     } else {
@@ -796,7 +810,9 @@ fn emit_required_asset_ready_progress(
             None,
             None,
             ModelProgressStatus::Ready,
-            || eprintln!("   ✅ Ready {asset_file}"),
+            || {
+                let _ = writeln!(err, "   ✅ Ready {asset_file}");
+            },
         );
     }
 }
@@ -839,11 +855,13 @@ fn print_multipart_terminal_progress(
     progress: &MultipartDownloadProgress,
     terminal_frame_mode: MultipartTerminalFrameMode,
 ) {
-    eprint!(
+    let mut err = mesh_llm_events::console_err();
+    let _ = write!(
+        err,
         "{}",
         multipart_progress_terminal_frame(progress, terminal_frame_mode)
     );
-    let _ = std::io::stderr().flush();
+    let _ = err.flush();
 }
 
 fn multipart_progress_terminal_frame(