diff --git a/crates/jarvis-app/src/app.rs b/crates/jarvis-app/src/app.rs
index 0c48826..492d4cc 100644
--- a/crates/jarvis-app/src/app.rs
+++ b/crates/jarvis-app/src/app.rs
@@ -470,9 +470,8 @@ fn execute_command(text: &str, rt: &tokio::runtime::Runtime) -> bool {
 }
 
 
-pub fn close(code: i32, label: &'static str) {
-    eprintln!("[jarvis-app] app::close called: code={} label={}", code, label);
-    error!("Closing application: code={} label={}", code, label);
+pub fn close(code: i32) {
+    info!("Closing application.");
     voices::play_goodbye();
     ipc::send(IpcEvent::Stopping);
     std::process::exit(code);
diff --git a/crates/jarvis-app/src/main.rs b/crates/jarvis-app/src/main.rs
index 9a57830..f704a70 100644
--- a/crates/jarvis-app/src/main.rs
+++ b/crates/jarvis-app/src/main.rs
@@ -28,51 +28,54 @@ mod tray;
 static SHOULD_STOP: AtomicBool = AtomicBool::new(false);
 
 fn main() -> Result<(), String> {
-    eprintln!("[jarvis-app] step: init_dirs");
+    // initialize directories
     config::init_dirs()?;
 
-    eprintln!("[jarvis-app] step: init_logging");
+    // initialize logging
     log::init_logging()?;
 
+    // log some base info
     info!("Starting Jarvis v{} ...", config::APP_VERSION.unwrap());
     info!("Config directory is: {}", APP_CONFIG_DIR.get().unwrap().display());
     info!("Log directory is: {}", APP_LOG_DIR.get().unwrap().display());
 
-    eprintln!("[jarvis-app] step: db::init");
+    // initialize settings
     let settings = db::init();
 
+    // set global DB (for core modules that read settings at init time)
     DB.set(settings.arc().clone())
             .expect("DB already initialized");
 
-    eprintln!("[jarvis-app] step: voices::init");
+    // init voices
     let voice_id = settings.lock().voice.clone();
     let language = settings.lock().language.clone();
     if let Err(e) = voices::init(&voice_id, &language) {
         warn!("Failed to init voices: {}", e);
     }
 
-    eprintln!("[jarvis-app] step: i18n::init");
+    // init i18n
     i18n::init(&settings.lock().language);
 
-    eprintln!("[jarvis-app] step: llm_fallback::init");
+    // init LLM fallback (no-op if GROQ_TOKEN missing)
     llm_fallback::init();
 
-    eprintln!("[jarvis-app] step: recorder::init");
+    // init recorder
     if recorder::init().is_err() {
-        app::close(1, "recorder::init failed");
+        app::close(1);
     }
 
-    eprintln!("[jarvis-app] step: models::init");
+    // init models registry (scans available AI models)
     if let Err(e) = models::init() {
         warn!("Models registry init failed: {}", e);
     }
 
-    eprintln!("[jarvis-app] step: stt::init");
+    // init stt engine
     if stt::init().is_err() {
-        app::close(1, "stt::init failed");
+        // @TODO. Allow continuing even without STT, if commands is using keywords or smthng?
+        app::close(1); // cannot continue without stt
     }
 
-    eprintln!("[jarvis-app] step: commands::parse_commands");
+    // init commands
     info!("Initializing commands.");
     let cmds = match commands::parse_commands() {
         Ok(c) => c,
@@ -84,40 +87,41 @@ fn main() -> Result<(), String> {
     info!("Commands initialized. Count: {}, List: {:?}", cmds.len(), commands::list_paths(&cmds));
     COMMANDS_LIST.set(cmds).unwrap();
 
-    eprintln!("[jarvis-app] step: audio::init");
+    // init audio
     if audio::init().is_err() {
-        app::close(1, "audio::init failed");
+        // @TODO. Allow continuing even without audio?
+        app::close(1); // cannot continue without audio
     }
 
-    eprintln!("[jarvis-app] step: listener::init");
+    // init wake-word engine
     if let Err(e) = listener::init() {
         error!("Wake-word engine init failed: {}", e);
-        app::close(1, "listener::init failed");
+        app::close(1);
     }
 
-    eprintln!("[jarvis-app] step: tokio runtime");
+    // shared async runtime for intent classification, IPC, etc.
     let rt = Arc::new(
         tokio::runtime::Runtime::new().expect("Failed to create tokio runtime")
     );
 
-    eprintln!("[jarvis-app] step: intent::init");
+    // init intent-recognition engine
     rt.block_on(async {
         if let Err(e) = intent::init(COMMANDS_LIST.get().unwrap()).await {
             error!("Failed to initialize intent classifier: {}", e);
-            app::close(1, "intent::init failed");
+            app::close(1);
         }
     });
 
-    eprintln!("[jarvis-app] step: slots::init");
+    // init slots parsing engine
     slots::init().map_err(|e| error!("Slot extraction init failed: {}", e)).ok();
 
-    eprintln!("[jarvis-app] step: audio_processing::init");
+    // init audio processing
     info!("Initializing audio processing...");
     if let Err(e) = audio_processing::init() {
         warn!("Audio processing init failed: {}", e);
     }
 
-    eprintln!("[jarvis-app] step: ipc::init");
+    // init IPC
     info!("Initializing IPC...");
     ipc::init();
 
@@ -157,16 +161,14 @@ fn main() -> Result<(), String> {
         ipc_rt.block_on(ipc::start_server());
     });
     
-    eprintln!("[jarvis-app] step: spawn app thread");
+    // start the app (in the background thread)
     let app_rt = Arc::clone(&rt);
     std::thread::spawn(move || {
         let _ = app::start(text_cmd_rx, &app_rt);
     });
 
-    eprintln!("[jarvis-app] step: tray::init_blocking");
     tray::init_blocking(settings);
 
-    eprintln!("[jarvis-app] step: main returning Ok");
     Ok(())
 }