diff --git a/resources/views/layouts/app.blade.php b/resources/views/layouts/app.blade.php
index 816e30ec3..14d1e63ce 100644
--- a/resources/views/layouts/app.blade.php
+++ b/resources/views/layouts/app.blade.php
@@ -325,5 +325,559 @@ function carregarMensagens() {
 
 </body>
 
+        {{-- Search input js logic --}}
+        <script src="{{ asset("assets/js/utils.js") }}"></script>
+        <script src="https://maps.googleapis.com/maps/api/js?key={{ env("GOOGLE_API_KEY") }}&libraries=places"></script>
+        <script src="{{ asset("assets/js/cep_autocomplete.js") }}"></script>
+        @stack("scripts")
+        @livewireScripts
+
+        <script>
+        // Function to handle input suggestion storage
+        function setupInputSuggestions() {
+            // Get all inputs with datalists
+            const inputsWithDatalist = document.querySelectorAll('input[list]');
+            
+            // Debounce function to limit how often we save
+            function debounce(func, wait) {
+                let timeout;
+                return function(...args) {
+                    clearTimeout(timeout);
+                    timeout = setTimeout(() => func.apply(this, args), wait);
+                };
+            }
+            
+            inputsWithDatalist.forEach(input => {
+                const datalistId = input.getAttribute('list');
+                const datalist = document.getElementById(datalistId);
+                const storageKey = `suggestions_${input.id || input.name}`;
+                
+                // Load existing suggestions from localStorage
+                const savedSuggestions = localStorage.getItem(storageKey);
+                if (savedSuggestions) {
+                    const suggestions = JSON.parse(savedSuggestions);
+                    suggestions.forEach(suggestion => {
+                        // Add to datalist if it doesn't already exist
+                        if (!Array.from(datalist.options).some(option => option.value === suggestion)) {
+                            const option = document.createElement('option');
+                            option.value = suggestion;
+                            datalist.appendChild(option);
+                        }
+                    });
+                }
+                
+                // Function to save suggestion
+                const saveSuggestion = () => {
+                    const value = input.value.trim();
+                    if (value) {
+                        let suggestions = [];
+                        if (localStorage.getItem(storageKey)) {
+                            suggestions = JSON.parse(localStorage.getItem(storageKey));
+                        }
+                        
+                        // Add new suggestion if it doesn't exist
+                        if (!suggestions.includes(value)) {
+                            suggestions.push(value);
+                            localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                            
+                            // Add to datalist if needed
+                            if (!Array.from(datalist.options).some(option => option.value === value)) {
+                                const option = document.createElement('option');
+                                option.value = value;
+                                datalist.appendChild(option);
+                            }
+                        }
+                    }
+                };
+                
+                // Debounced version for input event
+                const debouncedSave = debounce(saveSuggestion, 300);
+                
+                // Listen for input (typing) events - save while typing
+                input.addEventListener('input', debouncedSave);
+                
+                // Also listen for change events (when input loses focus)
+                input.addEventListener('change', saveSuggestion);
+                
+                // Special handling for Livewire: save before Livewire updates
+                input.addEventListener('keydown', function(e) {
+                    // Save immediately on Tab or Enter
+                    if (e.key === 'Tab' || e.key === 'Enter') {
+                        saveSuggestion();
+                    }
+                });
+                
+                // Save on blur (when focus leaves the input)
+                input.addEventListener('blur', saveSuggestion);
+                
+                // Handle Livewire update - very important
+                input.addEventListener('beforeinput', saveSuggestion);
+                
+                // Create a hidden form to prevent browser autocomplete from being blocked
+                const form = document.createElement('form');
+                form.style.display = 'none';
+                form.setAttribute('autocomplete', 'on');
+                document.body.appendChild(form);
+                
+                // Clone the input and append to hidden form
+                const clonedInput = input.cloneNode(true);
+                clonedInput.removeAttribute('wire:model');
+                form.appendChild(clonedInput);
+                
+                // Sync values between visible and hidden inputs
+                input.addEventListener('input', function() {
+                    clonedInput.value = input.value;
+                });
+            });
+        }
+
+        // Special handler for Livewire operations
+        document.addEventListener('livewire:update', function() {
+            // Save all input values before Livewire updates
+            document.querySelectorAll('input[list]').forEach(input => {
+                const storageKey = `suggestions_${input.id || input.name}`;
+                const value = input.value.trim();
+                
+                if (value) {
+                    let suggestions = [];
+                    if (localStorage.getItem(storageKey)) {
+                        suggestions = JSON.parse(localStorage.getItem(storageKey));
+                    }
+                    
+                    if (!suggestions.includes(value)) {
+                        suggestions.push(value);
+                        localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                    }
+                }
+            });
+        });
+
+        // Run when DOM is loaded
+        document.addEventListener('DOMContentLoaded', setupInputSuggestions);
+
+        // For Livewire components that may load after page load
+        document.addEventListener('livewire:initialized', setupInputSuggestions);
+        document.addEventListener('livewire:navigated', setupInputSuggestions);
+        </script>
+
+        <script>
+        // Make values available immediately
+        function populateSuggestions() {
+            // Add common values for each input type
+            const commonFields = {
+                'de_question_id': ['QA01', 'Q1', 'DE1', 'QD1', 'D1'],
+                'criteria_id': ['IC1', 'IC2', 'EC1', 'EC2'],
+                'quality_question_id': ['QA01', 'QA02', 'QA1', 'QA2'],
+                'research_question_id': ['RQ1', 'RQ2', 'RQ3', 'GQ1']
+            };
+            
+            // Add these to localStorage for immediate availability
+            for (const [fieldName, values] of Object.entries(commonFields)) {
+                const storageKey = `suggestions_${fieldName}`;
+                let suggestions = [];
+                
+                // Get existing suggestions
+                if (localStorage.getItem(storageKey)) {
+                    suggestions = JSON.parse(localStorage.getItem(storageKey));
+                }
+                
+                // Add new common values if they don't exist
+                values.forEach(value => {
+                    if (!suggestions.includes(value)) {
+                        suggestions.push(value);
+                    }
+                });
+                
+                // Save back to localStorage
+                localStorage.setItem(storageKey, JSON.stringify(suggestions));
+            }
+        }
+
+        // Run immediately
+        populateSuggestions();
+        </script>
+
+        <script>
+        // Force browser to refresh autocomplete suggestions
+        function forceBrowserAutocompleteRefresh() {
+            // Create a temporary hidden iframe to force browser cache refresh
+            const iframe = document.createElement('iframe');
+            iframe.style.display = 'none';
+            document.body.appendChild(iframe);
+            
+            // Create a form inside the iframe with autocomplete on
+            const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
+            iframeDoc.body.innerHTML = '<form autocomplete="on" id="temp-form"></form>';
+            const tempForm = iframeDoc.getElementById('temp-form');
+            
+            // For each input we care about, create a parallel input in the iframe
+            const inputFields = document.querySelectorAll('input[list]');
+            inputFields.forEach(input => {
+                const name = input.name || input.id;
+                const value = input.value;
+                
+                if (value) {
+                    // Get existing suggestions
+                    const storageKey = `suggestions_${name}`;
+                    let suggestions = [];
+                    if (localStorage.getItem(storageKey)) {
+                        suggestions = JSON.parse(localStorage.getItem(storageKey));
+                    }
+                    
+                    // Add the new value if not present
+                    if (!suggestions.includes(value)) {
+                        suggestions.push(value);
+                        localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                    }
+                    
+                    // Create all inputs and add all values as options in the iframe
+                    suggestions.forEach((suggestion, index) => {
+                        const tempInput = document.createElement('input');
+                        tempInput.type = 'text';
+                        tempInput.name = `${name}_${index}`;
+                        tempInput.value = suggestion;
+                        tempInput.setAttribute('autocomplete', 'on');
+                        tempForm.appendChild(tempInput);
+                    });
+                }
+            });
+            
+            // Submit the form to register values with browser's autocomplete
+            tempForm.submit();
+            
+            // Clean up after a delay
+            setTimeout(() => {
+                document.body.removeChild(iframe);
+            }, 500);
+        }
+
+        // Run this function whenever a form is submitted
+        document.addEventListener('submit', function(e) {
+            const form = e.target;
+            if (form.querySelector('input[list]')) {
+                forceBrowserAutocompleteRefresh();
+            }
+        });
+
+        // Also run for direct input changes
+        document.addEventListener('change', function(e) {
+            if (e.target.hasAttribute('list')) {
+                // Small delay to let the input value settle
+                setTimeout(() => forceBrowserAutocompleteRefresh(), 50);
+            }
+        });
+        </script>
+
+        <script>
+        // Bypass browser autocomplete memory limitations
+        (function() {
+            // Store a reference to all suggestions
+            const allSuggestions = {}; 
+            
+            // Special workaround to force browser to update input suggestions
+            function refreshInputBrowserCache(input) {
+                // Create a form that we'll later submit and destroy
+                const formId = `form-refresh-${Math.random().toString(36).substring(2)}`;
+                const form = document.createElement('form');
+                form.id = formId;
+                form.method = 'post';
+                form.action = 'javascript:void(0)';
+                form.style.position = 'absolute';
+                form.style.left = '-9999px';
+                form.setAttribute('autocomplete', 'on');
+                document.body.appendChild(form);
+                
+                // Create a reset button to clear browser cache
+                const resetBtn = document.createElement('button');
+                resetBtn.type = 'reset';
+                form.appendChild(resetBtn);
+                
+                // Reset the form to clear browser state
+                resetBtn.click();
+                
+                // Create a clone of our input
+                const inputClone = document.createElement('input');
+                inputClone.type = 'text';
+                inputClone.name = input.name || input.id;
+                inputClone.setAttribute('autocomplete', 'on');
+                form.appendChild(inputClone);
+                
+                // Get all suggestions for this input
+                const storageKey = `suggestions_${input.name || input.id}`;
+                if (localStorage.getItem(storageKey)) {
+                    const suggestions = JSON.parse(localStorage.getItem(storageKey));
+                    
+                    // We'll use this to preserve our suggestions
+                    allSuggestions[storageKey] = suggestions;
+                    
+                    // Create a hidden submit button
+                    const submitBtn = document.createElement('button');
+                    submitBtn.type = 'submit';
+                    submitBtn.style.display = 'none';
+                    form.appendChild(submitBtn);
+                    
+                    // For each suggestion, set the value and submit the form
+                    // This forces the browser to register each value
+                    for (let i = 0; i < suggestions.length; i++) {
+                        const suggestion = suggestions[i];
+                        
+                        // Set value and trigger events
+                        inputClone.value = suggestion;
+                        inputClone.dispatchEvent(new Event('input', { bubbles: true }));
+                        inputClone.dispatchEvent(new Event('change', { bubbles: true }));
+                        
+                        // Submit the form for this value
+                        submitBtn.click();
+                    }
+                }
+                
+                // Remove the temporary form
+                setTimeout(() => document.body.removeChild(form), 100);
+            }
+            
+            // Monitor for new inputs and refresh their cache
+            function checkForNewInputs() {
+                document.querySelectorAll('input[list]').forEach(input => {
+                    const name = input.name || input.id;
+                    if (name && !input.hasAttribute('data-autocomplete-monitored')) {
+                        input.setAttribute('data-autocomplete-monitored', 'true');
+                        
+                        // Immediately refresh this input's cache
+                        refreshInputBrowserCache(input);
+                        
+                        // Set up event listeners
+                        input.addEventListener('focus', () => refreshInputBrowserCache(input));
+                        
+                        // Save new values when they're entered
+                        input.addEventListener('change', function() {
+                            const value = this.value.trim();
+                            if (value) {
+                                const storageKey = `suggestions_${name}`;
+                                let suggestions = allSuggestions[storageKey] || [];
+                                
+                                if (!suggestions.includes(value)) {
+                                    suggestions.push(value);
+                                    allSuggestions[storageKey] = suggestions;
+                                    localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                                    
+                                    // Update datalist
+                                    const datalistId = input.getAttribute('list');
+                                    if (datalistId) {
+                                        const datalist = document.getElementById(datalistId);
+                                        if (datalist) {
+                                            // Add the new option
+                                            const option = document.createElement('option');
+                                            option.value = value;
+                                            datalist.appendChild(option);
+                                        }
+                                    }
+                                    
+                                    // Force browser to update
+                                    refreshInputBrowserCache(input);
+                                }
+                            }
+                        });
+                    }
+                });
+            }
+            
+            // Check regularly for new inputs
+            setInterval(checkForNewInputs, 1000);
+            
+            // Initial check on page load
+            document.addEventListener('DOMContentLoaded', checkForNewInputs);
+            
+            // Check after Livewire updates
+            document.addEventListener('livewire:load', checkForNewInputs);
+            document.addEventListener('livewire:update', checkForNewInputs);
+        })();
+        </script>
+
+        <script>
+        // Function for the refresh button
+        function refreshSuggestions(inputId, inputName, datalistId, showAlert = true) {
+            // Find the input and datalist elements
+            const input = document.getElementById(inputId);
+            const datalist = document.getElementById(datalistId);
+            
+            if (!input || !datalist) return;
+            
+            // Clear the browser's cache by toggling autocomplete
+            input.setAttribute('autocomplete', 'off');
+            
+            // Get current values from localStorage
+            const storageKey = `suggestions_${inputName || inputId}`;
+            let suggestions = [];
+            
+            if (localStorage.getItem(storageKey)) {
+                suggestions = JSON.parse(localStorage.getItem(storageKey));
+            }
+            
+            // Add the current value if it's not already in the list
+            const currentValue = input.value.trim();
+            if (currentValue && !suggestions.includes(currentValue)) {
+                suggestions.push(currentValue);
+                localStorage.setItem(storageKey, JSON.stringify(suggestions));
+            }
+            
+            // Clear and rebuild the datalist
+            datalist.innerHTML = '';
+            suggestions.forEach(suggestion => {
+                const option = document.createElement('option');
+                option.value = suggestion;
+                datalist.appendChild(option);
+            });
+            
+            // Create a hidden form to force browser to register suggestions
+            const form = document.createElement('form');
+            form.setAttribute('autocomplete', 'on');
+            form.style.position = 'absolute';
+            form.style.left = '-9999px';
+            document.body.appendChild(form);
+            
+            // Add a hidden input for each suggestion
+            suggestions.forEach((suggestion, index) => {
+                const hiddenInput = document.createElement('input');
+                hiddenInput.type = 'text';
+                hiddenInput.name = `${inputName || inputId}_${index}`;
+                hiddenInput.value = suggestion;
+                hiddenInput.setAttribute('autocomplete', 'on');
+                form.appendChild(hiddenInput);
+            });
+            
+            // Submit the form to register with browser
+            form.submit();
+            
+            // Remove the form after a delay
+            setTimeout(() => {
+                document.body.removeChild(form);
+                
+                // Re-enable autocomplete on the original input
+                input.setAttribute('autocomplete', 'on');
+                
+                // Show a message only if requested
+                if (showAlert) {
+                    alert("Sugestões atualizadas! Agora você pode começar a digitar para ver todas as sugestões.");
+                }
+            }, 500);
+        }
+        </script>
+
+        <script>
+        // Automatically refresh suggestions on form submit
+        document.addEventListener('DOMContentLoaded', function() {
+            // Find all forms with Livewire submit handlers
+            document.querySelectorAll('form[wire\\:submit]').forEach(form => {
+                form.addEventListener('submit', function(e) {
+                    // Find all input fields with datalists in this form
+                    const inputs = form.querySelectorAll('input[list]');
+                    
+                    // For each input, refresh its suggestions
+                    inputs.forEach(input => {
+                        const inputId = input.id;
+                        const inputName = input.name || input.id;
+                        const datalistId = input.getAttribute('list');
+                        
+                        // Use a small setTimeout to ensure this runs after the Livewire update
+                        setTimeout(() => {
+                            refreshSuggestions(inputId, inputName, datalistId, false);
+                        }, 500);
+                    });
+                });
+            });
+            
+            // Also monitor Livewire events for form submission
+            document.addEventListener('livewire:load', function() {
+                if (typeof window.Livewire !== 'undefined') {
+                    // After Livewire finishes updating, refresh suggestions
+                    window.Livewire.hook('message.processed', (message, component) => {
+                        if (message.updateQueue && message.updateQueue.length) {
+                            // Find all inputs with datalists
+                            document.querySelectorAll('input[list]').forEach(input => {
+                                const inputId = input.id;
+                                const inputName = input.name || input.id;
+                                const datalistId = input.getAttribute('list');
+                                
+                                // Refresh silently without alert
+                                refreshSuggestions(inputId, inputName, datalistId, false);
+                            });
+                        }
+                    });
+                }
+            });
+        });
+        </script>
+
+        <script>
+        // Watch for Livewire form submissions and update suggestions
+        document.addEventListener('livewire:load', function() {
+            if (typeof window.Livewire !== 'undefined') {
+                // Before Livewire sends a request, save current input values
+                window.Livewire.hook('message.sent', (message, component) => {
+                    // Get all inputs with datalists
+                    const inputs = document.querySelectorAll('input[list]');
+                    inputs.forEach(input => {
+                        const value = input.value.trim();
+                        if (value) {
+                            const storageKey = `suggestions_${input.name || input.id}`;
+                            let suggestions = [];
+                            
+                            if (localStorage.getItem(storageKey)) {
+                                suggestions = JSON.parse(localStorage.getItem(storageKey));
+                            }
+                            
+                            if (!suggestions.includes(value)) {
+                                suggestions.push(value);
+                                localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                            }
+                        }
+                    });
+                });
+                
+                // After Livewire processes a request, update suggestions
+                window.Livewire.hook('message.processed', (message, component) => {
+                    // Wait a bit for the DOM to settle
+                    setTimeout(() => {
+                        // Update all datalists with saved suggestions
+                        document.querySelectorAll('input[list]').forEach(input => {
+                            const datalistId = input.getAttribute('list');
+                            const datalist = document.getElementById(datalistId);
+                            
+                            if (datalist) {
+                                const storageKey = `suggestions_${input.name || input.id}`;
+                                if (localStorage.getItem(storageKey)) {
+                                    // Get saved suggestions
+                                    const suggestions = JSON.parse(localStorage.getItem(storageKey));
+                                    
+                                    // Clear datalist
+                                    datalist.innerHTML = '';
+                                    
+                                    // Add all suggestions as options
+                                    suggestions.forEach(suggestion => {
+                                        const option = document.createElement('option');
+                                        option.value = suggestion;
+                                        datalist.appendChild(option);
+                                    });
+                                }
+                            }
+                        });
+                        
+                        // Also force browser to refresh its autocomplete cache
+                        document.querySelectorAll('input[list]').forEach(input => {
+                            const inputId = input.id;
+                            const inputName = input.name;
+                            const datalistId = input.getAttribute('list');
+                            
+                            if (inputId && inputName && datalistId) {
+                                refreshSuggestions(inputId, inputName, datalistId, false);
+                            }
+                        });
+                    }, 300);
+                });
+            }
+        });
+        </script>
+    </body>
+
 </html>
 
diff --git a/resources/views/livewire/planning/criteria/criteria.blade.php b/resources/views/livewire/planning/criteria/criteria.blade.php
index 0bfd940b6..461abcf5c 100644
--- a/resources/views/livewire/planning/criteria/criteria.blade.php
+++ b/resources/views/livewire/planning/criteria/criteria.blade.php
@@ -17,7 +17,12 @@
                             label="{{ __('project/planning.criteria.form.id') }}"
                             wire:model="criteriaId"
                             placeholder="ID"
-                            required />
+                            required
+                            autocomplete="on"
+                            name="criteria_id"
+                            list="criteriaId_suggestions"
+                        />
+
                         @error("criteriaId")
                             <span class="text-xs text-danger">
                                 {{ $message }}
@@ -330,4 +335,37 @@ class="btn py-1 px-3 btn-outline-danger"
         });
     </script>
     @endscript
