diff --git a/apps/mobile/README.md b/apps/mobile/README.md
index 78ff5e7..bcd941e 100644
--- a/apps/mobile/README.md
+++ b/apps/mobile/README.md
@@ -30,6 +30,12 @@ npm ci
 npm run web
 ```
 
+Voice prompts use the iOS and Android system speech-recognition services, which
+may use network transcription depending on the device and its settings. Because
+that support includes native code, this app cannot run in Expo Go; test it in a
+development build with `npm run ios` or `npm run android`. On web, dictation is
+shown when the browser provides the Web Speech API.
+
 ## Validate
 
 From the repo root:
diff --git a/apps/mobile/app.json b/apps/mobile/app.json
index 86df94f..ef3a77c 100644
--- a/apps/mobile/app.json
+++ b/apps/mobile/app.json
@@ -58,7 +58,14 @@
         {
           "photosPermission": "Allow Brio to attach photos as Hermes context.",
           "cameraPermission": "Allow Brio to take a photo and attach it as Hermes context.",
-          "microphonePermission": false
+          "microphonePermission": "Allow Brio to use the microphone for voice prompts."
+        }
+      ],
+      [
+        "expo-speech-recognition",
+        {
+          "microphonePermission": "Allow Brio to use the microphone for voice prompts.",
+          "speechRecognitionPermission": "Allow Brio to turn your speech into editable prompt text."
         }
       ],
       [
diff --git a/apps/mobile/package-lock.json b/apps/mobile/package-lock.json
index f855bf6..a4b4d65 100644
--- a/apps/mobile/package-lock.json
+++ b/apps/mobile/package-lock.json
@@ -27,6 +27,7 @@
         "expo-router": "~57.0.15",
         "expo-secure-store": "~57.0.1",
         "expo-sharing": "~57.0.14",
+        "expo-speech-recognition": "^56.0.4",
         "expo-splash-screen": "~57.0.7",
         "expo-status-bar": "~57.0.1",
         "expo-symbols": "~57.0.2",
@@ -8595,6 +8596,17 @@
         "react-native": "*"
       }
     },
+    "node_modules/expo-speech-recognition": {
+      "version": "56.0.4",
+      "resolved": "https://registry.npmjs.org/expo-speech-recognition/-/expo-speech-recognition-56.0.4.tgz",
+      "integrity": "sha512-6Sh6aeKSG4W81TYfHUL8sgOxO++YrUi5Zhpmu5tiWurm6NP5hFL1SHd6+GbtV7Fyo4Cc35AofR9QxiSROZMJcQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "expo": "*",
+        "react": "*",
+        "react-native": "*"
+      }
+    },
     "node_modules/expo-splash-screen": {
       "version": "57.0.7",
       "resolved": "https://registry.npmjs.org/expo-splash-screen/-/expo-splash-screen-57.0.7.tgz",
diff --git a/apps/mobile/package.json b/apps/mobile/package.json
index c761b97..463ef2f 100644
--- a/apps/mobile/package.json
+++ b/apps/mobile/package.json
@@ -22,6 +22,7 @@
     "expo-router": "~57.0.15",
     "expo-secure-store": "~57.0.1",
     "expo-sharing": "~57.0.14",
+    "expo-speech-recognition": "^56.0.4",
     "expo-splash-screen": "~57.0.7",
     "expo-status-bar": "~57.0.1",
     "expo-symbols": "~57.0.2",
diff --git a/apps/mobile/src/components/composer-controls.tsx b/apps/mobile/src/components/composer-controls.tsx
index 3d4d051..3729f07 100644
--- a/apps/mobile/src/components/composer-controls.tsx
+++ b/apps/mobile/src/components/composer-controls.tsx
@@ -1,8 +1,11 @@
 import { useQuery } from '@tanstack/react-query';
 import * as DocumentPicker from 'expo-document-picker';
 import * as ImagePicker from 'expo-image-picker';
+import { useIsFocused } from 'expo-router';
+import { SymbolView } from 'expo-symbols';
 import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
 import {
+  AppState,
   Modal,
   Platform,
   Pressable,
@@ -36,6 +39,22 @@ import {
 } from '@/lib/brio';
 import { applyCompletion, completionToken, composerContentFromSharedPayloads } from '@/lib/composer-model';
 import { uploadComposerAttachment, type AttachmentSource } from '@/lib/composer';
+import {
+  abortSpeechRecognition,
+  claimSpeechRecognition,
+  isSpeechRecognitionAvailable,
+  ownsSpeechRecognition,
+  releaseSpeechRecognitionBeforeStart,
+  requestSpeechRecognitionPermissions,
+  startSpeechRecognition,
+  stopSpeechRecognition,
+} from '@/lib/speech-recognition-controller';
+import {
+  appendSpeechTranscript,
+  mergeSpeechSegment,
+  normalizeSpeechRecognitionLocale,
+  speechRecognitionErrorMessage,
+} from '@/lib/speech-recognition-model';
 import type { ComposerAttachment, PromptDeliveryMode } from '@/state/composer-store-model';
 
 type UploadState = {
@@ -46,6 +65,8 @@ type UploadState = {
   error?: string;
 };
 
+type SpeechState = 'idle' | 'starting' | 'listening' | 'stopping';
+
 const COMPOSER_MOTION = {
   duration: 230,
   easing: Easing.bezier(0.2, 0, 0, 1),
@@ -64,6 +85,7 @@ export function ComposerControls({
   hydrated,
   keyboardVisible,
   forceExpanded = false,
+  visible = true,
   modelControl,
   onAddAttachment,
   onDraftChange,
@@ -85,6 +107,7 @@ export function ComposerControls({
   hydrated: boolean;
   keyboardVisible?: boolean;
   forceExpanded?: boolean;
+  visible?: boolean;
   modelControl?: ReactNode;
   onAddAttachment: (attachment: ComposerAttachment) => Promise<void>;
   onDraftChange: (text: string) => void;
@@ -98,9 +121,14 @@ export function ComposerControls({
 }) {
   const colors = useTheme();
   const incomingShare = useIncomingShareContext();
+  const isFocused = useIsFocused();
   const processedShare = useRef<string | null>(null);
   const inputRef = useRef<TextInput>(null);
   const previousKeyboardVisible = useRef(keyboardVisible);
+  const speechBaseDraft = useRef('');
+  const committedSpeech = useRef('');
+  const speechOwner = useRef(Symbol('composer-speech-owner'));
+  const speechRequest = useRef(0);
   const [pickerOpen, setPickerOpen] = useState(false);
   const [historyOpen, setHistoryOpen] = useState(false);
   const [commandsOpen, setCommandsOpen] = useState(false);
@@ -108,6 +136,7 @@ export function ComposerControls({
   const [inputHeight, setInputHeight] = useState(42);
   const [uploads, setUploads] = useState<UploadState[]>([]);
   const [error, setError] = useState('');
+  const [speechState, setSpeechState] = useState<SpeechState>('idle');
   const token = completionToken(draft);
 
   const capabilities = useQuery({
@@ -130,17 +159,21 @@ export function ComposerControls({
     enabled: commandsOpen,
     staleTime: 60_000,
   });
+  const speechActive = speechState !== 'idle';
+  const hasPrompt = Boolean(draft.trim()) || attachments.length > 0;
   const canSend =
     hydrated &&
     !sendDisabled &&
-    (Boolean(draft.trim()) || attachments.length > 0) &&
-    uploads.length === 0;
+    hasPrompt &&
+    uploads.length === 0 &&
+    !speechActive;
   const expanded =
     forceExpanded ||
     inputFocused ||
     pickerOpen ||
     historyOpen ||
     commandsOpen ||
+    speechActive ||
     attachments.length > 0 ||
     uploads.length > 0 ||
     Boolean(error) ||
@@ -181,6 +214,37 @@ export function ComposerControls({
     return () => clearTimeout(timer);
   }, [inputFocused, keyboardVisible]);
 
+  useEffect(() => {
+    if (isFocused) return;
+    speechRequest.current += 1;
+    abortSpeechRecognition(speechOwner.current);
+    if (!ownsSpeechRecognition(speechOwner.current)) setSpeechState('idle');
+  }, [isFocused]);
+
+  useEffect(() => {
+    if (visible) return;
+    speechRequest.current += 1;
+    abortSpeechRecognition(speechOwner.current);
+    if (!ownsSpeechRecognition(speechOwner.current)) setSpeechState('idle');
+  }, [visible]);
+
+  useEffect(() => {
+    const subscription = AppState.addEventListener('change', (state) => {
+      // iOS permission sheets can transiently report `inactive`; only a real
+      // background transition should cancel the permission/start sequence.
+      if (state !== 'background') return;
+      speechRequest.current += 1;
+      abortSpeechRecognition(speechOwner.current);
+      if (!ownsSpeechRecognition(speechOwner.current)) setSpeechState('idle');
+    });
+    return () => subscription.remove();
+  }, []);
+
+  useEffect(() => () => {
+    speechRequest.current += 1;
+    abortSpeechRecognition(speechOwner.current);
+  }, [connection.id, profile, sessionId]);
+
   const uploadSources = useCallback(async (sources: AttachmentSource[]) => {
     setPickerOpen(false);
     setError('');
@@ -230,7 +294,7 @@ export function ComposerControls({
   }, [attachments, capabilities.data, connection, onAddAttachment, profile, sessionId]);
 
   useEffect(() => {
-    if (incomingShare.isResolving || incomingShare.error || incomingShare.sharedPayloads.length === 0) return;
+    if (speechActive || incomingShare.isResolving || incomingShare.error || incomingShare.sharedPayloads.length === 0) return;
     const payloads = incomingShare.resolvedSharedPayloads.length
       ? incomingShare.resolvedSharedPayloads
       : incomingShare.sharedPayloads;
@@ -244,7 +308,7 @@ export function ComposerControls({
       incomingShare.consumeSharedPayloads();
       if (!succeeded) setError('Some shared files could not be imported. Share them again to retry.');
     })();
-  }, [draft, incomingShare, onDraftChange, uploadSources]);
+  }, [draft, incomingShare, onDraftChange, speechActive, uploadSources]);
 
   useEffect(() => {
     if (Platform.OS !== 'web' || typeof document === 'undefined') return;
@@ -317,10 +381,87 @@ export function ComposerControls({
     if (focused === inputFocused) return;
     setInputFocused(focused);
   };
+  const startSpeech = async () => {
+    const owner = speechOwner.current;
+    const request = ++speechRequest.current;
+    setError('');
+    inputRef.current?.blur();
+    setInputFocused(false);
+    setSpeechState('starting');
+    try {
+      if (!isSpeechRecognitionAvailable()) {
+        setError('Speech recognition is not available on this device or browser.');
+        setSpeechState('idle');
+        return;
+      }
+      const permission = await requestSpeechRecognitionPermissions();
+      if (request !== speechRequest.current) return;
+      if (!permission.granted) {
+        setError('Microphone and speech recognition access are required. Enable them in device settings.');
+        setSpeechState('idle');
+        return;
+      }
+      if (AppState.currentState !== 'active' || !visible || !isFocused) {
+        setSpeechState('idle');
+        return;
+      }
+      const claimed = claimSpeechRecognition(owner, {
+        onStart: () => setSpeechState('listening'),
+        onResult: (event) => {
+          const segment = event.results[0]?.transcript ?? '';
+          if (!segment.trim()) return;
+          if (event.isFinal) committedSpeech.current = mergeSpeechSegment(committedSpeech.current, segment);
+          const transcript = event.isFinal
+            ? committedSpeech.current
+            : mergeSpeechSegment(committedSpeech.current, segment);
+          onDraftChange(appendSpeechTranscript(speechBaseDraft.current, transcript));
+        },
+        onNoMatch: () => setError("I didn't hear any speech. Tap the mic and try again."),
+        onError: (event) => {
+          const message = speechRecognitionErrorMessage(event.error);
+          if (message) setError(message);
+          setSpeechState('stopping');
+        },
+        onEnd: () => setSpeechState('idle'),
+      });
+      if (!claimed) {
+        setError('Dictation is already active in another composer.');
+        setSpeechState('idle');
+        return;
+      }
+      speechBaseDraft.current = draft;
+      committedSpeech.current = '';
+      startSpeechRecognition(owner, {
+        addsPunctuation: true,
+        continuous: false,
+        interimResults: true,
+        lang: normalizeSpeechRecognitionLocale(Intl.DateTimeFormat().resolvedOptions().locale),
+        maxAlternatives: 1,
+      });
+    } catch (reason) {
+      releaseSpeechRecognitionBeforeStart(owner);
+      setSpeechState('idle');
+      setError(reason instanceof Error ? reason.message : 'Could not start speech recognition.');
+    }
+  };
+  const stopSpeech = () => {
+    if (speechState === 'starting') {
+      speechRequest.current += 1;
+      abortSpeechRecognition(speechOwner.current);
+      if (!ownsSpeechRecognition(speechOwner.current)) setSpeechState('idle');
+      return;
+    }
+    if (speechState === 'stopping') {
+      abortSpeechRecognition(speechOwner.current);
+      return;
+    }
+    setSpeechState('stopping');
+    stopSpeechRecognition(speechOwner.current);
+  };
 
   return (
     <>
-      {suggestions.data?.items.length && token ? (
+      {!speechActive && suggestions.data?.items.length && token ? (
         <ScrollView keyboardShouldPersistTaps="handled" style={[styles.completions, { backgroundColor: colors.panelStrong, borderColor: colors.border }]}>
           {suggestions.data.items.slice(0, 12).map((item) => (
             <Pressable key={`${item.text}:${item.meta}`} onPress={() => onDraftChange(applyCompletion(draft, token, item.text))} style={styles.completionRow}>
@@ -389,6 +530,7 @@ export function ComposerControls({
           </Animated.View>
           <TextInput
             accessibilityLabel="Ask Hermes anything"
+            editable={!speechActive}
             maxLength={20000}
             multiline
             onBlur={() => {
@@ -403,7 +545,7 @@ export function ComposerControls({
               setInputHeight(nextHeight);
             }}
             onFocus={() => setFocused(true)}
-            placeholder={active ? 'Ask a follow-up…' : 'Ask Hermes anything…'}
+            placeholder={speechActive ? 'Listening…' : active ? 'Ask a follow-up…' : 'Ask Hermes anything…'}
             placeholderTextColor={colors.textTertiary}
             ref={inputRef}
             scrollEnabled={expanded && inputHeight >= 96}
@@ -420,24 +562,28 @@ export function ComposerControls({
           <Animated.View
             pointerEvents={expanded ? 'none' : 'auto'}
             style={[styles.compactRightSlot, compactRightStyle]}>
-            <Pressable
-              accessibilityElementsHidden={expanded}
-              accessibilityLabel={active ? 'Queue message' : 'Send message'}
-              accessible={!expanded}
-              disabled={!canSend}
-              onPress={() => onSend('queue')}
-              style={({ pressed }) => [
-                styles.sendPressable,
-                {
-                  backgroundColor: canSend ? colors.accent : colors.backgroundSelected,
-                  opacity: pressed ? 0.72 : 1,
-                },
-              ]}>
-              <ThemedText
-                style={{ color: canSend ? colors.accentText : colors.textDisabled, fontSize: 20 }}>
-                ↑
-              </ThemedText>
-            </Pressable>
+            {!hasPrompt && uploads.length === 0 ? (
+              <VoiceAction compact hidden={expanded} onPress={() => void startSpeech()} state={speechState} />
+            ) : (
+              <Pressable
+                accessibilityElementsHidden={expanded}
+                accessibilityLabel={active ? 'Queue message' : 'Send message'}
+                accessible={!expanded}
+                disabled={!canSend}
+                onPress={() => onSend('queue')}
+                style={({ pressed }) => [
+                  styles.sendPressable,
+                  {
+                    backgroundColor: canSend ? colors.accent : colors.backgroundSelected,
+                    opacity: pressed ? 0.72 : 1,
+                  },
+                ]}>
+                <ThemedText
+                  style={{ color: canSend ? colors.accentText : colors.textDisabled, fontSize: 20 }}>
+                  ↑
+                </ThemedText>
+              </Pressable>
+            )}
           </Animated.View>
         </View>
         {expanded ? (
@@ -448,12 +594,16 @@ export function ComposerControls({
               keyboardShouldPersistTaps="handled"
               style={styles.toolbarScroller}
               showsHorizontalScrollIndicator={false}>
-              <ToolbarAction bare label="+" accessibilityLabel="Attach context" onPress={() => setPickerOpen(true)} />
-              {modelControl}
-              <ToolbarAction accessibilityLabel="Commands" label="/" onPress={() => setCommandsOpen(true)} />
-              {history.length > 0 ? <ToolbarAction accessibilityLabel="Prompt history" label="↶" onPress={() => setHistoryOpen(true)} /> : null}
-              {canUndo ? <ToolbarAction label="Undo" onPress={onUndo} /> : null}
-              {canRedo ? <ToolbarAction label="Redo" onPress={onRedo} /> : null}
+              <ToolbarAction bare disabled={speechActive} label="+" accessibilityLabel="Attach context" onPress={() => setPickerOpen(true)} />
+              <VoiceAction
+                onPress={speechActive ? stopSpeech : () => void startSpeech()}
+                state={speechState}
+              />
+              {speechActive ? null : modelControl}
+              <ToolbarAction disabled={speechActive} accessibilityLabel="Commands" label="/" onPress={() => setCommandsOpen(true)} />
+              {history.length > 0 ? <ToolbarAction disabled={speechActive} accessibilityLabel="Prompt history" label="↶" onPress={() => setHistoryOpen(true)} /> : null}
+              {canUndo ? <ToolbarAction disabled={speechActive} label="Undo" onPress={onUndo} /> : null}
+              {canRedo ? <ToolbarAction disabled={speechActive} label="Redo" onPress={onRedo} /> : null}
               {active ? <ToolbarAction disabled={!canSend} label="Redirect" onPress={() => onSend('redirect')} tone="warning" /> : null}
             </ScrollView>
             <Pressable
@@ -487,6 +637,58 @@ function AttachmentChip({ detail, name, onRemove, tone = 'normal' }: { detail: s
   );
 }
 
+function VoiceAction({
+  compact = false,
+  hidden = false,
+  onPress,
+  state,
+}: {
+  compact?: boolean;
+  hidden?: boolean;
+  onPress: () => void;
+  state: SpeechState;
+}) {
+  const colors = useTheme();
+  const active = state !== 'idle';
+  const label = state === 'starting'
+    ? 'Starting dictation'
+    : state === 'stopping'
+      ? 'Force stop dictation'
+      : state === 'listening'
+        ? 'Stop dictation'
+        : 'Dictate prompt';
+  const symbol = active
+    ? ({ ios: 'stop.fill', android: 'stop', web: 'stop' } as const)
+    : ({ ios: 'mic.fill', android: 'mic_none', web: 'mic_none' } as const);
+
+  return (
+    <Pressable
+      accessibilityElementsHidden={hidden}
+      accessibilityLabel={label}
+      accessible={!hidden}
+      onPress={onPress}
+      style={({ pressed }) => [
+        compact ? styles.sendPressable : styles.voiceAction,
+        {
+          backgroundColor: active ? colors.danger : colors.backgroundSelected,
+          opacity: state === 'stopping' ? 0.72 : pressed ? 0.62 : 1,
+        },
+      ]}>
+      <SymbolView
+        fallback={<ThemedText style={{ color: active ? '#fff' : colors.textSecondary }} type="smallBold">Mic</ThemedText>}
+        name={symbol}
+        size={compact ? 20 : 18}
+        tintColor={active ? '#fff' : colors.textSecondary}
+      />
+      {!compact && active ? (
+        <ThemedText style={{ color: '#fff' }} type="smallBold">
+          {state === 'stopping' ? 'Finishing…' : state === 'starting' ? 'Starting…' : 'Listening…'}
+        </ThemedText>
+      ) : null}
+    </Pressable>
+  );
+}
+
 function ToolbarAction({ accessibilityLabel, bare = false, disabled, label, onPress, tone = 'normal' }: { accessibilityLabel?: string; bare?: boolean; disabled?: boolean; label: string; onPress: () => void; tone?: 'normal' | 'warning' }) {
   const colors = useTheme();
   return (
@@ -622,6 +824,16 @@ const styles = StyleSheet.create({
   },
   send: { alignItems: 'center', borderRadius: 20, height: 40, justifyContent: 'center', width: 40 },
   sendPressable: { alignItems: 'center', borderRadius: 20, height: 40, justifyContent: 'center', width: 40 },
+  voiceAction: {
+    alignItems: 'center',
+    borderRadius: 999,
+    flexDirection: 'row',
+    gap: 6,
+    justifyContent: 'center',
+    minHeight: 34,
+    minWidth: 38,
+    paddingHorizontal: 10,
+  },
   compactLeftSlot: { height: 40, justifyContent: 'center', overflow: 'hidden' },
   compactRightSlot: { alignItems: 'flex-end', height: 40, justifyContent: 'center', overflow: 'hidden' },
   compactControlPressable: { alignItems: 'center', height: 40, justifyContent: 'center', width: 36 },
diff --git a/apps/mobile/src/features/home/hermes-home-screen.tsx b/apps/mobile/src/features/home/hermes-home-screen.tsx
index 109fc44..eb3d92b 100644
--- a/apps/mobile/src/features/home/hermes-home-screen.tsx
+++ b/apps/mobile/src/features/home/hermes-home-screen.tsx
@@ -219,6 +219,7 @@ export function HermesHomeScreen({ connection }: { connection: AgentConnection }
 
       <HermesThreadScreen
         key={`${activeProfile}:${conversationEpoch}`}
+        composerVisible={!historyOpen && !settingsOpen}
         connection={connection}
         embedded
         initialSearchQuery={threadSearchQuery}
diff --git a/apps/mobile/src/features/threads/hermes-thread-screen.tsx b/apps/mobile/src/features/threads/hermes-thread-screen.tsx
index f8c0dd2..582ce9b 100644
--- a/apps/mobile/src/features/threads/hermes-thread-screen.tsx
+++ b/apps/mobile/src/features/threads/hermes-thread-screen.tsx
@@ -120,6 +120,7 @@ function createDraftSessionId() {
 
 export function HermesThreadScreen({
   connection,
+  composerVisible = true,
   embedded = false,
   initialModelOverride,
   initialSearchQuery = '',
@@ -128,6 +129,7 @@ export function HermesThreadScreen({
   routeSessionId,
 }: {
   connection: AgentConnection;
+  composerVisible?: boolean;
   embedded?: boolean;
   initialModelOverride?: ChatModelOverride;
   initialSearchQuery?: string;
@@ -1143,6 +1145,7 @@ export function HermesThreadScreen({
               canRedo={Boolean(revisions?.future.length)}
               canUndo={Boolean(revisions?.past.length)}
               connection={connection}
+              visible={composerVisible}
               draft={draft}
               forceExpanded={modelPickerOpen}
               history={history}
diff --git a/apps/mobile/src/lib/speech-recognition-controller.ts b/apps/mobile/src/lib/speech-recognition-controller.ts
new file mode 100644
index 0000000..dcd9764
--- /dev/null
+++ b/apps/mobile/src/lib/speech-recognition-controller.ts
@@ -0,0 +1,61 @@
+import {
+  ExpoSpeechRecognitionModule,
+  type ExpoSpeechRecognitionErrorEvent,
+  type ExpoSpeechRecognitionOptions,
+  type ExpoSpeechRecognitionResultEvent,
+} from 'expo-speech-recognition';
+
+import {
+  SpeechRecognitionCoordinator,
+  type SpeechRecognitionDriver,
+  type SpeechRecognitionSink,
+} from '@/lib/speech-recognition-coordinator';
+
+type BrioSpeechDriver = SpeechRecognitionDriver<
+  ExpoSpeechRecognitionOptions,
+  ExpoSpeechRecognitionResultEvent,
+  ExpoSpeechRecognitionErrorEvent
+>;
+
+const coordinator = new SpeechRecognitionCoordinator<
+  ExpoSpeechRecognitionOptions,
+  ExpoSpeechRecognitionResultEvent,
+  ExpoSpeechRecognitionErrorEvent
+>(ExpoSpeechRecognitionModule as unknown as BrioSpeechDriver);
+
+export type BrioSpeechRecognitionSink = SpeechRecognitionSink<
+  ExpoSpeechRecognitionResultEvent,
+  ExpoSpeechRecognitionErrorEvent
+>;
+
+export function claimSpeechRecognition(id: symbol, sink: BrioSpeechRecognitionSink) {
+  return coordinator.claim(id, sink);
+}
+
+export function startSpeechRecognition(id: symbol, options: ExpoSpeechRecognitionOptions) {
+  return coordinator.start(id, options);
+}
+
+export function stopSpeechRecognition(id: symbol) {
+  coordinator.stop(id);
+}
+
+export function abortSpeechRecognition(id: symbol) {
+  coordinator.abort(id);
+}
+
+export function releaseSpeechRecognitionBeforeStart(id: symbol) {
+  coordinator.releaseBeforeStart(id);
+}
+
+export function ownsSpeechRecognition(id: symbol) {
+  return coordinator.isOwner(id);
+}
+
+export function isSpeechRecognitionAvailable() {
+  return ExpoSpeechRecognitionModule.isRecognitionAvailable();
+}
+
+export function requestSpeechRecognitionPermissions() {
+  return ExpoSpeechRecognitionModule.requestPermissionsAsync();
+}
diff --git a/apps/mobile/src/lib/speech-recognition-coordinator.test.mjs b/apps/mobile/src/lib/speech-recognition-coordinator.test.mjs
new file mode 100644
index 0000000..adc3b8d
--- /dev/null
+++ b/apps/mobile/src/lib/speech-recognition-coordinator.test.mjs
@@ -0,0 +1,136 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { SpeechRecognitionCoordinator } from './speech-recognition-coordinator.ts';
+
+class FakeSpeechDriver {
+  listeners = new Map();
+  state = 'inactive';
+  aborts = 0;
+  abortChangesState = true;
+  stops = 0;
+
+  abort() {
+    this.aborts += 1;
+    if (this.abortChangesState) this.state = 'inactive';
+  }
+
+  addListener(event, listener) {
+    this.listeners.set(event, listener);
+    return { remove() {} };
+  }
+
+  emit(event, payload = null) {
+    this.listeners.get(event)?.(payload);
+  }
+
+  async getStateAsync() {
+    return this.state;
+  }
+
+  start() {
+    this.state = 'recognizing';
+  }
+
+  stop() {
+    this.stops += 1;
+    this.state = 'stopping';
+  }
+}
+
+function sink(events, name) {
+  return {
+    onEnd: () => events.push(`${name}:end`),
+    onError: () => events.push(`${name}:error`),
+    onNoMatch: () => events.push(`${name}:nomatch`),
+    onResult: () => events.push(`${name}:result`),
+    onStart: () => events.push(`${name}:start`),
+  };
+}
+
+test('serializes singleton recognition events to exactly one owner', () => {
+  const driver = new FakeSpeechDriver();
+  const coordinator = new SpeechRecognitionCoordinator(driver);
+  const events = [];
+  const first = Symbol('first');
+
+  assert.equal(coordinator.claim(first, sink(events, 'first')), true);
+  assert.equal(coordinator.claim(Symbol('second'), sink(events, 'second')), false);
+  coordinator.start(first, {});
+  driver.emit('start');
+  driver.emit('result', { transcript: 'hello' });
+  driver.emit('end');
+
+  assert.deepEqual(events, ['first:start', 'first:result', 'first:end']);
+  assert.equal(coordinator.claim(Symbol('second'), sink(events, 'second')), true);
+});
+
+test('does not allow a restart between an error and its trailing end event', () => {
+  const driver = new FakeSpeechDriver();
+  const coordinator = new SpeechRecognitionCoordinator(driver, 1000, 10);
+  const events = [];
+  const first = Symbol('first');
+
+  coordinator.claim(first, sink(events, 'first'));
+  coordinator.start(first, {});
+  driver.emit('error', { error: 'network' });
+  assert.equal(coordinator.claim(Symbol('second'), sink(events, 'second')), false);
+  driver.emit('end');
+  assert.deepEqual(events, ['first:error', 'first:end']);
+});
+
+test('force-aborts a recognizer that never finishes stopping', async () => {
+  const driver = new FakeSpeechDriver();
+  const coordinator = new SpeechRecognitionCoordinator(driver, 5, 5);
+  const events = [];
+  const owner = Symbol('owner');
+
+  coordinator.claim(owner, sink(events, 'owner'));
+  coordinator.start(owner, {});
+  coordinator.stop(owner);
+  await new Promise((resolve) => setTimeout(resolve, 20));
+
+  assert.equal(driver.stops, 1);
+  assert.equal(driver.aborts, 1);
+  assert.deepEqual(events, ['owner:end']);
+});
+
+test('eventually releases a recognizer even when abort never changes native state', async () => {
+  const driver = new FakeSpeechDriver();
+  driver.abortChangesState = false;
+  const coordinator = new SpeechRecognitionCoordinator(driver, 5, 5, 5);
+  const events = [];
+  const owner = Symbol('owner');
+
+  coordinator.claim(owner, sink(events, 'owner'));
+  coordinator.start(owner, {});
+  coordinator.abort(owner);
+  await new Promise((resolve) => setTimeout(resolve, 8));
+
+  assert.equal(driver.state, 'recognizing');
+  assert.deepEqual(events, ['owner:end']);
+  assert.equal(coordinator.claim(Symbol('too-early'), sink(events, 'too-early')), false);
+  await new Promise((resolve) => setTimeout(resolve, 8));
+  assert.equal(coordinator.claim(Symbol('next'), sink(events, 'next')), true);
+});
+
+test('drains a delayed old end before allowing the next session', async () => {
+  const driver = new FakeSpeechDriver();
+  const coordinator = new SpeechRecognitionCoordinator(driver, 5, 5, 50);
+  const events = [];
+  const first = Symbol('first');
+  const second = Symbol('second');
+
+  coordinator.claim(first, sink(events, 'first'));
+  coordinator.start(first, {});
+  coordinator.abort(first);
+  await new Promise((resolve) => setTimeout(resolve, 8));
+  assert.equal(coordinator.claim(second, sink(events, 'second')), false);
+
+  driver.emit('end');
+  assert.equal(coordinator.claim(second, sink(events, 'second')), true);
+  coordinator.start(second, {});
+  driver.emit('result', { transcript: 'new' });
+
+  assert.deepEqual(events, ['first:end', 'second:result']);
+});
diff --git a/apps/mobile/src/lib/speech-recognition-coordinator.ts b/apps/mobile/src/lib/speech-recognition-coordinator.ts
new file mode 100644
index 0000000..45bb7b3
--- /dev/null
+++ b/apps/mobile/src/lib/speech-recognition-coordinator.ts
@@ -0,0 +1,194 @@
+export type SpeechRecognitionEventMap<ResultEvent, ErrorEvent> = {
+  start: null;
+  result: ResultEvent;
+  nomatch: null;
+  error: ErrorEvent;
+  end: null;
+};
+
+export type SpeechRecognitionDriver<Options, ResultEvent, ErrorEvent> = {
+  abort: () => void;
+  addListener: <Event extends keyof SpeechRecognitionEventMap<ResultEvent, ErrorEvent>>(
+    event: Event,
+    listener: (payload: SpeechRecognitionEventMap<ResultEvent, ErrorEvent>[Event]) => void,
+  ) => { remove: () => void };
+  getStateAsync: () => Promise<string>;
+  start: (options: Options) => void;
+  stop: () => void;
+};
+
+export type SpeechRecognitionSink<ResultEvent, ErrorEvent> = {
+  onEnd: () => void;
+  onError: (event: ErrorEvent) => void;
+  onNoMatch: () => void;
+  onResult: (event: ResultEvent) => void;
+  onStart: () => void;
+};
+
+type ActiveSession<ResultEvent, ErrorEvent> = {
+  id: symbol;
+  sink: SpeechRecognitionSink<ResultEvent, ErrorEvent>;
+  started: boolean;
+};
+
+export class SpeechRecognitionCoordinator<Options, ResultEvent, ErrorEvent> {
+  private active: ActiveSession<ResultEvent, ErrorEvent> | null = null;
+  private draining = false;
+  private drainTimer: ReturnType<typeof setTimeout> | null = null;
+  private watchdog: ReturnType<typeof setTimeout> | null = null;
+  private readonly abortGraceMs: number;
+  private readonly drainQuietMs: number;
+  private readonly driver: SpeechRecognitionDriver<Options, ResultEvent, ErrorEvent>;
+  private readonly stopTimeoutMs: number;
+
+  constructor(
+    driver: SpeechRecognitionDriver<Options, ResultEvent, ErrorEvent>,
+    stopTimeoutMs = 5000,
+    abortGraceMs = 750,
+    drainQuietMs = 1000,
+  ) {
+    this.driver = driver;
+    this.stopTimeoutMs = stopTimeoutMs;
+    this.abortGraceMs = abortGraceMs;
+    this.drainQuietMs = drainQuietMs;
+    driver.addListener('start', () => {
+      if (this.consumeDrainingEvent()) return;
+      this.active?.sink.onStart();
+    });
+    driver.addListener('result', (event) => {
+      if (this.consumeDrainingEvent()) return;
+      this.active?.sink.onResult(event);
+    });
+    driver.addListener('nomatch', () => {
+      if (this.consumeDrainingEvent()) return;
+      this.active?.sink.onNoMatch();
+    });
+    driver.addListener('error', (event) => {
+      if (this.consumeDrainingEvent()) return;
+      const session = this.active;
+      if (!session) return;
+      session.sink.onError(event);
+      this.armStopWatchdog(session);
+    });
+    driver.addListener('end', () => {
+      if (this.draining) {
+        this.endDrain();
+        return;
+      }
+      this.finish(this.active);
+    });
+  }
+
+  claim(id: symbol, sink: SpeechRecognitionSink<ResultEvent, ErrorEvent>) {
+    if (this.active || this.draining) return false;
+    this.active = { id, sink, started: false };
+    return true;
+  }
+
+  isOwner(id: symbol) {
+    return this.active?.id === id;
+  }
+
+  start(id: symbol, options: Options) {
+    const session = this.session(id);
+    if (!session) return false;
+    session.started = true;
+    try {
+      this.driver.start(options);
+      return true;
+    } catch (error) {
+      session.started = false;
+      this.finish(session);
+      throw error;
+    }
+  }
+
+  releaseBeforeStart(id: symbol) {
+    const session = this.session(id);
+    if (session && !session.started) this.finish(session);
+  }
+
+  stop(id: symbol) {
+    const session = this.session(id);
+    if (!session) return;
+    if (!session.started) {
+      this.finish(session);
+      return;
+    }
+    this.driver.stop();
+    this.armStopWatchdog(session);
+  }
+
+  abort(id: symbol) {
+    const session = this.session(id);
+    if (!session) return;
+    if (!session.started) {
+      this.finish(session);
+      return;
+    }
+    this.driver.abort();
+    if (this.active === session) this.armAbortFallback(session);
+  }
+
+  private session(id: symbol) {
+    return this.active?.id === id ? this.active : null;
+  }
+
+  private armStopWatchdog(session: ActiveSession<ResultEvent, ErrorEvent>) {
+    this.clearWatchdog();
+    this.watchdog = setTimeout(() => {
+      if (this.active !== session) return;
+      this.driver.abort();
+      if (this.active === session) this.armAbortFallback(session);
+    }, this.stopTimeoutMs);
+  }
+
+  private armAbortFallback(session: ActiveSession<ResultEvent, ErrorEvent>) {
+    this.clearWatchdog();
+    this.watchdog = setTimeout(() => {
+      if (this.active !== session) return;
+      // Native recognizers occasionally remain in a stale `stopping` state forever.
+      // Release our owner regardless, then drain untagged native events before a new
+      // session can claim the singleton.
+      this.beginDrain(session);
+    }, this.abortGraceMs);
+  }
+
+  private beginDrain(session: ActiveSession<ResultEvent, ErrorEvent>) {
+    if (this.active !== session) return;
+    this.clearWatchdog();
+    this.active = null;
+    this.draining = true;
+    session.sink.onEnd();
+    this.armDrainQuietTimer();
+  }
+
+  private consumeDrainingEvent() {
+    if (!this.draining) return false;
+    this.armDrainQuietTimer();
+    return true;
+  }
+
+  private armDrainQuietTimer() {
+    if (this.drainTimer) clearTimeout(this.drainTimer);
+    this.drainTimer = setTimeout(() => this.endDrain(), this.drainQuietMs);
+  }
+
+  private endDrain() {
+    if (this.drainTimer) clearTimeout(this.drainTimer);
+    this.drainTimer = null;
+    this.draining = false;
+  }
+
+  private finish(session: ActiveSession<ResultEvent, ErrorEvent> | null) {
+    if (!session || this.active !== session) return;
+    this.clearWatchdog();
+    this.active = null;
+    session.sink.onEnd();
+  }
+
+  private clearWatchdog() {
+    if (this.watchdog) clearTimeout(this.watchdog);
+    this.watchdog = null;
+  }
+}
diff --git a/apps/mobile/src/lib/speech-recognition-model.test.mjs b/apps/mobile/src/lib/speech-recognition-model.test.mjs
new file mode 100644
index 0000000..c981196
--- /dev/null
+++ b/apps/mobile/src/lib/speech-recognition-model.test.mjs
@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  appendSpeechTranscript,
+  mergeSpeechSegment,
+  normalizeSpeechRecognitionLocale,
+  speechRecognitionErrorMessage,
+} from './speech-recognition-model.ts';
+
+test('adds dictated text to an existing draft without changing its content', () => {
+  assert.equal(appendSpeechTranscript('', '  draft a reply  '), 'draft a reply');
+  assert.equal(appendSpeechTranscript('Please', '  draft a reply  '), 'Please draft a reply');
+  assert.equal(appendSpeechTranscript('Please\n', 'draft a reply'), 'Please\ndraft a reply');
+});
+
+test('combines sequential final recognition segments', () => {
+  assert.equal(mergeSpeechSegment('', 'hello there'), 'hello there');
+  assert.equal(mergeSpeechSegment('hello there', 'how are you'), 'hello there how are you');
+  assert.equal(mergeSpeechSegment('hello', 'hello there'), 'hello there');
+});
+
+test('turns recognition failures into useful composer messages', () => {
+  assert.equal(speechRecognitionErrorMessage('aborted'), '');
+  assert.match(speechRecognitionErrorMessage('not-allowed'), /device settings/);
+  assert.match(speechRecognitionErrorMessage('no-speech'), /didn't hear/);
+});
+
+test('normalizes system locales and keeps dictated drafts within composer limits', () => {
+  assert.equal(normalizeSpeechRecognitionLocale('es_VE'), 'es-VE');
+  assert.equal(normalizeSpeechRecognitionLocale('en-US-u-ca-gregory'), 'en-US');
+  assert.equal(appendSpeechTranscript('a'.repeat(19_999), 'hello').length, 20_000);
+});
diff --git a/apps/mobile/src/lib/speech-recognition-model.ts b/apps/mobile/src/lib/speech-recognition-model.ts
new file mode 100644
index 0000000..d555eff
--- /dev/null
+++ b/apps/mobile/src/lib/speech-recognition-model.ts
@@ -0,0 +1,60 @@
+export type SpeechRecognitionError =
+  | 'aborted'
+  | 'audio-capture'
+  | 'interrupted'
+  | 'bad-grammar'
+  | 'language-not-supported'
+  | 'network'
+  | 'no-speech'
+  | 'not-allowed'
+  | 'service-not-allowed'
+  | 'busy'
+  | 'client'
+  | 'speech-timeout'
+  | 'unknown';
+
+const MAX_COMPOSER_LENGTH = 20_000;
+
+export function appendSpeechTranscript(draft: string, transcript: string) {
+  const spoken = transcript.trim();
+  if (!spoken) return draft;
+  if (!draft) return spoken.slice(0, MAX_COMPOSER_LENGTH);
+  if (/\s$/.test(draft)) return `${draft}${spoken}`.slice(0, MAX_COMPOSER_LENGTH);
+  return `${draft} ${spoken}`.slice(0, MAX_COMPOSER_LENGTH);
+}
+
+export function mergeSpeechSegment(committed: string, segment: string) {
+  const spoken = segment.trim();
+  if (!spoken) return committed.trim();
+  const previous = committed.trim();
+  if (!previous) return spoken;
+  if (spoken.startsWith(previous)) return spoken;
+  return `${previous} ${spoken}`;
+}
+
+export function speechRecognitionErrorMessage(error: SpeechRecognitionError) {
+  if (error === 'aborted') return '';
+  if (error === 'not-allowed') {
+    return 'Microphone and speech recognition access are required. Enable them in device settings.';
+  }
+  if (error === 'no-speech' || error === 'speech-timeout') {
+    return "I didn't hear any speech. Tap the mic and try again.";
+  }
+  if (error === 'audio-capture') return "Brio couldn't access the microphone.";
+  if (error === 'network') return 'Speech recognition could not reach the system transcription service.';
+  if (error === 'language-not-supported') return 'Speech recognition is not available for this device language.';
+  if (error === 'service-not-allowed') return 'Speech recognition is not available on this device.';
+  if (error === 'busy') return 'Speech recognition is busy. Wait a moment and try again.';
+  if (error === 'interrupted') return 'Dictation was interrupted.';
+  return 'Could not transcribe that audio. Tap the mic and try again.';
+}
+
+export function normalizeSpeechRecognitionLocale(locale: string) {
+  const normalized = locale.trim().replaceAll('_', '-');
+  if (!normalized) return 'en-US';
+  try {
+    return new Intl.Locale(normalized).baseName;
+  } catch {
+    return normalized.split('-u-')[0] || 'en-US';
+  }
+}