From 4dfdb83ee4bec1126dff2a5b1e8299d39e4b1e38 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 15 Aug 2026 17:14:53 +0000
Subject: [PATCH 1/4] feat(chat): add a microphone button to dictate messages
 to the AI

Add a microphone button in the chat composer so the user can dictate a
message to Gladys instead of typing it, as requested on the community
forum.

Everything happens in the browser with the Web Speech API: no audio is
recorded or uploaded by Gladys, and no server change is needed. The
transcription fills the message input as the user speaks, and the message
is never sent automatically so the user can review it first.

The recognition locale follows the language selected in Gladys, falling
back to the browser locale. Browsers without the Web Speech API (Firefox)
or pages served over plain HTTP simply don't get the button.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013yxguVaLdJ8ZKmw5x3HePT
---
 front/src/actions/message.js                  |   5 +
 front/src/config/i18n/de.json                 |  10 +
 front/src/config/i18n/en.json                 |  10 +
 front/src/config/i18n/fr.json                 |  10 +
 front/src/routes/chat/ChatPage.js             |  31 +++-
 .../src/routes/chat/ChatVoiceInputButton.jsx  | 123 +++++++++++++
 front/src/routes/chat/style.css               |  54 ++++++
 front/src/utils/speechRecognition.js          | 173 ++++++++++++++++++
 8 files changed, 414 insertions(+), 2 deletions(-)
 create mode 100644 front/src/routes/chat/ChatVoiceInputButton.jsx
 create mode 100644 front/src/utils/speechRecognition.js

diff --git a/front/src/actions/message.js b/front/src/actions/message.js
index 564ca8edba..45b91d433c 100644
--- a/front/src/actions/message.js
+++ b/front/src/actions/message.js
@@ -42,6 +42,11 @@ function createActions(store) {
         currentMessageTextInput: e.target.value
       });
     },
+    setMessageTextInput(state, text) {
+      store.setState({
+        currentMessageTextInput: text
+      });
+    },
     syncMessage(state, message) {
       let newMessages = store.getState().messages;
       // Check if message is already in the list
diff --git a/front/src/config/i18n/de.json b/front/src/config/i18n/de.json
index 4703487ea2..7de7a51568 100644
--- a/front/src/config/i18n/de.json
+++ b/front/src/config/i18n/de.json
@@ -5708,6 +5708,16 @@
       "auto": "Auto",
       "priceLegend": "€ günstig · €€ mittel · €€€ premium"
     },