-</div>
\ No newline at end of file
+
+</div>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    const form = document.querySelector('form[wire\\:submit]');
+    const input = document.querySelector('#criteriaId');
+    
+    if (form && input) {
+        form.addEventListener('submit', function() {
+            // Force save the current input value to suggestions
+            const value = input.value.trim();
+            if (value) {
+                const storageKey = `suggestions_${input.id || input.name}`;
+                let suggestions = [];
+                
+                if (localStorage.getItem(storageKey)) {
+                    suggestions = JSON.parse(localStorage.getItem(storageKey));
+                }
+                
+                if (!suggestions.includes(value)) {
+                    suggestions.push(value);
+                    localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                }
+                
+                // Automatically refresh suggestions without showing an alert
+                setTimeout(() => {
+                    refreshSuggestions('criteriaId', 'criteria_id', 'criteriaId_suggestions', false);
+                }, 200);
+            }
+        });
+    }
+});
+</script>
\ No newline at end of file
diff --git a/resources/views/livewire/planning/data-extraction/question.blade.php b/resources/views/livewire/planning/data-extraction/question.blade.php
index 41b60b6a6..2a04e4bb3 100644
--- a/resources/views/livewire/planning/data-extraction/question.blade.php
+++ b/resources/views/livewire/planning/data-extraction/question.blade.php
@@ -12,12 +12,18 @@
             <div class="form-group mt-3 d-flex flex-column gap-4">
                 <x-input
                     id="questionId"
