Fix review findings in voice rounds, dictation and the timer store

- Words heard after a Sparring Reset no longer start the reset turn's
  clock: dictated words append to the draft without the start path.
- One capture uses iOS's recognizer at a time; starting another cancels
  the first, so two screens never end or hear each other's sessions.
- An opponent clip that never reports its end gives up after its length
  plus slack, so the device voice reads the rest; clips fetched for a
  reply that stopped are deleted.
- Sending a spoken turn with nothing heard returns quietly.
- Generate's dictation keeps words that arrive between renders.
- A custom format saved before the stored list loads no longer replaces it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Programcode

apps/mobile/src/app/generate.tsx

@@ -64,9 +64,14 @@ export default function GenerateScreen() {
   const abort = useRef<AbortController | null>(null);
   const live = useRef(true);
   const liveRun = useLiveRun();
-  // Dictation fills the motion, as the website's microphone beside it does.
+  // Dictation fills the motion, as the website's microphone beside it does. The
+  // ref holds words that arrived before the last ones were drawn.
+  const motionRef = useRef(form.motion);
+  motionRef.current = form.motion;
   const dictation = useSpeechCapture(language, (text) => {
-    setForm({ motion: appendDictation(lastForm.get().motion, text, MAX_MOTION_LENGTH) });
+    const motion = appendDictation(motionRef.current, text, MAX_MOTION_LENGTH);
+    motionRef.current = motion;
+    setForm({ motion });
     setMotionError(false);
   });
 

apps/mobile/src/app/sparring/index.tsx

@@ -342,6 +342,8 @@ export default function SparringScreen() {
     else void capture.stop();
     const latest = sessionRef.current;
     if (!latest || latest.id !== before.id || latest.currentTurnIndex !== before.currentTurnIndex) return;
+    // Send pressed while listening, and nothing was heard: there is no speech to send yet.
+    if (!latest.draft.trim()) return;
     const delivery = voiceActiveRef.current ? measureDelivery(capture.getTake(), outputLanguage) : null;
     const next = submitSparringSpeech(latest, latest.draft, { now: Date.now(), createId: newSparringId, delivery });
     if (!next) {
@@ -399,8 +401,14 @@ export default function SparringScreen() {
     });
   };
 
-  // Recognised words join the draft, so the student can see and fix them.
-  const capture = useSpeechCapture(outputLanguage, (text) => updateDraft(appendDictation(sessionRef.current?.draft ?? '', text, MAX_SPARRING_SPEECH_CHARS)));
+  // Recognised words join the draft, so the student can see and fix them. They
+  // never start the clock: speaking starts it (onStart), and the last words
+  // after a Reset must not set the reset turn running again.
+  const capture = useSpeechCapture(outputLanguage, (text) => move((round, now) => ({
+    ...round,
+    draft: appendDictation(round.draft, text, MAX_SPARRING_SPEECH_CHARS),
+    updatedAt: now,
+  })));
   // Each turn of each round is measured on its own, and a start still waiting for permission does not carry over.
   const turnKey = session ? `${session.id}:${currentSparringTurn(session)?.id ?? ''}` : '';
   const cancelCapture = capture.cancel;

apps/mobile/src/lib/opponent-voice.ts

@@ -71,6 +71,17 @@ async function requestSegmentAudio(feature: VoiceFeature, segment: VoiceSegment,
 }
 
 let clipNumber = 0;
+/** How long a clip may play past its length, or at all when its length never loads, before the device voice goes on. */
+const CLIP_SLACK_MS = 5_000;
+const CLIP_WITHOUT_LENGTH_MS = 20_000;
+
+function deleteClip(clip: File | null) {
+  try {
+    clip?.delete();
+  } catch {
+    // Already gone; iOS clears the cache anyway.
+  }
+}
 
 class OpponentVoice {
   private state: OpponentVoiceState = { status: 'idle', engine: null, notice: null };
@@ -157,14 +168,23 @@ class OpponentVoice {
     if (segments.length > 0 && !this.providerOff) {
       this.setState({ status: 'loading', engine: 'elevenlabs', notice: null });
       // Fetch one segment ahead so speech does not stall between segments.
-      let pending = this.load(utterance.feature, segments[0], signal);
-      for (; next < segments.length; next += 1) {
-        const clip = await pending;
-        if (run !== this.run) return;
-        if (!clip) break;
-        pending = next + 1 < segments.length ? this.load(utterance.feature, segments[next + 1], signal) : Promise.resolve(null);
-        const played = await this.playClip(clip, run);
-        if (!played) return;
+      let pending: Promise<File | null> = this.load(utterance.feature, segments[0], signal);
+      try {
+        for (; next < segments.length; next += 1) {
+          const clip = await pending;
+          pending = Promise.resolve(null);
+          if (run !== this.run) {
+            deleteClip(clip);
+            return;
+          }
+          if (!clip) break;
+          pending = next + 1 < segments.length ? this.load(utterance.feature, segments[next + 1], signal) : Promise.resolve(null);
+          const played = await this.playClip(clip, run);
+          if (!played) return;
+        }
+      } finally {
+        // A segment fetched ahead for a reply that stopped is not played; its file goes too.
+        void pending.then(deleteClip);
       }
     }
     if (run !== this.run) return;
@@ -204,15 +224,19 @@ class OpponentVoice {
       this.setState({ status: 'speaking', engine: 'elevenlabs' });
       const player = createAudioPlayer(clip.uri);
       this.player = player;
+      const startedAt = Date.now();
       await new Promise<void>((resolve) => {
         const subscription = player.addListener('playbackStatusUpdate', (status) => {
           if (!status.didJustFinish) return;
           subscription.remove();
           resolve();
         });
-        // Stopping releases the player; the run check below ends the wait.
         const check = setInterval(() => {
-          if (run === this.run && this.player === player) return;
+          // Stopping releases the player. A clip that never reports its end (it
+          // failed to load, or a call interrupted it) gives up after its length
+          // and some slack, so the rest of the reply still gets read.
+          const limit = (player.duration > 0 ? player.duration * 1_000 : CLIP_WITHOUT_LENGTH_MS) + CLIP_SLACK_MS;
+          if (run === this.run && this.player === player && Date.now() - startedAt < limit) return;
           clearInterval(check);
           subscription.remove();
           resolve();
@@ -222,11 +246,7 @@ class OpponentVoice {
       if (this.player === player) this.releasePlayer();
       return run === this.run;
     } finally {
-      try {
-        clip.delete();
-      } catch {
-        // The cache is cleared by iOS anyway.
-      }
+      deleteClip(clip);
     }
   }
 

apps/mobile/src/lib/speech-capture.test.ts

@@ -103,4 +103,20 @@ describe('speech capture', () => {
     expect(await starting).toBe(false);
     expect(fake.starts).toBe(0);
   });
+
+  it('lets one capture use the recognizer at a time: starting another cancels the first', async () => {
+    const fake = fakeRecognizer();
+    const heard: string[] = [];
+    const first = new SpeechCapture(fake.recognizer, { lang: 'en-US', onFinalText: (text) => heard.push(`first: ${text}`) });
+    const second = new SpeechCapture(fake.recognizer, { lang: 'en-US', onFinalText: (text) => heard.push(`second: ${text}`) });
+    await first.start();
+    await second.start();
+    expect(first.getState().listening).toBe(false);
+    // The first no longer hears the shared recognizer, nor restarts when the second's session ends.
+    fake.heard('only for the second');
+    fake.emit('end');
+    expect(heard).toEqual(['second: only for the second']);
+    expect(fake.starts).toBe(3);
+    await second.stop();
+  });
 });

apps/mobile/src/lib/speech-capture.ts

@@ -34,6 +34,11 @@ export interface CaptureOptions {
 
 const emptyTake = (): SpeechTake => ({ text: '', speakingMs: 0, pausesMs: [] });
 
+// iOS has one recognizer for the app, and every capture listens to its events.
+// Only one capture may use it at a time: starting one cancels any other, so a
+// screen left listening under another never hears, or ends, the new one's session.
+const owner: { current: SpeechCapture | null } = { current: null };
+
 export class SpeechCapture {
   private state: CaptureState = { listening: false, interim: '', error: null };
   private listeners = new Set<() => void>();
@@ -84,6 +89,7 @@ export class SpeechCapture {
   private detach() {
     this.subscriptions.forEach((subscription) => subscription.remove());
     this.subscriptions = [];
+    if (owner.current === this) owner.current = null;
   }
 
   private finishListening() {
@@ -124,7 +130,9 @@ export class SpeechCapture {
   }
 
   start = async (): Promise<boolean> => {
-    if (this.want) return false;
+    if (this.want || this.state.listening) return false;
+    if (owner.current && owner.current !== this) owner.current.cancel();
+    owner.current = this;
     this.set({ error: null });
     this.want = true;
     const attempt = ++this.attempt;

apps/mobile/src/lib/timer-store.ts

@@ -18,6 +18,8 @@ interface TimerStoreState {
 }
 
 let state: TimerStoreState = { loaded: false, session: initialSession(), saved: [] };
+// What changed before the stored copy was read; that change wins over the copy.
+const changedBeforeLoad = { session: false, saved: false };
 const listeners = new Set<() => void>();
 let loading: Promise<void> | null = null;
 
@@ -43,12 +45,15 @@ async function readJson(key: string): Promise<unknown> {
 export function loadTimer(): Promise<void> {
   loading ??= (async () => {
     const [session, saved] = await Promise.all([readJson(SESSION_KEY), readJson(FORMATS_KEY)]);
-    // A change made before the read finished (a tap on a fresh screen) wins over the stored round.
+    // A change made before the read finished (a tap on a fresh screen) wins over the stored copy.
+    // Saved formats are merged, so one saved early does not drop the others.
+    const stored = parseSavedFormats(saved);
     state = {
       loaded: true,
-      session: state.loaded ? state.session : parseSession(session) ?? state.session,
-      saved: state.loaded ? state.saved : parseSavedFormats(saved),
+      session: changedBeforeLoad.session ? state.session : parseSession(session) ?? state.session,
+      saved: changedBeforeLoad.saved ? state.saved.reduce((list, entry) => upsertSavedFormat(list, entry), stored) : stored,
     };
+    if (changedBeforeLoad.saved) persist(FORMATS_KEY, state.saved);
     emit();
   })();
   return loading;
@@ -61,18 +66,21 @@ export function getTimer(): TimerStoreState {
 export function updateSession(change: (current: TimerSession) => TimerSession) {
   const next = change(state.session);
   if (next === state.session) return;
-  state = { ...state, loaded: true, session: next };
+  if (!state.loaded) changedBeforeLoad.session = true;
+  state = { ...state, session: next };
   persist(SESSION_KEY, serializeSession(next));
   emit();
 }
 
 export function saveFormat(entry: SavedFormat) {
+  if (!state.loaded) changedBeforeLoad.saved = true;
   state = { ...state, saved: upsertSavedFormat(state.saved, entry) };
   persist(FORMATS_KEY, state.saved);
   emit();
 }
 
 export function deleteSavedFormat(id: string) {
+  if (!state.loaded) changedBeforeLoad.saved = true;
   state = { ...state, saved: state.saved.filter((item) => item.id !== id) };
   persist(FORMATS_KEY, state.saved);
   emit();