Function activate_session_goal

src/apps/desktop/src/api/agentic_api.rs:925–977

(
    coordinator: State<'_, Arc<ConversationCoordinator>>,
    app_state: State<'_, AppState>,
    request: ActivateSessionGoalRequest,
)

#[tauri::command]
pub async fn activate_session_goal(
    coordinator: State<'_, Arc<ConversationCoordinator>>,
    app_state: State<'_, AppState>,
    request: ActivateSessionGoalRequest,
) -> Result<ActivateSessionGoalResponse, String> {
    let session_id = request.session_id.trim();
    if session_id.is_empty() {
        return Err("session_id is required".to_string());
    }

    if coordinator
        .get_session_manager()
        .get_session(session_id)
        .is_none()
    {
        let workspace_path = request
            .workspace_path
            .as_deref()
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .ok_or_else(|| {
                "workspace_path is required when the session is not loaded".to_string()
            })?;
        let effective = desktop_effective_session_storage_path(
            &app_state,
            workspace_path,
            request.remote_connection_id.as_deref(),
            request.remote_ssh_host.as_deref(),
        )
        .await;
        coordinator
            .restore_session_from_storage_path(&effective, session_id)
            .await
            .map_err(|e| format!("Failed to restore session before activating goal mode: {e}"))?;
    }

    let user_hint = request
        .user_hint
        .as_deref()
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .map(str::to_string);

    let activation = coordinator
        .activate_session_goal(session_id.to_string(), user_hint)
        .await
        .map_err(|error| error.to_string())?;

    Ok(ActivateSessionGoalResponse {
        success: true,
        goal: activation,
    })
}

async fn ensure_session_for_thread_goal(
    coordinator: &Arc<ConversationCoordinator>,