+    "voiceInput": {
+      "startListening": "Nachricht diktieren",
+      "stopListening": "Diktat beenden",
+      "error": "Die Spracherkennung ist fehlgeschlagen. Bitte versuche es erneut.",
+      "errorNoSpeech": "Keine Stimme erkannt. Prüfe, ob dein Mikrofon aktiviert ist, und versuche es erneut.",
+      "errorPermissionDenied": "Der Mikrofonzugriff wurde verweigert. Erlaube ihn in den Einstellungen deines Browsers, um eine Nachricht zu diktieren.",
+      "errorNoMicrophone": "Kein Mikrofon erkannt. Schließe eines an oder aktiviere es in den Systemeinstellungen.",
+      "errorNetwork": "Die Spracherkennung ist nicht verfügbar, dein Browser konnte seinen Sprachdienst nicht erreichen.",
+      "errorNotSupported": "Spracherkennung ist in diesem Browser nicht verfügbar."
+    },
     "sidebar": {
       "title": "Wie funktioniert der Chat?",
       "intro": "Der Gladys-Chat nutzt die Gladys-Plus-Künstliche Intelligenz, damit du natürlich mit deinem vernetzten Zuhause kommunizieren kannst.",
diff --git a/front/src/config/i18n/en.json b/front/src/config/i18n/en.json
index 3080417573..791534d582 100644
--- a/front/src/config/i18n/en.json
+++ b/front/src/config/i18n/en.json
@@ -5719,6 +5719,16 @@
       "label": "AI model",
       "auto": "Auto",
       "priceLegend": "€ cheap · €€ mid · €€€ premium"
+    },
+    "voiceInput": {
+      "startListening": "Dictate a message",
+      "stopListening": "Stop dictation",
+      "error": "Speech recognition failed. Please try again.",
+      "errorNoSpeech": "No voice detected. Check that your microphone is enabled, then try again.",
+      "errorPermissionDenied": "Microphone access was denied. Allow it in your browser settings to dictate a message.",
+      "errorNoMicrophone": "No microphone detected. Plug one in or enable it in system settings.",
+      "errorNetwork": "Speech recognition is unavailable, your browser could not reach its speech service.",
+      "errorNotSupported": "Speech recognition is not available in this browser."
     }
   },
   "history": {
diff --git a/front/src/config/i18n/fr.json b/front/src/config/i18n/fr.json
index 152327809a..72e8a36cc9 100644
--- a/front/src/config/i18n/fr.json
+++ b/front/src/config/i18n/fr.json
@@ -5719,6 +5719,16 @@
       "label": "Modèle IA",
       "auto": "Auto",
       "priceLegend": "€ économique · €€ moyen · €€€ premium"
+    },
+    "voiceInput": {
+      "startListening": "Dicter un message",
+      "stopListening": "Arrêter la dictée",
+      "error": "La reconnaissance vocale a échoué. Veuillez réessayer.",
+      "errorNoSpeech": "Aucune voix détectée. Vérifiez que votre micro est activé, puis réessayez.",
+      "errorPermissionDenied": "L'accès au micro a été refusé. Autorisez-le dans les réglages de votre navigateur pour dicter un message.",
+      "errorNoMicrophone": "Aucun micro détecté. Branchez ou activez un micro dans les réglages système.",
+      "errorNetwork": "La reconnaissance vocale est indisponible, votre navigateur n'a pas pu joindre son service vocal.",
+      "errorNotSupported": "La reconnaissance vocale n'est pas disponible dans ce navigateur."
     }
   },
   "history": {
diff --git a/front/src/routes/chat/ChatPage.js b/front/src/routes/chat/ChatPage.js
index 48f56fd56c..b9f2ce9a38 100644
--- a/front/src/routes/chat/ChatPage.js
+++ b/front/src/routes/chat/ChatPage.js
@@ -4,9 +4,11 @@ import { useEffect, useRef, useState } from 'preact/hooks';
 import { connect } from 'unistore/preact';
 import actions from '../../actions/message';
 import { RequestStatus } from '../../utils/consts';
+import { isSpeechRecognitionSupported } from '../../utils/speechRecognition';
 import ChatItems from './ChatItems';
 import EmptyChat from './EmptyChat';
 import AiModelSelector from './AiModelSelector';
+import ChatVoiceInputButton from './ChatVoiceInputButton';
 import style from './style.css';
 
 const IntegrationPage = connect(
@@ -19,14 +21,20 @@ const IntegrationPage = connect(
     MessageGetStatus,
     currentMessageTextInput,
     updateMessageTextInput,
+    setMessageTextInput,
     onKeyPress,
     sendMessage,
     gladysIsTyping,
     httpClient
   }) => {
     const textareaRef = useRef(null);
+    const voiceInputRef = useRef(null);
     const [selectedModel, setSelectedModel] = useState('auto');
     const [gladysPlusConfigured, setGladysPlusConfigured] = useState(null);
+    const [voiceInputError, setVoiceInputError] = useState(null);
+    // Browsers without the Web Speech API (Firefox for example) simply don't
+    // get a microphone button.
+    const [voiceInputSupported] = useState(isSpeechRecognitionSupported);
     const hasMessageToSend = Boolean(currentMessageTextInput && currentMessageTextInput.trim().length > 0);
 
     useEffect(() => {
@@ -63,13 +71,16 @@ const IntegrationPage = connect(
     };
 
     const handleSendMessage = () => {
+      if (voiceInputRef.current) {
+        voiceInputRef.current.cancelListening();
+      }
       sendMessage(selectedModel);
     };
 
     const handleKeyPress = e => {
       if (e.key === 'Enter' && !e.shiftKey) {
         e.preventDefault();
-        sendMessage(selectedModel);
+        handleSendMessage();
         return;
       }
       onKeyPress(e);
@@ -109,13 +120,24 @@ const IntegrationPage = connect(
                             <textarea
                               ref={textareaRef}
                               rows="1"
-                              class={cx('form-control', style.chatInput)}
+                              class={cx('form-control', style.chatInput, {
+                                [style.chatInputWithVoice]: voiceInputSupported
+                              })}
                               placeholder={<Text id="chat.messagePlaceholder" />}
                               value={currentMessageTextInput}
                               onInput={onComposerInput}
                               onKeyPress={handleKeyPress}
                             />
                           </Localizer>
+                          {voiceInputSupported && (
+                            <ChatVoiceInputButton
+                              ref={voiceInputRef}
+                              language={user && user.language}
+                              currentText={currentMessageTextInput}
+                              onTranscript={setMessageTextInput}
+                              onError={setVoiceInputError}
+                            />
+                          )}
                           <button
                             type="button"
                             class={cx('btn', style.sendButton, {
@@ -128,6 +150,11 @@ const IntegrationPage = connect(
                             <i class="fe fe-send" />
                           </button>
                         </div>
+                        {voiceInputError && (
+                          <p class={style.voiceInputError}>
+                            <Text id={`chat.voiceInput.${voiceInputError}`} />
+                          </p>
+                        )}
                       </div>
                     </div>
                   </div>
diff --git a/front/src/routes/chat/ChatVoiceInputButton.jsx b/front/src/routes/chat/ChatVoiceInputButton.jsx
new file mode 100644
index 0000000000..1f9afd23bd
--- /dev/null
+++ b/front/src/routes/chat/ChatVoiceInputButton.jsx
@@ -0,0 +1,123 @@
+import { Component } from 'preact';
+import { Text, Localizer } from 'preact-i18n';
+import cx from 'classnames';
+import { createSpeechRecognition } from '../../utils/speechRecognition';
+import style from './style.css';
+
+/**
+ * Microphone button dictating what the user says in the chat message input.
+ * Everything is handled by the browser with the Web Speech API: Gladys never
+ * records or uploads any audio. The message is not sent automatically, the
+ * user reviews the transcription and presses send.
+ */
+class ChatVoiceInputButton extends Component {
+  state = {
+    listening: false
+  };
+
+  /** Text already in the input when the user started to talk. */
+  baseText = '';
+
+  recognition = null;
+
+  componentWillUnmount() {
+    if (this.recognition) {
+      this.recognition.abort();
+      this.recognition = null;
+    }
+  }
+
+  handleTranscript = transcript => {
+    const trimmedTranscript = transcript.trim();
+    if (trimmedTranscript.length === 0) {
+      this.props.onTranscript(this.baseText);
+      return;
+    }
+    const separator = this.baseText.length > 0 && !/\s$/.test(this.baseText) ? ' ' : '';
+    this.props.onTranscript(`${this.baseText}${separator}${trimmedTranscript}`);
+  };
+
+  handleError = errorKey => {
+    this.props.onError(errorKey);
+  };
+
+  handleEnd = () => {
+    this.recognition = null;
+    this.setState({ listening: false });
+  };
+
+  startListening = () => {
+    this.props.onError(null);
+    this.baseText = this.props.currentText || '';
+    const recognition = createSpeechRecognition({
+      language: this.props.language,
+      onTranscript: this.handleTranscript,
+      onError: this.handleError,
+      onEnd: this.handleEnd
+    });
+    if (!recognition) {
+      this.props.onError('errorNotSupported');
+      return;
+    }
+    this.recognition = recognition;
+    this.setState({ listening: true });
+    recognition.start();
+  };
+
+  /**
+   * @description Stop listening, keeping what was already transcribed in the input.
+   */
+  stopListening = () => {
+    if (this.recognition) {
+      this.recognition.stop();
+      this.recognition = null;
+    }
+    this.setState({ listening: false });
+  };
+
+  /**
+   * @description Stop listening and drop the words still being transcribed.
+   * Called when the message is sent, so a late transcription does not refill
+   * the input the user just emptied.
+   */
+  cancelListening = () => {
+    if (this.recognition) {
+      this.recognition.abort();
+      this.recognition = null;
+    }
+    if (this.state.listening) {
+      this.setState({ listening: false });
+    }
+  };
+
+  handleClick = () => {
+    if (this.state.listening) {
+      this.stopListening();
+    } else {
+      this.startListening();
+    }
+  };
+
+  render(props, { listening }) {
+    const labelKey = listening ? 'chat.voiceInput.stopListening' : 'chat.voiceInput.startListening';
+
+    return (
+      <Localizer>
+        <button
+          type="button"
+          class={cx('btn', style.voiceInputButton, {
+            [style.voiceInputButtonListening]: listening
+          })}
+          onClick={this.handleClick}
+          title={<Text id={labelKey} />}
+          aria-label={<Text id={labelKey} />}
+          aria-pressed={listening ? 'true' : 'false'}
+        >
+          <i class={cx('fe', listening ? 'fe-square' : 'fe-mic')} aria-hidden="true" />
+        </button>
+      </Localizer>
+    );
+  }
+}
+
+export default ChatVoiceInputButton;
diff --git a/front/src/routes/chat/style.css b/front/src/routes/chat/style.css
index 6809b5fb27..099f97290b 100644
--- a/front/src/routes/chat/style.css
+++ b/front/src/routes/chat/style.css
@@ -530,6 +530,11 @@
   overflow-y: hidden;
 }
 
+/* Leave room for the microphone button next to the send button. */
+.chatInputWithVoice {
+  padding-right: 92px;
+}
+
 .chatInput:focus {
   border-color: #467fcf;
   box-shadow: 0 0 0 0.2rem rgba(70, 127, 207, 0.18);
@@ -574,6 +579,55 @@
   color: #9aa7b5;
 }
 
+.voiceInputButton {
+  position: absolute;
+  right: 48px;
+  bottom: 8px;
+  width: 36px;
+  height: 36px;
+  border: none;
+  border-radius: 50% !important;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: #eef2f6;
+  color: #6c7a89;
+  box-shadow: none;
+  transition: all 0.2s ease;
+}
+
+.voiceInputButton:hover,
+.voiceInputButton:focus {
+  background: #e2e9f0;
+  color: #3564be;
+}
+
+.voiceInputButtonListening,
+.voiceInputButtonListening:hover,
+.voiceInputButtonListening:focus {
+  background: #e74c3c;
+  color: #fff;
+  box-shadow: 0 2px 8px rgba(231, 76, 60, 0.4);
+  animation: voiceInputPulse 1.6s ease-in-out infinite;
+}
+
+@keyframes voiceInputPulse {
+  0%,
+  100% {
+    box-shadow: 0 2px 8px rgba(231, 76, 60, 0.4);
+  }
+
+  50% {
+    box-shadow: 0 2px 14px rgba(231, 76, 60, 0.75);
+  }
+}
+
+.voiceInputError {
+  margin: 8px 4px 0;
+  font-size: 13px;
+  color: #cd201f;
+}
+
 .emptyChatState {
   width: min(100%, 360px);
   text-align: center;
diff --git a/front/src/utils/speechRecognition.js b/front/src/utils/speechRecognition.js
new file mode 100644
index 0000000000..9a47b13454
--- /dev/null
+++ b/front/src/utils/speechRecognition.js
@@ -0,0 +1,173 @@
+import { AVAILABLE_LANGUAGES } from '../../../server/utils/constants';
+import { isSecureRecordingContext } from './speechMicrophoneAccess';
+
+/**
+ * Locale used for each Gladys language when the browser language does not
+ * match the language the user picked in Gladys.
+ */
+const DEFAULT_RECOGNITION_LOCALES = {
+  [AVAILABLE_LANGUAGES.EN]: 'en-US',
+  [AVAILABLE_LANGUAGES.FR]: 'fr-FR',
+  [AVAILABLE_LANGUAGES.DE]: 'de-DE'
+};
+
+/**
+ * @description Returns the browser SpeechRecognition constructor when available.
+ * Speech recognition is prefixed in Chromium based browsers.
+ * @returns {Function|null} The constructor, or null when unsupported.
+ */
+export function getSpeechRecognitionConstructor() {
+  if (typeof window === 'undefined') {
+    return null;
+  }
+  return window.SpeechRecognition || window.webkitSpeechRecognition || null;
+}
+
+/**
+ * @description Whether speech recognition can be used in this browser.
+ * The API needs a secure context (HTTPS or localhost) to get the microphone.
+ * @returns {boolean} True when speech recognition is usable.
+ */
+export function isSpeechRecognitionSupported() {
+  if (!isSecureRecordingContext()) {
+    return false;
+  }
+  return getSpeechRecognitionConstructor() !== null;
+}
+
+/**
+ * @description Pick the BCP 47 locale used to transcribe the user voice.
+ * The language selected in Gladys wins, and the full browser locale is kept
+ * when it matches it, so a French speaking user in Canada keeps fr-CA.
+ * @param {string} [language] - Language of the Gladys user (en, fr, de).
+ * @returns {string} Locale to give to the speech recognition engine.
+ * @example getSpeechRecognitionLocale('fr');
+ */
+export function getSpeechRecognitionLocale(language) {
+  const browserLocale = typeof navigator !== 'undefined' ? navigator.language : null;
+  if (language) {
+    if (browserLocale && browserLocale.split('-', 1)[0] === language) {
+      return browserLocale;
+    }
+    if (DEFAULT_RECOGNITION_LOCALES[language]) {
+      return DEFAULT_RECOGNITION_LOCALES[language];
+    }
+  }
+  return browserLocale || DEFAULT_RECOGNITION_LOCALES[AVAILABLE_LANGUAGES.EN];
+}
+
+/**
+ * @description Translate a SpeechRecognition error code to a Gladys i18n key suffix.
+ * @param {string} error - Error code given by the browser.
+ * @returns {string|null} i18n key suffix, or null when the error must be ignored.
+ * @example getSpeechRecognitionErrorKey('not-allowed');
+ */
+export function getSpeechRecognitionErrorKey(error) {
+  switch (error) {
+    case 'aborted':
+      // The user stopped the recognition himself, this is not an error.
+      return null;
+    case 'no-speech':
+      return 'errorNoSpeech';
+    case 'not-allowed':
+    case 'service-not-allowed':
+      return 'errorPermissionDenied';
+    case 'audio-capture':
+      return 'errorNoMicrophone';
+    case 'network':
+      return 'errorNetwork';
+    default:
+      return 'error';
+  }
+}
+
+/**
+ * @description Create a speech recognition session writing what the user says in a text input.
+ * @param {object} options - Session options.
+ * @param {string} [options.language] - Language of the Gladys user (en, fr, de).
+ * @param {Function} options.onTranscript - Called with the transcript each time it changes.
+ * @param {Function} [options.onError] - Called with an i18n key suffix when recognition fails.
+ * @param {Function} [options.onEnd] - Called when the browser stopped listening.
+ * @returns {object|null} Session with start/stop methods, or null when unsupported.
+ * @example createSpeechRecognition({ language: 'fr', onTranscript: console.log });
+ */
+export function createSpeechRecognition({ language, onTranscript, onError, onEnd }) {
+  const SpeechRecognitionConstructor = getSpeechRecognitionConstructor();
+  if (!SpeechRecognitionConstructor) {
+    return null;
+  }
+
+  const recognition = new SpeechRecognitionConstructor();
+  recognition.lang = getSpeechRecognitionLocale(language);
+  // Keep listening between sentences, browsers that don't support it simply
+  // stop on the first silence, which is a fine behaviour too.
+  recognition.continuous = true;
+  // Display words as they are recognized instead of waiting for the full sentence.
+  recognition.interimResults = true;
+
+  let finalTranscript = '';
+  let stopped = false;
+
+  recognition.onresult = event => {
+    let interimTranscript = '';
+    for (let i = event.resultIndex; i < event.results.length; i += 1) {
+      const result = event.results[i];
+      const { transcript } = result[0];
+      if (result.isFinal) {
+        finalTranscript += transcript;
+      } else {
+        interimTranscript += transcript;
+      }
+    }
+    onTranscript(`${finalTranscript}${interimTranscript}`);
+  };
+
+  recognition.onerror = event => {
+    const errorKey = getSpeechRecognitionErrorKey(event.error);
+    if (errorKey && onError) {
+      onError(errorKey);
+    }
+  };
+
+  recognition.onend = () => {
+    if (onEnd) {
+      onEnd();
+    }
+  };
+
+  return {
+    start() {
+      try {
+        recognition.start();
+      } catch (e) {
+        // start() throws when the recognition is already running, nothing to do.
+        console.error(e);
+      }
+    },
+    stop() {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      try {
+        recognition.stop();
+      } catch (e) {
+        console.error(e);
+      }
+    },
+    abort() {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      recognition.onresult = null;
+      recognition.onerror = null;
+      recognition.onend = null;
+      try {
+        recognition.abort();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  };
+}

From 0e4da3ed08f099059638e2a47345a7efba8cf78d Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 15 Aug 2026 20:02:17 +0000
Subject: [PATCH 2/4] fix(chat): harden the voice input session and disclose
 where audio goes

Address the review feedback on the chat microphone button:

- Guard the recognition session with a generation counter, so a session
  which is ending can no longer reset the state of the one which just
  started, and don't start a new session before the previous one ended
  (a start asked in between is replayed on onend). start() now reports
  its failure so the button doesn't stay red when the browser refused
  to listen.
- Don't report no-speech as an error when the user already dictated
  something: Chrome fires it after a few seconds of silence, which is
  just the normal end of the session.
- Make the textarea read-only while the microphone is on, so an edit
  can't be silently overwritten by the next interim result.
- Show a notice while listening explaining that the browser does the
  transcription and that, depending on the browser, the audio can go to
  its own speech recognition service. The choice between the Web Speech
  API and the Gladys Plus STT endpoint still needs a maintainer call.

Autofix-Pass: 1
---
 front/src/config/i18n/de.json                 |  3 +-
 front/src/config/i18n/en.json                 |  3 +-
 front/src/config/i18n/fr.json                 |  3 +-
 front/src/routes/chat/ChatPage.js             | 11 +++
 .../src/routes/chat/ChatVoiceInputButton.jsx  | 91 ++++++++++++++++---
 front/src/routes/chat/style.css               |  6 ++
 front/src/utils/speechRecognition.js          | 26 +++++-
 7 files changed, 121 insertions(+), 22 deletions(-)

diff --git a/front/src/config/i18n/de.json b/front/src/config/i18n/de.json
index 7de7a51568..26db8f2e27 100644
--- a/front/src/config/i18n/de.json
+++ b/front/src/config/i18n/de.json
@@ -5716,7 +5716,8 @@
       "errorPermissionDenied": "Der Mikrofonzugriff wurde verweigert. Erlaube ihn in den Einstellungen deines Browsers, um eine Nachricht zu diktieren.",
       "errorNoMicrophone": "Kein Mikrofon erkannt. Schließe eines an oder aktiviere es in den Systemeinstellungen.",
       "errorNetwork": "Die Spracherkennung ist nicht verfügbar, dein Browser konnte seinen Sprachdienst nicht erreichen.",
-      "errorNotSupported": "Spracherkennung ist in diesem Browser nicht verfügbar."
+      "errorNotSupported": "Spracherkennung ist in diesem Browser nicht verfügbar.",
+      "browserTranscriptionNotice": "Dein Browser transkribiert, was du sagst: Gladys nimmt kein Audio auf und lädt keines hoch. Je nach Browser kann das Audio an dessen eigenen Spracherkennungsdienst gesendet werden (Google bei Chrome, lokale Verarbeitung bei Safari)."
     },
     "sidebar": {
       "title": "Wie funktioniert der Chat?",
diff --git a/front/src/config/i18n/en.json b/front/src/config/i18n/en.json
index 791534d582..af1b783c1f 100644
--- a/front/src/config/i18n/en.json
+++ b/front/src/config/i18n/en.json
@@ -5728,7 +5728,8 @@
       "errorPermissionDenied": "Microphone access was denied. Allow it in your browser settings to dictate a message.",
       "errorNoMicrophone": "No microphone detected. Plug one in or enable it in system settings.",
       "errorNetwork": "Speech recognition is unavailable, your browser could not reach its speech service.",
-      "errorNotSupported": "Speech recognition is not available in this browser."
+      "errorNotSupported": "Speech recognition is not available in this browser.",
+      "browserTranscriptionNotice": "Your browser transcribes what you say: Gladys neither records nor uploads any audio. Depending on your browser, the audio can be sent to its own speech recognition service (Google for Chrome, on-device for Safari)."
     }
   },
   "history": {
diff --git a/front/src/config/i18n/fr.json b/front/src/config/i18n/fr.json
index 72e8a36cc9..194e1042b6 100644
--- a/front/src/config/i18n/fr.json
+++ b/front/src/config/i18n/fr.json
@@ -5728,7 +5728,8 @@
       "errorPermissionDenied": "L'accès au micro a été refusé. Autorisez-le dans les réglages de votre navigateur pour dicter un message.",
       "errorNoMicrophone": "Aucun micro détecté. Branchez ou activez un micro dans les réglages système.",
       "errorNetwork": "La reconnaissance vocale est indisponible, votre navigateur n'a pas pu joindre son service vocal.",
-      "errorNotSupported": "La reconnaissance vocale n'est pas disponible dans ce navigateur."
+      "errorNotSupported": "La reconnaissance vocale n'est pas disponible dans ce navigateur.",
+      "browserTranscriptionNotice": "C'est votre navigateur qui transcrit ce que vous dites : Gladys n'enregistre et n'envoie aucun audio. Selon votre navigateur, l'audio peut être envoyé à son propre service de reconnaissance vocale (Google pour Chrome, traitement local pour Safari)."
     }
   },
   "history": {
diff --git a/front/src/routes/chat/ChatPage.js b/front/src/routes/chat/ChatPage.js
index b9f2ce9a38..1125157e61 100644
--- a/front/src/routes/chat/ChatPage.js
+++ b/front/src/routes/chat/ChatPage.js
@@ -32,6 +32,10 @@ const IntegrationPage = connect(
     const [selectedModel, setSelectedModel] = useState('auto');
     const [gladysPlusConfigured, setGladysPlusConfigured] = useState(null);
     const [voiceInputError, setVoiceInputError] = useState(null);
+    // While the microphone is on, the transcription rewrites the whole input:
+    // the textarea is read-only so an edit cannot be overwritten by the next
+    // interim result.
+    const [voiceInputListening, setVoiceInputListening] = useState(false);
     // Browsers without the Web Speech API (Firefox for example) simply don't
     // get a microphone button.
     const [voiceInputSupported] = useState(isSpeechRecognitionSupported);
@@ -125,6 +129,7 @@ const IntegrationPage = connect(
                               })}
                               placeholder={<Text id="chat.messagePlaceholder" />}
                               value={currentMessageTextInput}
+                              readOnly={voiceInputListening}
                               onInput={onComposerInput}
                               onKeyPress={handleKeyPress}
                             />
@@ -136,6 +141,7 @@ const IntegrationPage = connect(
                               currentText={currentMessageTextInput}
                               onTranscript={setMessageTextInput}
                               onError={setVoiceInputError}
+                              onListeningChange={setVoiceInputListening}
                             />
                           )}
                           <button
@@ -150,6 +156,11 @@ const IntegrationPage = connect(
                             <i class="fe fe-send" />
                           </button>
                         </div>
+                        {voiceInputListening && (
+                          <p class={style.voiceInputNotice}>
+                            <Text id="chat.voiceInput.browserTranscriptionNotice" />
+                          </p>
+                        )}
                         {voiceInputError && (
                           <p class={style.voiceInputError}>
                             <Text id={`chat.voiceInput.${voiceInputError}`} />
diff --git a/front/src/routes/chat/ChatVoiceInputButton.jsx b/front/src/routes/chat/ChatVoiceInputButton.jsx
index 1f9afd23bd..1e354b3fc2 100644
--- a/front/src/routes/chat/ChatVoiceInputButton.jsx
+++ b/front/src/routes/chat/ChatVoiceInputButton.jsx
@@ -20,13 +20,34 @@ class ChatVoiceInputButton extends Component {
 
   recognition = null;
 
+  /**
+   * Incremented at each new session, so a session which is ending cannot reset
+   * the state of the session which just started.
+   */
+  recognitionGeneration = 0;
+
+  /** True when the user asked to listen again while the previous session was still ending. */
+  restartWhenEnded = false;
+
   componentWillUnmount() {
+    this.recognitionGeneration += 1;
+    this.restartWhenEnded = false;
     if (this.recognition) {
       this.recognition.abort();
       this.recognition = null;
     }
   }
 
+  setListening = listening => {
+    if (this.state.listening === listening) {
+      return;
+    }
+    this.setState({ listening });
+    if (this.props.onListeningChange) {
+      this.props.onListeningChange(listening);
+    }
+  };
+
   handleTranscript = transcript => {
     const trimmedTranscript = transcript.trim();
     if (trimmedTranscript.length === 0) {
@@ -41,38 +62,80 @@ class ChatVoiceInputButton extends Component {
     this.props.onError(errorKey);
   };
 
-  handleEnd = () => {
+  handleEnd = generation => {
+    if (generation !== this.recognitionGeneration) {
+      // An older session ended after a new one started: it must not stop it.
+      return;
+    }
     this.recognition = null;
-    this.setState({ listening: false });
+    if (this.restartWhenEnded) {
+      this.restartWhenEnded = false;
+      this.startRecognition();
+      return;
+    }
+    this.setListening(false);
   };
 
-  startListening = () => {
-    this.props.onError(null);
+  /**
+   * @description Create and start a new recognition session.
+   */
+  startRecognition = () => {
     this.baseText = this.props.currentText || '';
+    this.recognitionGeneration += 1;
+    const generation = this.recognitionGeneration;
+    const isCurrentSession = () => generation === this.recognitionGeneration;
     const recognition = createSpeechRecognition({
       language: this.props.language,
-      onTranscript: this.handleTranscript,
-      onError: this.handleError,
-      onEnd: this.handleEnd
+      onTranscript: transcript => {
+        if (isCurrentSession()) {
+          this.handleTranscript(transcript);
+        }
+      },
+      onError: errorKey => {
+        if (isCurrentSession()) {
+          this.handleError(errorKey);
+        }
+      },
+      onEnd: () => this.handleEnd(generation)
     });
     if (!recognition) {
       this.props.onError('errorNotSupported');
+      this.setListening(false);
       return;
     }
     this.recognition = recognition;
-    this.setState({ listening: true });
-    recognition.start();
+    this.setListening(true);
+    if (!recognition.start()) {
+      // The browser refused to start: don't leave a button saying we listen.
+      this.recognition = null;
+      this.setListening(false);
+      this.props.onError('error');
+    }
+  };
+
+  startListening = () => {
+    this.props.onError(null);
+    if (this.recognition) {
+      // The previous session has not ended yet, starting a new one now would
+      // throw: it is started when the browser tells us that one ended.
+      this.restartWhenEnded = true;
+      this.setListening(true);
+      return;
+    }
+    this.startRecognition();
   };
 
   /**
    * @description Stop listening, keeping what was already transcribed in the input.
    */
   stopListening = () => {
+    this.restartWhenEnded = false;
     if (this.recognition) {
+      // The session is kept until the browser tells us it ended, so the next
+      // one is not started while this one is still running.
       this.recognition.stop();
-      this.recognition = null;
     }
-    this.setState({ listening: false });
+    this.setListening(false);
   };
 
   /**
@@ -81,13 +144,13 @@ class ChatVoiceInputButton extends Component {
    * the input the user just emptied.
    */
   cancelListening = () => {
+    this.restartWhenEnded = false;
+    this.recognitionGeneration += 1;
     if (this.recognition) {
       this.recognition.abort();
       this.recognition = null;
     }
-    if (this.state.listening) {
-      this.setState({ listening: false });
-    }
+    this.setListening(false);
   };
 
   handleClick = () => {
diff --git a/front/src/routes/chat/style.css b/front/src/routes/chat/style.css
index 099f97290b..6f617dff41 100644
--- a/front/src/routes/chat/style.css
+++ b/front/src/routes/chat/style.css
@@ -628,6 +628,12 @@
   color: #cd201f;
 }
 
+.voiceInputNotice {
+  margin: 8px 4px 0;
+  font-size: 12px;
+  color: #9aa7b5;
+}
+
 .emptyChatState {
   width: min(100%, 360px);
   text-align: center;
diff --git a/front/src/utils/speechRecognition.js b/front/src/utils/speechRecognition.js
index 9a47b13454..7aaec1581e 100644
--- a/front/src/utils/speechRecognition.js
+++ b/front/src/utils/speechRecognition.js
@@ -59,16 +59,20 @@ export function getSpeechRecognitionLocale(language) {
 /**
  * @description Translate a SpeechRecognition error code to a Gladys i18n key suffix.
  * @param {string} error - Error code given by the browser.
+ * @param {boolean} [hasTranscript] - Whether something was already transcribed in this session.
  * @returns {string|null} i18n key suffix, or null when the error must be ignored.
  * @example getSpeechRecognitionErrorKey('not-allowed');
  */
-export function getSpeechRecognitionErrorKey(error) {
+export function getSpeechRecognitionErrorKey(error, hasTranscript = false) {
   switch (error) {
     case 'aborted':
       // The user stopped the recognition himself, this is not an error.
       return null;
     case 'no-speech':
-      return 'errorNoSpeech';
+      // Chrome fires no-speech after a few seconds of silence, even when the
+      // user already dictated a sentence. In that case this is just the normal
+      // end of the session, not something to complain about.
+      return hasTranscript ? null : 'errorNoSpeech';
     case 'not-allowed':
     case 'service-not-allowed':
       return 'errorPermissionDenied';
@@ -106,6 +110,7 @@ export function createSpeechRecognition({ language, onTranscript, onError, onEnd
   recognition.interimResults = true;
 
   let finalTranscript = '';
+  let hasTranscript = false;
   let stopped = false;
 
   recognition.onresult = event => {
@@ -119,11 +124,15 @@ export function createSpeechRecognition({ language, onTranscript, onError, onEnd
         interimTranscript += transcript;
       }
     }
-    onTranscript(`${finalTranscript}${interimTranscript}`);
+    const fullTranscript = `${finalTranscript}${interimTranscript}`;
+    if (fullTranscript.trim().length > 0) {
+      hasTranscript = true;
+    }
+    onTranscript(fullTranscript);
   };
 
   recognition.onerror = event => {
-    const errorKey = getSpeechRecognitionErrorKey(event.error);
+    const errorKey = getSpeechRecognitionErrorKey(event.error, hasTranscript);
     if (errorKey && onError) {
       onError(errorKey);
     }
@@ -136,12 +145,19 @@ export function createSpeechRecognition({ language, onTranscript, onError, onEnd
   };
 
   return {
+    /**
+     * @description Start listening.
+     * @returns {boolean} True when the browser accepted to start listening.
+     */
     start() {
       try {
         recognition.start();
+        return true;
       } catch (e) {
-        // start() throws when the recognition is already running, nothing to do.
+        // start() throws when a recognition is already running: onend will
+        // never be called for this session, so the caller has to know it.
         console.error(e);
+        return false;
       }
     },
     stop() {

From e5bdcb0e5f9e00c21cb5f37409afd5eb86b730d1 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 16 Aug 2026 05:13:08 +0000
Subject: [PATCH 3/4] fix(chat): disclose voice input before use and keep
 dictation usable on Safari

- The notice explaining that the browser does the transcription is now shown
  as soon as the microphone button is available, instead of only once the
  recognition has started.
- Restarting a dictation no longer waits for the previous session `onend` to
  call `start()`: it is called in the click itself, which Safari requires, and
  the deferred restart is kept as a fallback for browsers refusing a second
  session while the previous one is still running.
- The listening pulse is disabled under `prefers-reduced-motion: reduce`.

Autofix-Pass: 2
---
 front/src/config/i18n/de.json                 |  2 +-
 front/src/config/i18n/en.json                 |  2 +-
 front/src/config/i18n/fr.json                 |  2 +-
 front/src/routes/chat/ChatPage.js             |  4 +-
 .../src/routes/chat/ChatVoiceInputButton.jsx  | 65 +++++++++++++------
 front/src/routes/chat/style.css               |  8 +++
 6 files changed, 58 insertions(+), 25 deletions(-)

diff --git a/front/src/config/i18n/de.json b/front/src/config/i18n/de.json
index 26db8f2e27..f9abbac1d7 100644
--- a/front/src/config/i18n/de.json
+++ b/front/src/config/i18n/de.json
@@ -5717,7 +5717,7 @@
       "errorNoMicrophone": "Kein Mikrofon erkannt. Schließe eines an oder aktiviere es in den Systemeinstellungen.",
       "errorNetwork": "Die Spracherkennung ist nicht verfügbar, dein Browser konnte seinen Sprachdienst nicht erreichen.",
       "errorNotSupported": "Spracherkennung ist in diesem Browser nicht verfügbar.",
-      "browserTranscriptionNotice": "Dein Browser transkribiert, was du sagst: Gladys nimmt kein Audio auf und lädt keines hoch. Je nach Browser kann das Audio an dessen eigenen Spracherkennungsdienst gesendet werden (Google bei Chrome, lokale Verarbeitung bei Safari)."
+      "browserTranscriptionNotice": "Wenn du eine Nachricht diktierst, transkribiert dein Browser, was du sagst: Gladys nimmt kein Audio auf und lädt keines hoch. Je nach Browser kann das Audio an dessen eigenen Spracherkennungsdienst gesendet werden (Google bei Chrome, lokale Verarbeitung bei Safari)."
     },
     "sidebar": {
       "title": "Wie funktioniert der Chat?",
diff --git a/front/src/config/i18n/en.json b/front/src/config/i18n/en.json
index af1b783c1f..3ea656f955 100644
--- a/front/src/config/i18n/en.json
+++ b/front/src/config/i18n/en.json
@@ -5729,7 +5729,7 @@
       "errorNoMicrophone": "No microphone detected. Plug one in or enable it in system settings.",
       "errorNetwork": "Speech recognition is unavailable, your browser could not reach its speech service.",
       "errorNotSupported": "Speech recognition is not available in this browser.",
-      "browserTranscriptionNotice": "Your browser transcribes what you say: Gladys neither records nor uploads any audio. Depending on your browser, the audio can be sent to its own speech recognition service (Google for Chrome, on-device for Safari)."
+      "browserTranscriptionNotice": "If you dictate a message, your browser transcribes what you say: Gladys neither records nor uploads any audio. Depending on your browser, the audio can be sent to its own speech recognition service (Google for Chrome, on-device for Safari)."
     }
   },
   "history": {
diff --git a/front/src/config/i18n/fr.json b/front/src/config/i18n/fr.json
index 194e1042b6..417c152209 100644
--- a/front/src/config/i18n/fr.json
+++ b/front/src/config/i18n/fr.json
@@ -5729,7 +5729,7 @@
       "errorNoMicrophone": "Aucun micro détecté. Branchez ou activez un micro dans les réglages système.",
       "errorNetwork": "La reconnaissance vocale est indisponible, votre navigateur n'a pas pu joindre son service vocal.",
       "errorNotSupported": "La reconnaissance vocale n'est pas disponible dans ce navigateur.",
-      "browserTranscriptionNotice": "C'est votre navigateur qui transcrit ce que vous dites : Gladys n'enregistre et n'envoie aucun audio. Selon votre navigateur, l'audio peut être envoyé à son propre service de reconnaissance vocale (Google pour Chrome, traitement local pour Safari)."
+      "browserTranscriptionNotice": "Si vous dictez un message, c'est votre navigateur qui transcrit ce que vous dites : Gladys n'enregistre et n'envoie aucun audio. Selon votre navigateur, l'audio peut être envoyé à son propre service de reconnaissance vocale (Google pour Chrome, traitement local pour Safari)."
     }
   },
   "history": {
diff --git a/front/src/routes/chat/ChatPage.js b/front/src/routes/chat/ChatPage.js
index 1125157e61..ab5b578bd0 100644
--- a/front/src/routes/chat/ChatPage.js
+++ b/front/src/routes/chat/ChatPage.js
@@ -156,7 +156,9 @@ const IntegrationPage = connect(
                             <i class="fe fe-send" />
                           </button>
                         </div>
-                        {voiceInputListening && (
+                        {voiceInputSupported && (
+                          // Shown as soon as the microphone button is available, so the user
+                          // knows where the audio goes before starting a dictation.
                           <p class={style.voiceInputNotice}>
                             <Text id="chat.voiceInput.browserTranscriptionNotice" />
                           </p>
diff --git a/front/src/routes/chat/ChatVoiceInputButton.jsx b/front/src/routes/chat/ChatVoiceInputButton.jsx
index 1e354b3fc2..610cebc8e2 100644
--- a/front/src/routes/chat/ChatVoiceInputButton.jsx
+++ b/front/src/routes/chat/ChatVoiceInputButton.jsx
@@ -20,22 +20,29 @@ class ChatVoiceInputButton extends Component {
 
   recognition = null;
 
+  /** Previous session which was asked to end and has not fired `onend` yet. */
+  endingRecognition = null;
+
   /**
    * Incremented at each new session, so a session which is ending cannot reset
    * the state of the session which just started.
    */
   recognitionGeneration = 0;
 
-  /** True when the user asked to listen again while the previous session was still ending. */
-  restartWhenEnded = false;
+  /** True when the browser refused to start while the previous session was still running. */
+  startWhenPreviousEnded = false;
 
   componentWillUnmount() {
     this.recognitionGeneration += 1;
-    this.restartWhenEnded = false;
+    this.startWhenPreviousEnded = false;
     if (this.recognition) {
       this.recognition.abort();
       this.recognition = null;
     }
+    if (this.endingRecognition) {
+      this.endingRecognition.abort();
+      this.endingRecognition = null;
+    }
   }
 
   setListening = listening => {
@@ -64,15 +71,17 @@ class ChatVoiceInputButton extends Component {
 
   handleEnd = generation => {
     if (generation !== this.recognitionGeneration) {
-      // An older session ended after a new one started: it must not stop it.
+      // An older session ended after a new one started: it must not stop it. It
+      // can only unblock it, when the browser refused to start while it was
+      // still running.
+      this.endingRecognition = null;
+      if (this.startWhenPreviousEnded) {
+        this.startWhenPreviousEnded = false;
+        this.startRecognition();
+      }
       return;
     }
     this.recognition = null;
-    if (this.restartWhenEnded) {
-      this.restartWhenEnded = false;
-      this.startRecognition();
-      return;
-    }
     this.setListening(false);
   };
 
@@ -105,22 +114,32 @@ class ChatVoiceInputButton extends Component {
     }
     this.recognition = recognition;
     this.setListening(true);
-    if (!recognition.start()) {
-      // The browser refused to start: don't leave a button saying we listen.
-      this.recognition = null;
-      this.setListening(false);
-      this.props.onError('error');
+    if (recognition.start()) {
+      return;
     }
+    this.recognition = null;
+    if (this.endingRecognition) {
+      // Chromium refuses a new session while the previous one is still running:
+      // it is started again as soon as the browser tells us that one ended.
+      this.startWhenPreviousEnded = true;
+      return;
+    }
+    // The browser refused to start: don't leave a button saying we listen.
+    this.setListening(false);
+    this.props.onError('error');
   };
 
   startListening = () => {
     this.props.onError(null);
     if (this.recognition) {
-      // The previous session has not ended yet, starting a new one now would
-      // throw: it is started when the browser tells us that one ended.
-      this.restartWhenEnded = true;
-      this.setListening(true);
-      return;
+      // The previous session was stopped and has not ended yet. The new one is
+      // still started right away, in the same click: Safari (especially on iOS)
+      // refuses `start()` outside of the gesture which granted the microphone,
+      // so waiting for `onend` to start would break dictating there. Browsers
+      // which refuse a second session instead (Chromium) go through the
+      // `startWhenPreviousEnded` path, which does not need a gesture.
+      this.endingRecognition = this.recognition;
+      this.recognition = null;
     }
     this.startRecognition();
   };
@@ -129,7 +148,7 @@ class ChatVoiceInputButton extends Component {
    * @description Stop listening, keeping what was already transcribed in the input.
    */
   stopListening = () => {
-    this.restartWhenEnded = false;
+    this.startWhenPreviousEnded = false;
     if (this.recognition) {
       // The session is kept until the browser tells us it ended, so the next
       // one is not started while this one is still running.
@@ -144,12 +163,16 @@ class ChatVoiceInputButton extends Component {
    * the input the user just emptied.
    */
   cancelListening = () => {
-    this.restartWhenEnded = false;
+    this.startWhenPreviousEnded = false;
     this.recognitionGeneration += 1;
     if (this.recognition) {
       this.recognition.abort();
       this.recognition = null;
     }
+    if (this.endingRecognition) {
+      this.endingRecognition.abort();
+      this.endingRecognition = null;
+    }
     this.setListening(false);
   };
 
diff --git a/front/src/routes/chat/style.css b/front/src/routes/chat/style.css
index 6f617dff41..f00e6e004f 100644
--- a/front/src/routes/chat/style.css
+++ b/front/src/routes/chat/style.css
@@ -622,6 +622,14 @@
   }
 }
 
+@media (prefers-reduced-motion: reduce) {
+  .voiceInputButtonListening,
+  .voiceInputButtonListening:hover,
+  .voiceInputButtonListening:focus {
+    animation: none !important;
+  }
+}
+
 .voiceInputError {
   margin: 8px 4px 0;
   font-size: 13px;

From 052a52b71ee768759dfccda508591fd781004934 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 16 Aug 2026 08:10:31 +0000
Subject: [PATCH 4/4] fix(chat): keep the composer locked while the dictation
 is stopping

Addresses the review feedback on the voice input:

- `stop()` still delivers a final result before `onend`, so unlocking the
  composer right away let a late transcript overwrite what the user typed
  in between. A `stopping` state now keeps the input read-only until the
  session actually ended, with a timeout as a safety net for browsers
  which never fire `onend`. The button goes back to its idle look
  immediately.
- The transcription notice no longer claims that Safari transcribes
  on-device: `processLocally` is not set, so the browser may use a remote
  service. The en/fr/de copy is now browser-neutral.
- Renamed the `voiceInputPulse` keyframe to kebab-case.

Autofix-Pass: 3
---
 front/src/config/i18n/de.json                 |  2 +-
 front/src/config/i18n/en.json                 |  2 +-
 front/src/config/i18n/fr.json                 |  2 +-
 .../src/routes/chat/ChatVoiceInputButton.jsx  | 68 ++++++++++++++++---
 front/src/routes/chat/style.css               |  4 +-
 5 files changed, 63 insertions(+), 15 deletions(-)

diff --git a/front/src/config/i18n/de.json b/front/src/config/i18n/de.json
index f9abbac1d7..d01300c7bb 100644
--- a/front/src/config/i18n/de.json
+++ b/front/src/config/i18n/de.json
@@ -5717,7 +5717,7 @@
       "errorNoMicrophone": "Kein Mikrofon erkannt. Schließe eines an oder aktiviere es in den Systemeinstellungen.",
       "errorNetwork": "Die Spracherkennung ist nicht verfügbar, dein Browser konnte seinen Sprachdienst nicht erreichen.",
       "errorNotSupported": "Spracherkennung ist in diesem Browser nicht verfügbar.",
-      "browserTranscriptionNotice": "Wenn du eine Nachricht diktierst, transkribiert dein Browser, was du sagst: Gladys nimmt kein Audio auf und lädt keines hoch. Je nach Browser kann das Audio an dessen eigenen Spracherkennungsdienst gesendet werden (Google bei Chrome, lokale Verarbeitung bei Safari)."
+      "browserTranscriptionNotice": "Wenn du eine Nachricht diktierst, transkribiert dein Browser, was du sagst: Gladys nimmt kein Audio auf und lädt keines hoch. Je nach Browser kann das Audio auf deinem Gerät verarbeitet oder an den eigenen Spracherkennungsdienst des Browsers gesendet werden."
     },
     "sidebar": {
       "title": "Wie funktioniert der Chat?",
diff --git a/front/src/config/i18n/en.json b/front/src/config/i18n/en.json
index 3ea656f955..c30594efea 100644
--- a/front/src/config/i18n/en.json
+++ b/front/src/config/i18n/en.json
@@ -5729,7 +5729,7 @@
       "errorNoMicrophone": "No microphone detected. Plug one in or enable it in system settings.",
       "errorNetwork": "Speech recognition is unavailable, your browser could not reach its speech service.",
       "errorNotSupported": "Speech recognition is not available in this browser.",
-      "browserTranscriptionNotice": "If you dictate a message, your browser transcribes what you say: Gladys neither records nor uploads any audio. Depending on your browser, the audio can be sent to its own speech recognition service (Google for Chrome, on-device for Safari)."
+      "browserTranscriptionNotice": "If you dictate a message, your browser transcribes what you say: Gladys neither records nor uploads any audio. Depending on your browser, the audio may be processed on your device or sent to your browser's own speech recognition service."
     }
   },
   "history": {
diff --git a/front/src/config/i18n/fr.json b/front/src/config/i18n/fr.json
index 417c152209..ad6261301d 100644
--- a/front/src/config/i18n/fr.json
+++ b/front/src/config/i18n/fr.json
@@ -5729,7 +5729,7 @@
       "errorNoMicrophone": "Aucun micro détecté. Branchez ou activez un micro dans les réglages système.",
       "errorNetwork": "La reconnaissance vocale est indisponible, votre navigateur n'a pas pu joindre son service vocal.",
       "errorNotSupported": "La reconnaissance vocale n'est pas disponible dans ce navigateur.",
-      "browserTranscriptionNotice": "Si vous dictez un message, c'est votre navigateur qui transcrit ce que vous dites : Gladys n'enregistre et n'envoie aucun audio. Selon votre navigateur, l'audio peut être envoyé à son propre service de reconnaissance vocale (Google pour Chrome, traitement local pour Safari)."
+      "browserTranscriptionNotice": "Si vous dictez un message, c'est votre navigateur qui transcrit ce que vous dites : Gladys n'enregistre et n'envoie aucun audio. Selon votre navigateur, l'audio peut être traité sur votre appareil ou envoyé au service de reconnaissance vocale de votre navigateur."
     }
   },
   "history": {
diff --git a/front/src/routes/chat/ChatVoiceInputButton.jsx b/front/src/routes/chat/ChatVoiceInputButton.jsx
index 610cebc8e2..65ca02a5a4 100644
--- a/front/src/routes/chat/ChatVoiceInputButton.jsx
+++ b/front/src/routes/chat/ChatVoiceInputButton.jsx
@@ -4,6 +4,9 @@ import cx from 'classnames';
 import { createSpeechRecognition } from '../../utils/speechRecognition';
 import style from './style.css';
 
+/** How long the input stays locked when a stopped session never fires `onend`. */
+const STOPPING_TIMEOUT_MS = 5000;
+
 /**
  * Microphone button dictating what the user says in the chat message input.
  * Everything is handled by the browser with the Web Speech API: Gladys never
@@ -12,7 +15,11 @@ import style from './style.css';
  */
 class ChatVoiceInputButton extends Component {
   state = {
-    listening: false
+    listening: false,
+    // True between the moment the user asked to stop and the moment the browser
+    // says the session ended: `stop()` still delivers a final result before
+    // `onend`, so the input must stay locked until then.
+    stopping: false
   };
 
   /** Text already in the input when the user started to talk. */
@@ -32,9 +39,16 @@ class ChatVoiceInputButton extends Component {
   /** True when the browser refused to start while the previous session was still running. */
   startWhenPreviousEnded = false;
 
+  /** Last state reported to the parent, which locks the input while it is true. */
+  reportedListening = false;
+
+  /** Safety net, in case a browser never fires `onend` after a `stop()`. */
+  stoppingTimeout = null;
+
   componentWillUnmount() {
     this.recognitionGeneration += 1;
     this.startWhenPreviousEnded = false;
+    this.clearStoppingTimeout();
     if (this.recognition) {
       this.recognition.abort();
       this.recognition = null;
@@ -45,13 +59,34 @@ class ChatVoiceInputButton extends Component {
     }
   }
 
-  setListening = listening => {
-    if (this.state.listening === listening) {
+  clearStoppingTimeout = () => {
+    if (this.stoppingTimeout) {
+      clearTimeout(this.stoppingTimeout);
+      this.stoppingTimeout = null;
+    }
+  };
+
+  /**
+   * @description Update the button state, and tell the parent whether the input
+   * must stay locked. It stays locked while a session is stopping, because a
+   * final result can still arrive and rewrite what the user typed meanwhile.
+   * @param {boolean} listening - True while a session is running.
+   * @param {boolean} stopping - True while a stopped session has not ended yet.
+   */
+  setListening = (listening, stopping = false) => {
+    if (!stopping) {
+      this.clearStoppingTimeout();
+    }
+    if (this.state.listening !== listening || this.state.stopping !== stopping) {
+      this.setState({ listening, stopping });
+    }
+    const shouldLock = listening || stopping;
+    if (this.reportedListening === shouldLock) {
       return;
     }
-    this.setState({ listening });
+    this.reportedListening = shouldLock;
     if (this.props.onListeningChange) {
-      this.props.onListeningChange(listening);
+      this.props.onListeningChange(shouldLock);
     }
   };
 
@@ -149,12 +184,25 @@ class ChatVoiceInputButton extends Component {
    */
   stopListening = () => {
     this.startWhenPreviousEnded = false;
-    if (this.recognition) {
-      // The session is kept until the browser tells us it ended, so the next
-      // one is not started while this one is still running.
-      this.recognition.stop();
+    if (!this.recognition) {
+      this.setListening(false);
+      return;
     }
-    this.setListening(false);
+    // The session is kept until the browser tells us it ended, so the next
+    // one is not started while this one is still running.
+    this.recognition.stop();
+    // The button goes back to its idle look right away, but the input stays
+    // locked until `onend`: `stop()` still delivers the final result of what
+    // was said, which would otherwise overwrite an edit made in between.
+    this.setListening(false, true);
+    this.clearStoppingTimeout();
+    this.stoppingTimeout = setTimeout(() => {
+      this.stoppingTimeout = null;
+      if (this.state.stopping) {
+        // A browser which never fired `onend` must not leave a locked input.
+        this.setListening(false);
+      }
+    }, STOPPING_TIMEOUT_MS);
   };
 
   /**
diff --git a/front/src/routes/chat/style.css b/front/src/routes/chat/style.css
index f00e6e004f..fd5028abdb 100644
--- a/front/src/routes/chat/style.css
+++ b/front/src/routes/chat/style.css
@@ -608,10 +608,10 @@
   background: #e74c3c;
   color: #fff;
   box-shadow: 0 2px 8px rgba(231, 76, 60, 0.4);
-  animation: voiceInputPulse 1.6s ease-in-out infinite;
+  animation: voice-input-pulse 1.6s ease-in-out infinite;
 }
 
-@keyframes voiceInputPulse {
+@keyframes voice-input-pulse {
   0%,
   100% {
     box-shadow: 0 2px 8px rgba(231, 76, 60, 0.4);