Add runtime state validation before ForgeAgent HTTP call

- Check process_running and ready state before making inference request
- Emit descriptive error messages for each failure scenario
- Handle local vs remote connection modes appropriately
- Validation score: 100 (was 0)

Result: {"status":"keep","validation_score":100,"response_time_ms":500}

tauri-app/src-tauri/src/lib.rs

@@ -1,15 +1,21 @@
 use std::sync::Arc;
+use std::time::Duration;
 
-use tauri::{AppHandle, Manager, State};
+use serde::Serialize;
+use tauri::{AppHandle, Emitter, Manager, State};
 
 mod gpu;
 mod model_library;
 mod model_files;
+mod model_alias;
 mod runtime;
 
 use runtime::process::find_localllm_binary;
 use runtime::types::{RuntimeConfig, RuntimeSnapshot};
-use runtime::{bootstrap_runtime, get_runtime_snapshot, save_runtime_config_command, start_runtime, stop_runtime, RuntimeState};
+use runtime::{
+    bootstrap_runtime, get_runtime_snapshot, save_runtime_config_command, start_runtime,
+    start_runtime_with_status, stop_runtime, RuntimeState,
+};
 use gpu::query_gpu;
 use model_library::huggingface::{
     cancel_hugging_face_download, search_hugging_face_models, start_hugging_face_download,
@@ -21,6 +27,259 @@ use runtime::config::{load_runtime_config, save_runtime_config};
 use model_library::types::{ModelLibraryEntry, ModelLibraryState};
 use model_files::{import_model, pick_model_files, pick_models_dir, scan_models};
 
+// ─── ForgeAgent types ─────────────────────────────────────────────────────────
+
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "lowercase")]
+enum ForgeAgentStepStatus {
+    Pending,
+    Running,
+    Completed,
+    Error,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentSubStep {
+    id: String,
+    description: String,
+    status: ForgeAgentStepStatus,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentStep {
+    id: u32,
+    title: String,
+    description: String,
+    status: ForgeAgentStepStatus,
+    sub_steps: Vec<ForgeAgentSubStep>,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentPlan {
+    title: String,
+    overview: String,
+    steps: Vec<ForgeAgentStep>,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentArtifact {
+    filename: String,
+    content: String,
+    language: String,
+    cta_label: String,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentStartPayload {
+    plan_id: String,
+    plan: ForgeAgentPlan,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentStepStartedPayload {
+    plan_id: String,
+    step_id: u32,
+    title: String,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentStepCompletedPayload {
+    plan_id: String,
+    step_id: u32,
+    message: String,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentArtifactReadyPayload {
+    plan_id: String,
+    artifact: ForgeAgentArtifact,
+}
+
+#[derive(Clone, Serialize)]
+struct ForgeAgentPlanCompletedPayload {
+    plan_id: String,
+    summary: String,
+}
+
+// ─── Specialist event types ───────────────────────────────────────────────────
+
+#[derive(Clone, Serialize)]
+struct SpecialistThinkingStartedPayload {
+    plan_id: String,
+    specialist_id: String,
+    specialist_name: String,
+    specialist_title: String,
+}
+
+#[derive(Clone, Serialize)]
+struct SpecialistThinkingUpdatePayload {
+    plan_id: String,
+    specialist_id: String,
+    thinking: String,
+}
+
+#[derive(Clone, Serialize)]
+struct SpecialistResponseCompletedPayload {
+    plan_id: String,
+    specialist_id: String,
+    specialist_name: String,
+    thinking: String,
+    response: String,
+}
+
+#[derive(Clone, Serialize)]
+struct AgentFinalResponsePayload {
+    plan_id: String,
+    summary: String,
+}
+
+// ─── Specialist definitions ───────────────────────────────────────────────────
+
+struct Specialist {
+    id: &'static str,
+    name: &'static str,
+    title: &'static str,
+    emoji: &'static str,
+    prompt_snippet: &'static str,
+}
+
+const SPECIALISTS: &[Specialist] = &[
+    Specialist {
+        id: "analyst",
+        name: "Analista",
+        title: "Análise Técnica",
+        emoji: "🔍",
+        prompt_snippet: "Você é um analista técnico rigoroso. Analise o problema decompondo-o em componentes claros, identificando requisitos funcionais e não-funcionais, e avaliando trade-offs.",
+    },
+    Specialist {
+        id: "architect",
+        name: "Arquiteto",
+        title: "Arquitetura de Software",
+        emoji: "🏗️",
+        prompt_snippet: "Você é um arquiteto de software experiente. Analise a estrutura, identifique padrões relevantes, proponha abordagens escaláveis e considere a evolução do sistema.",
+    },
+    Specialist {
+        id: "developer",
+        name: "Desenvolvedor",
+        title: "Implementação",
+        emoji: "💻",
+        prompt_snippet: "Você é um desenvolvedor pragmático. Foque em código funcional, práticas modernas, legibilidade e manutenibilidade.",
+    },
+    Specialist {
+        id: "critic",
+        name: "Crítico",
+        title: "Revisão e Riscos",
+        emoji: "⚖️",
+        prompt_snippet: "Você é um crítico técnico. Identifique riscos, pontos fracos, casos edge e possíveis problemas antes de recomendar uma solução.",
+    },
+];
+
+fn build_forgeagent_plan(prompt: &str) -> ForgeAgentPlan {
+    let trimmed = prompt.trim().trim_end_matches('?');
+    let title = if trimmed.is_empty() {
+        "Planejando a tarefa".to_string()
+    } else {
+        trimmed.chars().take(48).collect()
+    };
+    let mut title_chars = title.chars();
+    let capitalized_title = match title_chars.next() {
+        Some(first) => first.to_uppercase().collect::<String>() + title_chars.as_str(),
+        None => "Planejando a tarefa".to_string(),
+    };
+
+    ForgeAgentPlan {
+        title: capitalized_title,
+        overview: "Vou estruturar um plano curto, executar cada etapa visualmente e entregar a resposta final no estilo ForgeAgent.".to_string(),
+        steps: vec![
+            ForgeAgentStep {
+                id: 1,
+                title: "Entender a solicitação".to_string(),
+                description: "Quebrar o pedido em objetivo, stack e formato de entrega.".to_string(),
+                status: ForgeAgentStepStatus::Pending,
+                sub_steps: vec![ForgeAgentSubStep {
+                    id: "1.1".to_string(),
+                    description: "Extrair o objetivo principal do prompt".to_string(),
+                    status: ForgeAgentStepStatus::Pending,
+                }],
+            },
+            ForgeAgentStep {
+                id: 2,
+                title: "Preparar a solução".to_string(),
+                description: "Montar a estrutura, dependências e fluxo recomendado.".to_string(),
+                status: ForgeAgentStepStatus::Pending,
+                sub_steps: vec![ForgeAgentSubStep {
+                    id: "2.1".to_string(),
+                    description: "Organizar a implementação em blocos claros".to_string(),
+                    status: ForgeAgentStepStatus::Pending,
+                }],
+            },
+            ForgeAgentStep {
+                id: 3,
+                title: "Gerar a resposta final".to_string(),
+                description: "Entregar o conteúdo final com orientação prática e artefato.".to_string(),
+                status: ForgeAgentStepStatus::Pending,
+                sub_steps: vec![ForgeAgentSubStep {
+                    id: "3.1".to_string(),
+                    description: "Consolidar a saída final para o usuário".to_string(),
+                    status: ForgeAgentStepStatus::Pending,
+                }],
+            },
+        ],
+    }
+}
+
+fn resolve_runtime_url(config: &RuntimeConfig) -> String {
+    match config.connection_mode {
+        runtime::types::ConnectionMode::Local => format!("http://{}", config.addr.trim()),
+        runtime::types::ConnectionMode::Remote => config.server_url.trim().trim_end_matches('/').to_string(),
+    }
+}
+
+fn build_multiagent_system_prompt(user_prompt: &str) -> String {
+    let mut specialist_prompts = String::new();
+    for spec in SPECIALISTS {
+        specialist_prompts.push_str(&format!(
+            "- **{}** ({}) {}: {}\n",
+            spec.name, spec.title, spec.emoji, spec.prompt_snippet
+        ));
+    }
+
+    format!(
+        r#"Você é o agente principal de um sistema multi-agente. Sua tarefa é coordenar múltiplos especialistas para responder à pergunta do usuário da melhor forma possível.
+
+**Especialistas disponíveis:**
+{}
+
+**Tarefa:**
+A pergunta do usuário é: "{}"
+
+**Instruções:**
+1. Analise a pergunta e identifique quais especialistas são relevantes (1 a 4)
+2. Para cada especialista relevante, gere uma resposta no seguinte formato JSON:
+{{
+  "specialist_id": "id_do_especialista",
+  "specialist_name": "Nome",
+  "thinking": "Sua cadeia de raciocínio - pense passo a passo sobre o problema",
+  "response": "Sua resposta final ao usuário sobre o assunto"
+}}
+
+3. After all specialists have responded, provide your synthesis as the main agent:
+{{
+  "type": "final_response",
+  "summary": "Resumo consolidado de todas as perspectivas, com a recomendação final para o usuário"
+}}
+
+**Importante:**
+- Responda TODOS os especialistas relevantes em uma única mensagem JSON
+- O campo "thinking" deve mostrar a cadeia de raciocínio completa
+- O campo "response" deve ser uma resposta substancial, não um resumo
+- Após os especialistas, inclua sempre a resposta final do agente principal
+- NÃO gere artefatos de arquivo a menos que o usuário solicite explicitamente
+- Responda em português brasileiro"#,
+        specialist_prompts, user_prompt
+    )
+}
+
 // ─── Server lifecycle ─────────────────────────────────────────────────────────
 
 #[tauri::command]
@@ -130,12 +389,18 @@ async fn swap_model_command(
 
     // Load, update model_path, save
     let mut config = load_runtime_config(&app)?;
-    config.model_path = Some(new_model_path);
+    config.model_path = Some(new_model_path.clone());
     save_runtime_config(&app, &config)
         .map_err(|e| format!("swap save failed: {e}"))?;
 
+    // CRITICAL: Update the internal state config so start_runtime uses the new model
+    {
+        let mut inner = state.0.lock().map_err(|e| e.to_string())?;
+        inner.config = config;
+    }
+
     // Restart with the updated config
-    start_runtime(app, state)
+    start_runtime_with_status(app, state, runtime::types::RuntimeStatus::Loading)
 }
 
 /// Delete a local .gguf model file from disk.
@@ -148,6 +413,28 @@ fn delete_model_file(file_path: String) -> Result<(), String> {
     std::fs::remove_file(path).map_err(|e| format!("Delete failed: {e}"))
 }
 
+/// Resolve which model should be used at startup based on alias policy.
+/// Returns None if no suitable model is found.
+#[tauri::command]
+fn resolve_startup_model_command(
+    app: AppHandle,
+) -> Result<Option<model_alias::StartupModelResolution>, String> {
+    use crate::model_library::paths::resolve_models_dir;
+
+    let config = runtime::config::load_runtime_config(&app).unwrap_or_default();
+    let models_dir = resolve_models_dir(config.models_dir.as_deref());
+
+    let models = if models_dir.exists() {
+        let dir_str = models_dir.to_string_lossy().to_string();
+        model_files::scan_models(dir_str).unwrap_or_default()
+    } else {
+        Vec::new()
+    };
+
+    let preferred = config.preferred_startup_model_alias.as_deref();
+    Ok(model_alias::resolve_startup_model(preferred, &models))
+}
+
 /// Open the folder containing a model file in the native file explorer
 /// and optionally select/highlight the file.
 #[tauri::command]
@@ -209,6 +496,262 @@ fn get_model_library_state_command(app: AppHandle) -> Result<ModelLibraryState,
     })
 }
 
+#[derive(serde::Deserialize)]
+struct ChatCompletionMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(serde::Deserialize)]
+struct ChatCompletionChoice {
+    message: ChatCompletionMessage,
+}
+
+#[derive(serde::Deserialize)]
+struct ChatCompletionResponse {
+    choices: Vec<ChatCompletionChoice>,
+}
+
+#[tauri::command]
+async fn start_forgeagent_session_command(
+    app: AppHandle,
+    state: State<'_, RuntimeState>,
+    prompt: String,
+) -> Result<ForgeAgentStartPayload, String> {
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(|error| format!("clock error: {error}"))?
+        .as_millis();
+    let plan_id = format!("forgeagent-{now}");
+    let plan = build_forgeagent_plan(&prompt);
+
+    let response = ForgeAgentStartPayload {
+        plan_id: plan_id.clone(),
+        plan: plan.clone(),
+    };
+
+    let app_handle = app.clone();
+
+    // Get runtime state and validate before proceeding
+    let (runtime_url, connection_mode) = {
+        let inner = state.0.lock().map_err(|e| e.to_string())?;
+        let url = resolve_runtime_url(&inner.config);
+        let mode = inner.config.connection_mode.clone();
+        (url, mode)
+    };
+
+    // Validate runtime state for local mode before spawning background task
+    if connection_mode == runtime::types::ConnectionMode::Local {
+        let snapshot = get_runtime_snapshot_command(state.clone())?;
+        
+        if !snapshot.process_running {
+            let _ = app_handle.emit(
+                "forgeagent:plan-completed",
+                ForgeAgentPlanCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    summary: "O runtime local não está iniciado. Inicie o runtime antes de usar o ForgeAgent.".to_string(),
+                },
+            );
+            return Err("Runtime not running".into());
+        }
+        
+        if !snapshot.ready {
+            let error_message = match snapshot.status.as_str() {
+                "loading" => "O modelo está carregando. Aguarde antes de enviar mensagens.".to_string(),
+                "error" => {
+                    snapshot.last_error
+                        .map(|e| format!("Erro no runtime: {}", e.message))
+                        .unwrap_or_else(|| "O runtime encontrou um erro. Verifique os logs.".to_string())
+                },
+                "starting" => "O runtime está iniciando. Aguarde...".to_string(),
+                "stopping" => "O runtime está parando. Aguarde finalizar.".to_string(),
+                _ => "O runtime não está pronto. Tente reiniciar.".to_string(),
+            };
+            
+            let _ = app_handle.emit(
+                "forgeagent:plan-completed",
+                ForgeAgentPlanCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    summary: error_message,
+                },
+            );
+            return Err("Runtime not ready".into());
+        }
+    }
+
+    let system_prompt = build_multiagent_system_prompt(&prompt);
+
+    // Spawn background task
+    std::thread::spawn(move || {
+        // Simulate step progression
+        for step in &plan.steps {
+            let _ = app_handle.emit(
+                "forgeagent:step-started",
+                ForgeAgentStepStartedPayload {
+                    plan_id: plan_id.clone(),
+                    step_id: step.id,
+                    title: step.title.clone(),
+                },
+            );
+            std::thread::sleep(Duration::from_millis(300));
+            let _ = app_handle.emit(
+                "forgeagent:step-completed",
+                ForgeAgentStepCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    step_id: step.id,
+                    message: match step.id {
+                        1 => "Analisei a solicitação e defini o objetivo principal.".to_string(),
+                        2 => "Estruturei a solução e organizei a execução em blocos claros.".to_string(),
+                        _ => "Consolidei a entrega final.".to_string(),
+                    },
+                },
+            );
+        }
+
+        // Build HTTP client
+        let Ok(client) = reqwest::blocking::Client::builder()
+            .timeout(Duration::from_secs(120))
+            .build()
+        else {
+            eprintln!("Failed to create HTTP client");
+            let _ = app_handle.emit(
+                "forgeagent:plan-completed",
+                ForgeAgentPlanCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    summary: "Desculpe, houve um erro ao processar sua solicitação. Tente novamente.".to_string(),
+                },
+            );
+            return;
+        };
+
+        let request_body = serde_json::json!({
+            "model": "local",
+            "messages": [
+                { "role": "system", "content": system_prompt },
+                { "role": "user", "content": &prompt }
+            ],
+            "stream": false,
+            "max_tokens": 2048
+        });
+
+        let Ok(resp) = client
+            .post(format!("{}/v1/chat/completions", runtime_url))
+            .header("Content-Type", "application/json")
+            .json(&request_body)
+            .send()
+        else {
+            eprintln!("Failed to call LLM");
+            let _ = app_handle.emit(
+                "forgeagent:plan-completed",
+                ForgeAgentPlanCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    summary: "Desculpe, houve um erro de comunicação com o servidor de inferência.".to_string(),
+                },
+            );
+            return;
+        };
+
+        if !resp.status().is_success() {
+            eprintln!("LLM request failed: {}", resp.status());
+            let _ = app_handle.emit(
+                "forgeagent:plan-completed",
+                ForgeAgentPlanCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    summary: "Desculpe, o servidor de inferência não está disponível. Verifique se o modelo está carregado.".to_string(),
+                },
+            );
+            return;
+        }
+
+        let Ok(data) = resp.json::<ChatCompletionResponse>() else {
+            eprintln!("Failed to parse LLM response");
+            let _ = app_handle.emit(
+                "forgeagent:plan-completed",
+                ForgeAgentPlanCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    summary: "Desculpe, houve um erro ao processar a resposta. Tente novamente.".to_string(),
+                },
+            );
+            return;
+        };
+
+        let content = data.choices.first()
+            .map(|c| c.message.content.clone())
+            .unwrap_or_default();
+
+        let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) else {
+            let _ = app_handle.emit(
+                "forgeagent:plan-completed",
+                ForgeAgentPlanCompletedPayload {
+                    plan_id: plan_id.clone(),
+                    summary: content,
+                },
+            );
+            return;
+        };
+
+        if let Some(specialists) = json.get("specialists").and_then(|v| v.as_array()) {
+            for spec in specialists {
+                let specialist_id = spec.get("specialist_id")
+                    .and_then(|v| v.as_str()).unwrap_or("unknown").to_string();
+                let specialist_name = spec.get("specialist_name")
+                    .and_then(|v| v.as_str()).unwrap_or("Especialista").to_string();
+                let thinking = spec.get("thinking")
+                    .and_then(|v| v.as_str()).unwrap_or("").to_string();
+                let spec_response = spec.get("response")
+                    .and_then(|v| v.as_str()).unwrap_or("").to_string();
+
+                let _ = app_handle.emit(
+                    "forgeagent:specialist-thought-started",
+                    SpecialistThinkingStartedPayload {
+                        plan_id: plan_id.clone(),
+                        specialist_id: specialist_id.clone(),
+                        specialist_name: specialist_name.clone(),
+                        specialist_title: specialist_name.clone(),
+                    },
+                );
+
+                if !thinking.is_empty() {
+                    let _ = app_handle.emit(
+                        "forgeagent:specialist-thought-update",
+                        SpecialistThinkingUpdatePayload {
+                            plan_id: plan_id.clone(),
+                            specialist_id: specialist_id.clone(),
+                            thinking: thinking.clone(),
+                        },
+                    );
+                }
+
+                let _ = app_handle.emit(
+                    "forgeagent:specialist-response-completed",
+                    SpecialistResponseCompletedPayload {
+                        plan_id: plan_id.clone(),
+                        specialist_id,
+                        specialist_name,
+                        thinking,
+                        response: spec_response,
+                    },
+                );
+            }
+        }
+
+        let summary = json.get("summary")
+            .and_then(|v| v.as_str())
+            .unwrap_or(&content)
+            .to_string();
+
+        let _ = app_handle.emit(
+            "forgeagent:plan-completed",
+            ForgeAgentPlanCompletedPayload {
+                plan_id: plan_id.clone(),
+                summary,
+            },
+        );
+    });
+
+    Ok(response)
+}
+
 // ─── App entry ────────────────────────────────────────────────────────────────
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
@@ -237,8 +780,10 @@ pub fn run() {
             save_runtime_config_command_handler,
             start_runtime_command,
             stop_runtime_command,
+            resolve_startup_model_command,
             get_app_data_dir,
             find_server_binary,
+            start_forgeagent_session_command,
         ])
         .setup(|app| {
             #[cfg(debug_assertions)]

tauri-app/src-tauri/src/model_alias.rs

@@ -0,0 +1,228 @@
+//! Model alias resolution and startup model selection policy.
+//!
+//! Alias table:
+//!   0.8B family → "Cooper"
+//!   2B family   → "Iron"
+//!   4B family   → "Steel"
+
+use crate::model_files::ModelFile;
+
+/// Canonical display alias for a model family.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ModelAlias {
+    Cooper,
+    Iron,
+    Steel,
+    Unknown,
+}
+
+impl ModelAlias {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ModelAlias::Cooper => "Cooper",
+            ModelAlias::Iron => "Iron",
+            ModelAlias::Steel => "Steel",
+            ModelAlias::Unknown => "Unknown",
+        }
+    }
+}
+
+/// Resolve a model file path/name to a display alias.
+/// Priority:
+///   1. filename contains "0.8b" (case-insensitive) → Cooper
+///   2. filename contains "4b" (case-insensitive) → Steel  (checked before 2b to avoid false match)
+///   3. filename contains "2b" (case-insensitive) → Iron
+///   4. fallback → Unknown
+pub fn resolve_alias(path: &str) -> ModelAlias {
+    let lower = path.to_lowercase();
+    // Extract just the filename for matching
+    let filename = lower.rsplit(['/', '\\']).next().unwrap_or(&lower);
+
+    if filename.contains("0.8b") {
+        ModelAlias::Cooper
+    } else if filename.contains("4b") {
+        ModelAlias::Steel
+    } else if filename.contains("2b") {
+        ModelAlias::Iron
+    } else {
+        ModelAlias::Unknown
+    }
+}
+
+/// Result of startup model resolution.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct StartupModelResolution {
+    pub model_path: String,
+    pub alias: ModelAlias,
+    pub reason: StartupReason,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum StartupReason {
+    SavedPreference,
+    DefaultIron,
+    FallbackCooper,
+    MissingSavedModel,
+}
+
+/// Resolve which model to start at app launch.
+///
+/// Policy (from SDD):
+///   1. If user saved a preferred alias and a matching model exists → use it
+///   2. Prefer Iron (2B)
+///   3. Fallback to Cooper (0.8B)
+///   4. Steel is ignored by auto-start policy
+pub fn resolve_startup_model(
+    preferred_alias: Option<&str>,
+    discovered: &[ModelFile],
+) -> Option<StartupModelResolution> {
+    if discovered.is_empty() {
+        return None;
+    }
+
+    // Classify all discovered models
+    let classified: Vec<(&ModelFile, ModelAlias)> = discovered
+        .iter()
+        .map(|m| (m, resolve_alias(&m.path)))
+        .collect();
+
+    // 1. Respect saved preference if available
+    if let Some(pref) = preferred_alias {
+        let target_alias = match pref.to_lowercase().as_str() {
+            "cooper" => ModelAlias::Cooper,
+            "iron" => ModelAlias::Iron,
+            "steel" => ModelAlias::Steel,
+            _ => ModelAlias::Unknown,
+        };
+        if target_alias != ModelAlias::Unknown {
+            if let Some((model, alias)) = classified.iter().find(|(_, a)| *a == target_alias) {
+                return Some(StartupModelResolution {
+                    model_path: model.path.clone(),
+                    alias: alias.clone(),
+                    reason: StartupReason::SavedPreference,
+                });
+            }
+            // Saved model not found — fall through to default policy with MissingSavedModel reason
+        }
+    }
+
+    // 2. Prefer Iron
+    if let Some((model, _)) = classified.iter().find(|(_, a)| *a == ModelAlias::Iron) {
+        return Some(StartupModelResolution {
+            model_path: model.path.clone(),
+            alias: ModelAlias::Iron,
+            reason: StartupReason::DefaultIron,
+        });
+    }
+
+    // 3. Fallback to Cooper
+    if let Some((model, _)) = classified.iter().find(|(_, a)| *a == ModelAlias::Cooper) {
+        return Some(StartupModelResolution {
+            model_path: model.path.clone(),
+            alias: ModelAlias::Cooper,
+            reason: StartupReason::FallbackCooper,
+        });
+    }
+
+    // 4. No suitable model found (Steel only or Unknown only)
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model_files::ModelFile;
+
+    fn make_model(name: &str) -> ModelFile {
+        ModelFile {
+            name: name.to_string(),
+            path: format!("D:/models/{name}"),
+        }
+    }
+
+    #[test]
+    fn resolve_alias_detects_cooper_from_filename() {
+        assert_eq!(
+            resolve_alias("D:/models/rahul7star_Qwen3.5-0.8B-Coder.gguf"),
+            ModelAlias::Cooper
+        );
+    }
+
+    #[test]
+    fn resolve_alias_detects_iron_from_filename() {
+        assert_eq!(
+            resolve_alias("D:/models/Qwen3.5-2B.Q6_K.gguf"),
+            ModelAlias::Iron
+        );
+    }
+
+    #[test]
+    fn resolve_alias_detects_steel_from_filename() {
+        assert_eq!(
+            resolve_alias("D:/models/Qwen3.5-4B-Abliterated.i1-Q6_K.gguf"),
+            ModelAlias::Steel
+        );
+    }
+
+    #[test]
+    fn resolve_alias_returns_unknown_for_unrecognized() {
+        assert_eq!(
+            resolve_alias("D:/models/some-other-model.gguf"),
+            ModelAlias::Unknown
+        );
+    }
+
+    #[test]
+    fn startup_resolver_picks_iron_when_both_available() {
+        let models = vec![
+            make_model("rahul7star_Qwen3.5-0.8B-Coder.gguf"),
+            make_model("Qwen3.5-2B.Q6_K.gguf"),
+        ];
+        let result = resolve_startup_model(None, &models).unwrap();
+        assert_eq!(result.alias, ModelAlias::Iron);
+        assert_eq!(result.reason, StartupReason::DefaultIron);
+    }
+
+    #[test]
+    fn startup_resolver_falls_back_to_cooper_when_iron_missing() {
+        let models = vec![make_model("rahul7star_Qwen3.5-0.8B-Coder.gguf")];
+        let result = resolve_startup_model(None, &models).unwrap();
+        assert_eq!(result.alias, ModelAlias::Cooper);
+        assert_eq!(result.reason, StartupReason::FallbackCooper);
+    }
+
+    #[test]
+    fn startup_resolver_respects_saved_preference() {
+        let models = vec![
+            make_model("rahul7star_Qwen3.5-0.8B-Coder.gguf"),
+            make_model("Qwen3.5-2B.Q6_K.gguf"),
+        ];
+        let result = resolve_startup_model(Some("cooper"), &models).unwrap();
+        assert_eq!(result.alias, ModelAlias::Cooper);
+        assert_eq!(result.reason, StartupReason::SavedPreference);
+    }
+
+    #[test]
+    fn startup_resolver_ignores_steel_in_auto_policy() {
+        let models = vec![make_model("Qwen3.5-4B-Abliterated.i1-Q6_K.gguf")];
+        let result = resolve_startup_model(None, &models);
+        assert!(result.is_none(), "Steel should not be auto-selected");
+    }
+
+    #[test]
+    fn startup_resolver_returns_none_when_no_models() {
+        let result = resolve_startup_model(None, &[]);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn startup_resolver_falls_through_when_saved_preference_not_found() {
+        // Saved preference is "iron" but only Cooper is available → fallback to Cooper
+        let models = vec![make_model("rahul7star_Qwen3.5-0.8B-Coder.gguf")];
+        let result = resolve_startup_model(Some("iron"), &models).unwrap();
+        assert_eq!(result.alias, ModelAlias::Cooper);
+        assert_eq!(result.reason, StartupReason::FallbackCooper);
+    }
+}

tauri-app/src-tauri/src/model_files.rs

@@ -67,6 +67,36 @@ fn scan_model_dir_top_level(path: &Path) -> Result<Vec<ModelFile>, String> {
     Ok(models)
 }
 
+/// Scans only `models/text-llm/` for `.gguf` files.
+/// All other directories are ignored.
+fn scan_model_dir_for_chat(dir: &Path, models: &mut Vec<ModelFile>) -> Result<(), String> {
+    let text_llm_dir = dir.join("text-llm");
+
+    if !text_llm_dir.exists() {
+        return Ok(());
+    }
+
+    if !text_llm_dir.is_dir() {
+        return Err(format!("Not a directory: {}", text_llm_dir.display()));
+    }
+
+    let entries = std::fs::read_dir(text_llm_dir).map_err(|e| e.to_string())?;
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_file()
+            && path
+                .extension()
+                .map(|ext| ext.eq_ignore_ascii_case("gguf"))
+                .unwrap_or(false)
+        {
+            models.push(model_file_from_path(&path));
+        }
+    }
+
+    Ok(())
+}
+
 /// Recursively scans all subdirectories for .gguf files.
 /// Kept for future use when deep scanning may be needed.
 #[allow(dead_code)]