-                    label="{{ __('project/planning.data-extraction.question-form.id') }}"
+                    class="form-control w-md-25 w-100"
+                    type="text"
+                    maxlength="20"
                     wire:model="questionId"
                     placeholder="ID"
+                    autocomplete="on"
+                    name="de_question_id"
+                    list="de_questionId_suggestions"
                     maxlength="255"
                     pattern="\d+"
                     required
+
                 />
                 @error("questionId")
                     <span class="text-xs text-danger">
@@ -89,3 +95,69 @@
         });
     </script>
 @endscript
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    const form = document.querySelector('form[wire\\:submit]');
+    const input = document.querySelector('#questionId');
+    
+    if (form && input) {
+        // Save every keypress, not just on submit
+        input.addEventListener('input', function() {
+            const value = input.value.trim();
+            if (value) {
+                const storageKey = `suggestions_${input.id || input.name}`;
+                let suggestions = [];
+                
+                if (localStorage.getItem(storageKey)) {
+                    suggestions = JSON.parse(localStorage.getItem(storageKey));
+                }
+                
+                if (!suggestions.includes(value)) {
+                    suggestions.push(value);
+                    localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                    
+                    // Force immediate refresh of suggestions
+                    const datalist = document.getElementById('de_questionId_suggestions');
+                    if (datalist) {
+                        // Clear existing options and re-add them
+                        datalist.innerHTML = '';
+                        suggestions.forEach(suggestion => {
+                            const option = document.createElement('option');
+                            option.value = suggestion;
+                            datalist.appendChild(option);
+                        });
+                    }
+                    
+                    // Hack: force browser to "reset" its autocomplete understanding
+                    input.setAttribute('autocomplete', 'off');
+                    setTimeout(() => input.setAttribute('autocomplete', 'on'), 10);
+                }
+            }
+        });
+        
+        form.addEventListener('submit', function() {
+            // Save the current value
+            const value = input.value.trim();
+            if (value) {
+                const storageKey = `suggestions_${input.id || input.name}`;
+                let suggestions = [];
+                
+                if (localStorage.getItem(storageKey)) {
+                    suggestions = JSON.parse(localStorage.getItem(storageKey));
+                }
+                
+                if (!suggestions.includes(value)) {
+                    suggestions.push(value);
+                    localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                }
+                
+                // Automatically refresh suggestions without showing an alert
+                setTimeout(() => {
+                    refreshSuggestions('questionId', 'de_question_id', 'de_questionId_suggestions', false);
+                }, 200);
+            }
+        });
+    }
+});
+</script>
diff --git a/resources/views/livewire/planning/quality-assessment/question-quality.blade.php b/resources/views/livewire/planning/quality-assessment/question-quality.blade.php
index 600a1e733..00f58a1f1 100644
--- a/resources/views/livewire/planning/quality-assessment/question-quality.blade.php
+++ b/resources/views/livewire/planning/quality-assessment/question-quality.blade.php
@@ -17,6 +17,9 @@
                         wire:model="questionId"
                         pattern="[a-zA-ZÀ-ÿ0-9\s]+"
                         required
