@@ -35,7 +35,7 @@ The iOS app DebateOwl (`@debatelab/mobile`; bundle id `com.pistack.debateowl`, E
 - A case's and an attack's next steps are `result-links.ts`: "Open in Crossfire" fills the next Crossfire form through the one-shot `crossfirePrefill` slot (the website's route state; the builders are `packages/core/src/crossfire/prefill.ts`), and a case is built into an unsaved map with `flowchartFromCase` (`packages/core/src/flowchart.ts`, shared with the website), only in the debate the Flowchart is on, as on the website.
 - Limits mirror the website's subscription dialogs: `refusal.ts` turns a 402 or 403 refusal (with the limit details `errorFrom` keeps) into the `limit` sheet's parameters and holds the website's messages (`limit-message.ts`); the tools open the sheet instead of an inline error, and Ask, Crossfire and Sparring open it beside theirs. Where the website offers Pro, the sheet's next step is `plans.tsx` in a build with StoreKit, else the plan in You. `usage.ts` reads today's uses for the line under each tool's title (`DailyUsageLine`, the website's DailyUsage) and reads again after every AI request (`onAIRequestSettled`). `session-quota.ts` asks what a Crossfire or Sparring round costs (`quotaCheck`), shows it above Start (`SessionCostNote`) and opens the sheet before a round the day cannot cover.
 - Timer mirrors the website's free round timer (`src/components/free-tools/DebateTimer.tsx`), not the in-app TimerPage: the seven formats with their speeches, points-of-information windows, prep banks, overtime and grace come from `packages/core/src/free-tools/` (moved there from `src/lib/free-tools/`, which re-exports them; the custom format's URL codec stays in the website). `timer.ts` holds the session (format choice, round, mute), its stored form and the Live Activity's times (`timer.test.ts`); `timer-store.ts` keeps it and the custom formats saved on the device in AsyncStorage, so a running speech survives closing the timer and restarting the app. `components/timer-runner.tsx`, in the root layout, sounds the cues (a knock when POIs open or close, a beep at one minute left, two at time; after a gap in the background only time up) and stops an exhausted prep bank, with signals mounted only while a clock runs, and keeps the Live Activity in step. `timer-signals.ts` plays the bundled sounds in `assets/sounds` (made by `scripts/render-timer-sounds.ts`) with expo-audio, taps with expo-haptics and keeps the screen awake while the timer screen shows a running clock; `timer-signals.web.ts` only records the signals for the screenshot script.
-- The Lock Screen timer: `src/widgets/timer-widgets.tsx` holds the Live Activity (`DebateTimerActivity`: Lock Screen banner and Dynamic Island) and the lock-screen widget (`DebateTimerWidget`, the `widgets[]` entry in `app.config.ts`), drawn by iOS from SwiftUI timer texts so they count without the app. Their functions run in the extension's own runtime ('widget' directive): no imports or outside names, every string in the props. `live-activity.ts` loads them only when `nativeCapabilities().liveActivity` (a development build with `DEBATELAB_APP_GROUP`), takes over or ends an activity left by an earlier launch, and ends the activity when no clock has time on it; `live-activity.web.ts` records the state for the screenshot script. Round 4's Home Screen widget adds its own entry to the same `widgets[]` array. From iOS 17 the activity has Pause or Resume and Next speech buttons with fixed targets (`timer-toggle`, `timer-next`): iOS runs them in the app's process, `live-activity.ts` hears them through `addUserInteractionListener` and applies `applyTimerActivityAction` (`timer.ts`) to the stored round, and `TimerRunner` sends the new clock back. `timer-alerts.ts` sets a local, time-sensitive notification for the moment the running clock runs out (`timerAlertAt`) whenever the app is off screen, because the app's own signals stop when iOS suspends it; it asks for permission the first time a clock starts.
+- The Lock Screen timer: `src/widgets/timer-widgets.tsx` holds the Live Activity (`DebateTimerActivity`: Lock Screen banner and Dynamic Island) and the lock-screen widget (`DebateTimerWidget`, the `widgets[]` entry in `app.config.ts`), drawn by iOS from SwiftUI timer texts so they count without the app. Their functions run in the extension's own runtime ('widget' directive): no imports or outside names, every string in the props. `live-activity.ts` loads them only when `nativeCapabilities().liveActivity` (a development build with `DEBATELAB_APP_GROUP`), takes over or ends an activity left by an earlier launch, and ends the activity when no clock has time on it; `live-activity.web.ts` records the state for the screenshot script. Round 4's Home Screen widget adds its own entry to the same `widgets[]` array. From iOS 17 the activity has Pause or Resume and Next speech buttons with fixed targets (`timer-toggle`, `timer-next`): iOS runs them in the app's process, `live-activity.ts` hears them through `addUserInteractionListener` and applies `applyTimerActivityAction` (`timer.ts`) to the stored round, and `TimerRunner` sends the new clock back. A prep bank paused while it ran stays on the Lock Screen as the session's `held` bank, so Resume restarts it; `settleHeld` keeps `held` in step on every change (`updateSession`), from either screen's buttons. `timer-alerts.ts` sets a local, time-sensitive notification for the moment the running clock runs out (`timerAlertAt`) whenever the app is off screen, because the app's own signals stop when iOS suspends it; it asks for permission the first time a clock starts.
 - The generating Live Activity (`widgets/generating-activity.tsx`, `generating-activity.ts`, the words in `generating-activity-state.ts`): `useLiveRun({ tool, parts })` in Generate, Attack, Brainstorm and Factoids starts it with the run's motion, updates the step and the parts written, `complete()` marks it ready and `end('failed')` failed. Ollie's poses are copied into the App Group folder by `widget-images.ts`, which the Current Debate widget uses too. When the app leaves the screen the activity is given a stale date 30 seconds later, and the layout then says to open DebateOwl, because the stream stops while iOS suspends the app; the answer comes back from `ai_run_results` when it opens. A finished or failed run stays on the Lock Screen for 15 minutes when the app is away. Every live run also sends `notifyWhenReady` with this install's id (`setReadyPushInstall`, set at launch), so the `ai` function pushes `result_ready` to this phone once the answer is stored; `push.ts` hides that push while the app is on screen.
 - Crossfire is the website's typed mode: `crossfire.ts` sends `crossfire` and its signal requests as `src/lib/ai/client.ts` does (Ask's model settings, 75 s and 5 s deadlines), with the round's id as `quotaSession` on turns and the debrief so the round is charged once, as the website does and saves a finished round to `crossfires` in its debate, as CrossfirePage's `recordResult` call; the reducer and schemas are `packages/core/src/crossfire`. The unfinished round is a session slot, so leaving the screen keeps it. A saved round opens read only from History and the Debate tab (`crossfire-round/[id].tsx`, `fetchCrossfireRound`, with an offline copy): debrief, spoken delivery and transcript. The website lists saved rounds but cannot open them.
 - Sparring is the website's typed mode: `sparring.ts` sends the opponent's turns and the judge as `generateSparringTurn` and `judgeSparringSession` in `src/lib/ai/client.ts` do (the Sparring model settings, a transcript-only debate context), and the round's moves (turn order, the deadline clock, judging, saved rows) are `packages/core/src/sparring/session.ts`, shared with the website's sparring store. The server saves the judged round to `sparring_sessions` when it scores it; the app then files it in its debate with `attach_to_debate` and the student's side, as the store does. The side is asked when the round starts. The unfinished round is a session slot (`sparringDraft`), so leaving the screen keeps it, and a request cut off by leaving is offered again. The flow button opens the Flowchart on the Current Debate's map, above the round, which keeps running. Practice lists the Current Debate's judged rounds and the Debate tab lists them by side; both open `sparring/[id]`, which can delete them and exports the website's Sparring PDF (`sparringExportHtml`; Word export is not in the app).
 
@@ -167,6 +167,19 @@ describe('delivering unfinished transactions', () => {
     expect(env.posts).toHaveLength(2);
   });
 
+  it('sends and finishes a new unfinished version of a transaction it already delivered', async () => {
+    const bought = transaction(USER_A);
+    store.unfinishedList.push(bought);
+    env.respond = () => Promise.resolve(APPLIED);
+    await expect(deliverPending(USER_A)).resolves.toBe(1);
+
+    // The same id, signed again (a refund or a new expiry), waiting unfinished.
+    store.unfinishedList.push({ ...bought, signedTransaction: `${bought.signedTransaction}-v2` });
+    await expect(deliverPending(USER_A)).resolves.toBe(1);
+    expect(env.posts).toHaveLength(2);
+    expect(store.unfinishedList).toHaveLength(0);
+  });
+
   it('does not send a purchase under the account that signed in while the sheet was open', async () => {
     const sheet = deferred<StorePurchaseResult>();
     let opened = false;
 
@@ -83,11 +83,11 @@ const REQUEST_BUDGET_MS = 20_000;
 // deliverPending and an update event never send the same transaction at once.
 const serial = createSerialQueue();
 
-// What the server answered for each transaction finished in this run of the
-// app, so a purchase that a queued deliverPending already sent is not sent again.
+// What the server answered for each signed transaction it took in this run of
+// the app, so a version a queued deliverPending already sent is not sent again.
+// Keyed by the signed version, not the id: StoreKit signs the same transaction
+// again when it changes (a refund, a new expiry), and that version must be sent.
 const delivered = new Map<string, PurchasedPlan | null>();
-/** The signed versions the server has taken this run, so an update that repeats one is not sent again. */
-const deliveredVersions = new Set<string>();
 
 function planOf(payload: Record<string, unknown> | null): PurchasedPlan | null {
   const plan = payload?.entitlement;
@@ -139,11 +139,11 @@ async function post(transaction: StoreTransaction, userId: string): Promise<Deli
  * and sending it again is harmless.
  */
 async function deliver(transaction: StoreTransaction, userId: string): Promise<Delivery> {
-  if (delivered.has(transaction.transactionId)) return { ok: true, plan: delivered.get(transaction.transactionId) ?? null };
+  const version = transaction.signedTransaction;
+  if (delivered.has(version)) return { ok: true, plan: delivered.get(version) ?? null };
   const result = await post(transaction, userId);
   if (!result.ok) return result;
-  delivered.set(transaction.transactionId, result.plan);
-  deliveredVersions.add(transaction.signedTransaction);
+  delivered.set(version, result.plan);
   await storeKit()
     ?.finish(transaction.transactionId)
     .catch((cause: unknown) => console.warn('Could not finish an App Store transaction:', storeKitErrorCode(cause) ?? cause));
@@ -264,7 +264,6 @@ export async function manageSubscriptions(): Promise<boolean> {
   );
 }
 
-
 /**
  * A transaction StoreKit reports as updated: sent even when this run already
  * delivered its id, because an update can be a new signed version of the same
@@ -274,14 +273,7 @@ export async function manageSubscriptions(): Promise<boolean> {
 function deliverUpdate(transaction: StoreTransaction, userId: string): Promise<void> {
   if (!belongsTo(transaction, userId)) return Promise.resolve();
   return serial(async () => {
-    if (deliveredVersions.has(transaction.signedTransaction)) return;
-    const result = await post(transaction, userId);
-    if (!result.ok) return;
-    delivered.set(transaction.transactionId, result.plan);
-    deliveredVersions.add(transaction.signedTransaction);
-    await storeKit()
-      ?.finish(transaction.transactionId)
-      .catch((cause: unknown) => console.warn('Could not finish an App Store transaction:', storeKitErrorCode(cause) ?? cause));
+    await deliver(transaction, userId);
   });
 }
 
 
@@ -1,7 +1,7 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { useSyncExternalStore } from 'react';
 
-import { initialSession, parseSavedFormats, parseSession, serializeSession, upsertSavedFormat, type SavedFormat, type TimerSession } from './timer';
+import { initialSession, parseSavedFormats, parseSession, serializeSession, settleHeld, upsertSavedFormat, type SavedFormat, type TimerSession } from './timer';
 
 // The timer's round and the custom formats saved on this device, as the
 // website keeps its round in localStorage. Not tied to an account: a timer
@@ -64,7 +64,8 @@ export function getTimer(): TimerStoreState {
 }
 
 export function updateSession(change: (current: TimerSession) => TimerSession) {
-  const next = change(state.session);
+  // Which prep bank was last paused, whichever button stopped it (timer.ts's settleHeld).
+  const next = settleHeld(state.session, change(state.session));
   if (next === state.session) return;
   if (!state.loaded) changedBeforeLoad.session = true;
   state = { ...state, session: next };
 
@@ -1,4 +1,4 @@
-import { togglePrep, toggleSpeech } from '@debatelab/core/free-tools/round-timer';
+import { settlePrep, togglePrep, toggleSpeech } from '@debatelab/core/free-tools/round-timer';
 import { describe, expect, it } from 'vitest';
 
 import {
@@ -7,6 +7,7 @@ import {
   parseSavedFormats,
   parseSession,
   serializeSession,
+  settleHeld,
   timerActivityState,
   timerAlertAt,
   type TimerSession,
@@ -71,9 +72,37 @@ describe('Live Activity buttons and the time-up alert', () => {
     const paused = applyTimerActivityAction(session, 'toggle', T0 + 20_000);
     expect(paused.round.prep.b.deadline).toBeNull();
     expect(paused.round.speech.startedAt).toBeNull();
-    // With no prep running, the same button resumes the speech where it stopped.
+    // The paused bank stays on the Lock Screen, so the same button restarts it, not the speech.
     const resumed = applyTimerActivityAction(paused, 'toggle', T0 + 30_000);
-    expect(resumed.round.speech).toEqual({ elapsedMs: 10_000, startedAt: T0 + 30_000 });
+    expect(resumed.round.prep.b.deadline).not.toBeNull();
+    expect(resumed.round.speech).toEqual({ elapsedMs: 10_000, startedAt: null });
+    // With no bank held, it resumes the speech where it stopped.
+    const speech = applyTimerActivityAction({ ...paused, held: null }, 'toggle', T0 + 30_000);
+    expect(speech.round.speech).toEqual({ elapsedMs: 10_000, startedAt: T0 + 30_000 });
+  });
+
+  it('keeps a prep bank paused from the Lock Screen on it, so Resume restarts that prep', () => {
+    let session = initialSession({ id: 'custom', custom });
+    session = { ...session, round: togglePrep(session.round, 'b', T0) };
+    const paused = applyTimerActivityAction(session, 'toggle', T0 + 30_000);
+    const shown = timerActivityState(paused, T0 + 40_000, { ...text, controls: true });
+    expect(shown).toMatchObject({ kind: 'prep', side: 'b', pausedAt: T0 + 40_000, endsAt: T0 + 40_000 + 90_000 });
+    const resumed = applyTimerActivityAction(paused, 'toggle', T0 + 50_000);
+    expect(resumed.round.prep.b.deadline).toBe(T0 + 50_000 + 90_000);
+    expect(resumed.round.speech.startedAt).toBeNull();
+  });
+
+  it('lets go of a paused bank once another clock starts, it runs out, or the format changes', () => {
+    let session = initialSession({ id: 'custom', custom });
+    session = { ...session, round: togglePrep(session.round, 'a', T0) };
+    const paused = applyTimerActivityAction(session, 'toggle', T0 + 10_000);
+    expect(paused.held).toBe('a');
+    expect(settleHeld(paused, { ...paused, round: toggleSpeech(paused.round, T0 + 20_000) }).held).toBeUndefined();
+    expect(settleHeld(paused, { ...paused, choice: { id: 'bp' }, round: initialSession({ id: 'bp' }).round }).held).toBeUndefined();
+    const emptied = { ...session, round: settlePrep(session.round, T0 + 121_000) };
+    expect(settleHeld(session, emptied).held).toBeUndefined();
+    // Stored and read back with the round.
+    expect(parseSession(JSON.parse(JSON.stringify(serializeSession(paused))))?.held).toBe('a');
   });
 
   it('moves on to a fresh, paused next speech, and not past the last one', () => {