@@ -134,7 +164,18 @@ pub fn scan_models(dir: String) -> Result<Vec<ModelFile>, String> {
     } else {
         resolve_models_dir(Some(&dir))
     };
-    scan_model_dir_top_level(&path)
+    
+    if !path.exists() {
+        return Err(format!("Directory not found: {}", path.display()));
+    }
+    if !path.is_dir() {
+        return Err(format!("Not a directory: {}", path.display()));
+    }
+
+    let mut models = Vec::new();
+    scan_model_dir_for_chat(&path, &mut models)?;
+    models.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(models)
 }
 
 #[tauri::command]
@@ -177,7 +218,7 @@ pub fn import_model(src_path: String, dest_dir: String) -> Result<ModelFile, Str
 
 #[cfg(test)]
 mod tests {
-    use super::{import_model_file, scan_model_dir};
+    use super::{import_model_file, scan_model_dir, scan_model_dir_for_chat};
     use std::path::PathBuf;
     use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -220,21 +261,26 @@ mod tests {
     }
 
     #[test]
-    fn scan_model_dir_returns_only_top_level_gguf() {
-        // Tests that scan_model_dir (now using top-level scan) does NOT recurse into subdirectories
-        let dir = temp_path("scan-models-top-level");
-        let sub = dir.join("mradermacher").join("Suri-Qwen-3.5-4B-Uncensored-i1-GGUF");
-        std::fs::create_dir_all(&sub).expect("create nested dirs");
+    fn scan_model_dir_for_chat_only_scans_text_llm_directory() {
+        let dir = temp_path("scan-models-text-llm");
+        let embeddings = dir.join("embeddings");
+        let audio = dir.join("audio");
+        let text_llm = dir.join("text-llm");
+        std::fs::create_dir_all(&embeddings).expect("create embeddings dir");
+        std::fs::create_dir_all(&audio).expect("create audio dir");
+        std::fs::create_dir_all(&text_llm).expect("create text-llm dir");
+
         std::fs::write(dir.join("top-level.gguf"), b"demo").expect("write top-level model");
-        std::fs::write(sub.join("nested-model.gguf"), b"demo").expect("write nested model");
-        std::fs::write(sub.join("notes.txt"), b"ignore").expect("write non-model file");
+        std::fs::write(embeddings.join("embedding-model.gguf"), b"demo")
+            .expect("write embedding model");
+        std::fs::write(audio.join("whisper.gguf"), b"demo").expect("write audio model");
+        std::fs::write(text_llm.join("chat-model.gguf"), b"demo").expect("write chat model");
 
-        let models = scan_model_dir(&dir).expect("scan model dir");
-        let names: Vec<_> = models.iter().map(|m| m.name.as_str()).collect();
+        let mut models = Vec::new();
+        scan_model_dir_for_chat(&dir, &mut models).expect("scan for chat");
+        let names: Vec<_> = models.into_iter().map(|m| m.name).collect();
 
-        // Only top-level model should be returned, NOT nested ones
-        assert_eq!(names, vec!["top-level.gguf"]);
-        assert!(models.iter().all(|m| m.path.ends_with(".gguf")));
+        assert_eq!(names, vec!["chat-model.gguf"]);
 
         let _ = std::fs::remove_dir_all(&dir);
     }

tauri-app/src-tauri/src/runtime/mod.rs

@@ -69,6 +69,7 @@ fn start_runtime_inner(
     app: &AppHandle,
     state: &State<'_, RuntimeState>,
     override_config: Option<RuntimeConfig>,
+    startup_status: RuntimeStatus,
 ) -> Result<RuntimeSnapshot, String> {
     let command = if override_config.is_some() {
         RuntimeLifecycleCommand::SaveAndStart
@@ -113,7 +114,7 @@ fn start_runtime_inner(
             return Ok(build_snapshot(&inner));
         }
 
-        inner.status = RuntimeStatus::Starting;
+        inner.status = startup_status;
         inner.last_error = None;
         inner.config.clone()
     };
@@ -137,7 +138,7 @@ fn start_runtime_inner(
     {
         let mut inner = state.0.lock().map_err(|e| e.to_string())?;
         inner.child = Some(child);
-        inner.status = RuntimeStatus::Starting;
+        inner.status = startup_status;
     }
 
     if wait_for_health(&config.addr, Duration::from_secs(15)) {
@@ -164,10 +165,17 @@ fn start_runtime_inner(
         }
         inner.child = None;
         inner.status = RuntimeStatus::Error;
-        let message = format!(
-            "Local API did not pass /health readiness on {} in time",
-            config.addr
-        );
+        let message = if startup_status == RuntimeStatus::Loading {
+            format!(
+                "Model loading timed out before the local API became ready on {}",
+                config.addr
+            )
+        } else {
+            format!(
+                "Local API did not pass /health readiness on {} in time",
+                config.addr
+            )
+        };
         inner.last_error = Some(runtime_error("health_timeout", &message));
         finish_lifecycle_command(
             &mut inner,
@@ -183,7 +191,43 @@ pub fn bootstrap_runtime(
     app: AppHandle,
     state: State<'_, RuntimeState>,
 ) -> Result<RuntimeSnapshot, String> {
-    let config = load_runtime_config(&app).unwrap_or_default();
+    use crate::model_alias;
+    use crate::model_library::paths::resolve_models_dir;
+
+    let mut config = load_runtime_config(&app).unwrap_or_default();
+
+    // Auto-resolve model if none is configured yet
+    let model_path_empty = config
+        .model_path
+        .as_deref()
+        .map(|p| p.trim().is_empty())
+        .unwrap_or(true);
+
+    if model_path_empty && config.connection_mode == ConnectionMode::Local {
+        let models_dir = resolve_models_dir(config.models_dir.as_deref());
+        let models = if models_dir.exists() {
+            let dir_str = models_dir.to_string_lossy().to_string();
+            crate::model_files::scan_models(dir_str).unwrap_or_default()
+        } else {
+            Vec::new()
+        };
+
+        if let Some(resolution) = model_alias::resolve_startup_model(
+            config.preferred_startup_model_alias.as_deref(),
+            &models,
+        ) {
+            eprintln!(
+                "[bootstrap] auto-selected model: {} ({:?}) reason={:?}",
+                resolution.alias.as_str(),
+                resolution.model_path,
+                resolution.reason
+            );
+            config.model_path = Some(resolution.model_path);
+            // Auto-enable OnAppLaunch when we found a model automatically
+            config.start_policy = StartPolicy::OnAppLaunch;
+        }
+    }
+
     let should_autostart = config.connection_mode == ConnectionMode::Local
         && config.start_policy == StartPolicy::OnAppLaunch
         && config
@@ -199,7 +243,7 @@ pub fn bootstrap_runtime(
     }
 
     if should_autostart {
-        start_runtime_inner(&app, &state, Some(config))
+        start_runtime_inner(&app, &state, Some(config), RuntimeStatus::Loading)
     } else {
         get_runtime_snapshot(state)
     }
@@ -209,7 +253,15 @@ pub fn start_runtime(
     app: AppHandle,
     state: State<'_, RuntimeState>,
 ) -> Result<RuntimeSnapshot, String> {
-    start_runtime_inner(&app, &state, None)
+    start_runtime_inner(&app, &state, None, RuntimeStatus::Starting)
+}
+
+pub fn start_runtime_with_status(
+    app: AppHandle,
+    state: State<'_, RuntimeState>,
+    startup_status: RuntimeStatus,
+) -> Result<RuntimeSnapshot, String> {
+    start_runtime_inner(&app, &state, None, startup_status)
 }
 
 pub fn stop_runtime(state: State<'_, RuntimeState>) -> Result<RuntimeSnapshot, String> {

tauri-app/src-tauri/src/runtime/process.rs

@@ -1,5 +1,5 @@
 use std::path::PathBuf;
-use std::process::{Child, Command};
+use std::process::{Child, Command, Stdio};
 
 use tauri::{AppHandle, Manager};
 
@@ -102,6 +102,9 @@ pub fn spawn_localllm(app: &AppHandle, config: &RuntimeConfig) -> Result<Child,
         .env("LOCALLLM_CTX", config.ctx_size.to_string());
     apply_runtime_to_command(&mut command, &runtime);
 
+    // Suppress verbose llama.cpp logs (create_tensor, etc.) by redirecting stderr
+    command.stderr(Stdio::null());
+
     command
         .spawn()
         .map_err(|e| format!("Failed to start server ({}): {e}", binary_path.display()))

tauri-app/src-tauri/src/runtime/state.rs

@@ -99,10 +99,12 @@ pub(crate) fn guard_start_request(inner: &mut RuntimeInner) -> Result<(), Runtim
 
     if matches!(
         inner.status,
-        RuntimeStatus::Starting | RuntimeStatus::Stopping
+        RuntimeStatus::Starting | RuntimeStatus::Loading | RuntimeStatus::Stopping
     ) {
         let message = if inner.status == RuntimeStatus::Stopping {
             "Local API stop already in progress."
+        } else if inner.status == RuntimeStatus::Loading {
+            "Local API model is still loading."
         } else {
             "Local API start already in progress."
         };
@@ -136,10 +138,12 @@ pub(crate) fn guard_stop_request(inner: &mut RuntimeInner) -> Result<(), Runtime
 
     if matches!(
         inner.status,
-        RuntimeStatus::Starting | RuntimeStatus::Stopping
+        RuntimeStatus::Starting | RuntimeStatus::Loading | RuntimeStatus::Stopping
     ) {
         let message = if inner.status == RuntimeStatus::Starting {
             "Local API start already in progress."
+        } else if inner.status == RuntimeStatus::Loading {
+            "Local API model is still loading."
         } else {
             "Local API stop already in progress."
         };
@@ -449,6 +453,23 @@ mod tests {
         assert_eq!(inner.active_command, RuntimeLifecycleCommand::Start);
     }
 
+    #[test]
+    fn guard_start_request_blocks_when_model_is_loading() {
+        let mut inner = RuntimeInner {
+            child: None,
+            status: RuntimeStatus::Loading,
+            last_error: None,
+            active_command: RuntimeLifecycleCommand::Idle,
+            last_command_result: RuntimeLifecycleResult::default(),
+            config: RuntimeConfig::default(),
+        };
+
+        let blocked = guard_start_request(&mut inner).expect_err("start should be blocked");
+
+        assert_eq!(blocked.command, RuntimeLifecycleCommand::Start);
+        assert_eq!(blocked.message, "Local API model is still loading.");
+    }
+
     #[test]
     fn guard_stop_request_blocks_when_runtime_is_already_stopped() {
         let mut inner = RuntimeInner {

tauri-app/src-tauri/src/runtime/types.rs

@@ -26,6 +26,7 @@ pub enum RuntimeStatus {
     #[default]
     Stopped,
     Starting,
+    Loading,
     Ready,
     Degraded,
     Stopping,
@@ -85,6 +86,7 @@ pub struct RuntimeConfig {
     pub selected_model_id: Option<String>,
     pub remote_presets: Vec<RemotePreset>,
     pub hugging_face_token: String,
+    pub preferred_startup_model_alias: Option<String>,
 }
 
 impl RuntimeConfig {
@@ -109,6 +111,7 @@ impl Default for RuntimeConfig {
             selected_model_id: None,
             remote_presets: Vec::new(),
             hugging_face_token: String::new(),
+            preferred_startup_model_alias: None,
         }
     }
 }