+                        autocomplete="on"
+                        name="quality_question_id"
+                        list="quality_questionId_suggestions"
                     />
                     @error("questionId")
                         <span class="text-xs text-danger">
@@ -102,6 +105,35 @@ function limit(element, maxLength = 10) {
         .addEventListener('input', function () {
             limit(this, 10);
         });
+        
+    document.addEventListener('DOMContentLoaded', function() {
+        const form = document.querySelector('form[wire\\:submit]');
+        const input = document.querySelector('#question-quality-id');
+        
+        if (form && input) {
+            form.addEventListener('submit', function() {
+                const value = input.value.trim();
+                if (value) {
+                    const storageKey = `suggestions_${input.id || input.name}`;
+                    let suggestions = [];
+                    
+                    if (localStorage.getItem(storageKey)) {
+                        suggestions = JSON.parse(localStorage.getItem(storageKey));
+                    }
+                    
+                    if (!suggestions.includes(value)) {
+                        suggestions.push(value);
+                        localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                    }
+                    
+                    // Automatically refresh suggestions without showing an alert
+                    setTimeout(() => {
+                        refreshSuggestions('question-quality-id', 'quality_question_id', 'quality_questionId_suggestions', false);
+                    }, 200);
+                }
+            });
+        }
+    });
 </script>
 
 @script
diff --git a/resources/views/livewire/planning/questions/research-questions.blade.php b/resources/views/livewire/planning/questions/research-questions.blade.php
index 3a8b1b8a8..191e4ce62 100644
--- a/resources/views/livewire/planning/questions/research-questions.blade.php
+++ b/resources/views/livewire/planning/questions/research-questions.blade.php
@@ -17,6 +17,9 @@ class="w-md-25 w-100"
                     wire:model="questionId"
                     placeholder="ID"
                     required
+                    autocomplete="on"
+                    name="research_question_id"
+                    list="research_questionId_suggestions"
                 />
                 @error("questionId")
                     <span class="text-xs text-danger">
@@ -157,3 +160,35 @@ class="btn py-1 px-3 btn-outline-danger"
         });
     </script>
 @endscript
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    const form = document.querySelector('form[wire\\:submit]');
+    const input = document.querySelector('#questionId');
+    
+    if (form && input) {
+        form.addEventListener('submit', function() {
+            // Force save the current input value to suggestions
+            const value = input.value.trim();
+            if (value) {
+                const storageKey = `suggestions_${input.id || input.name}`;
+                let suggestions = [];
+                
+                if (localStorage.getItem(storageKey)) {
+                    suggestions = JSON.parse(localStorage.getItem(storageKey));
+                }
+                
+                if (!suggestions.includes(value)) {
+                    suggestions.push(value);
+                    localStorage.setItem(storageKey, JSON.stringify(suggestions));
+                }
+                
+                // Automatically refresh suggestions without showing an alert
+                setTimeout(() => {
+                    refreshSuggestions('questionId', 'research_question_id', 'research_questionId_suggestions', false);
+                }, 200);
+            }
+        });
+    }
+});
+</script>