@@ -26,7 +26,7 @@ import { confirmDestructive, promptText } from '@/lib/confirm';
 import { useDebates } from '@/lib/debate-context';
 import { haptics } from '@/lib/haptics';
 import { LIBRARY_ROOMY_WIDTH, LIST_WIDTH, useContentWidth, useLayoutClass } from '@/lib/layout';
-import { currentSourceId, waitingSourceIds, withQueuedWrites } from '@/lib/offline-queue';
+import { currentSourceId, discardQueuedForDebate, waitingSourceIds, withQueuedWrites } from '@/lib/offline-queue';
 import { openRowId } from '@/lib/open-pane';
 import { pickSourceFile } from '@/lib/pick-source-file';
 import { useSourceActions } from '@/lib/source-actions';
@@ -103,6 +103,8 @@ function LibraryView({ debateId, layout }: { debateId: string | null; layout: Re
     const confirmed = await confirmDestructive({ title: t('libraryPage.clearAll'), message: t('libraryPage.clearConfirm'), confirm: t('libraryPage.clearAll'), cancel: t('common.cancel') });
     if (!confirmed) return;
     try {
+      // Notes and changes still waiting to sync would come back after the clear; they go first.
+      await discardQueuedForDebate(userId, debateId);
       await clearLibrary(userId, debateId);
       setSelected(null);
       library.setSources([]);
 
@@ -152,6 +152,24 @@ describe('offline queue', () => {
     expect(queue.getQueueSnapshot().items).toEqual([]);
   });
 
+  it('clears every write queued for a debate before Clear all, so none comes back', async () => {
+    const queue = await load();
+    copies.set('sources:d1', [row('s1', { title: 'Kept', content: 'Text', debateId: 'd1' })]);
+    net.offline = true;
+    const note = queue.queueAddSource('user-a', { title: 'Waiting note', content: 'Text', type: 'text', debateId: 'd1' });
+    await note;
+    await queue.queueUpdateSource('user-a', 'd2', 's9', { title: 'Other debate' });
+    await queue.discardQueuedForDebate('user-a', 'd1');
+    await cache.copiesWritten();
+    expect(queue.getQueueSnapshot().items.map((item) => item.kind === 'add' ? item.input.debateId : item.debateId)).toEqual(['d2']);
+    expect((copies.get('sources:d1') as Source[]).map((item) => item.id)).toEqual(['s1']);
+
+    net.offline = false;
+    await queue.replayOfflineQueue();
+    expect(sources.addSource).not.toHaveBeenCalled();
+    expect(sent()).toEqual(['edit s9 {"title":"Other debate"}']);
+  });
+
   it('puts back what the copies showed before a refused change, even when the server cannot be read again', async () => {
     const queue = await load();
     copies.set('sources:d1', [row('s1', { title: 'Old', content: 'Text', debateId: 'd1' })]);
@@ -244,6 +262,8 @@ describe('offline queue', () => {
     await cache.copiesWritten();
     expect((copies.get('sources:d1') as Source[]).map((item) => item.id)).toEqual(['uuid-1']);
     expect((copies.get('source:uuid-1') as Source).title).toBe('Final');
+    // updateSource drops the saved list, so the list is read back from the server.
+    expect(sources.fetchSources).toHaveBeenCalledWith('user-a', 'd1');
   });
 
   it('sends a change made while its note is on the way with the row id', async () => {
 
@@ -486,6 +486,27 @@ export async function queueSetSourcesActive(userId: string, debateId: string, so
   });
 }
 
+/**
+ * Clear all for a debate: lets a replay that is running finish, then drops every write still
+ * queued for that debate (its waiting notes, edits and switches), so none comes back after the
+ * server clears the Library. Call it before clearLibrary.
+ */
+export async function discardQueuedForDebate(userId: string, debateId: string): Promise<void> {
+  await adopt(userId);
+  if (running) await running.catch(() => undefined);
+  if (owner !== userId) return;
+  const debateOf = (item: QueuedWrite) => (item.kind === 'add' ? item.input.debateId : item.debateId);
+  const dropped = items.filter((item) => debateOf(item) === debateId);
+  if (dropped.length === 0) return;
+  items = items.filter((item) => debateOf(item) !== debateId);
+  const forgotten = new Set(dropped.flatMap((item) => touched(item).map((one) => one.id)));
+  before = Object.fromEntries(Object.entries(before).filter(([id]) => !forgotten.has(id)));
+  updateCopy<Source[]>(userId, 'sources', debateId, (list) => list?.filter((source) => !isLocalSourceId(source.id)));
+  dropped.forEach((item) => takeWaiters(item.key).forEach((waiter) => waiter.reject(new Error('The Library was cleared before this change was saved.'))));
+  persist();
+  emit();
+}
+
 /**
  * Removes a note that has not reached the server, as deleting it does. False
  * while the note is on its way: the caller asks again once it has synced.
@@ -576,8 +597,11 @@ async function send(userId: string, item: QueuedWrite): Promise<Source | undefin
     }
     // This path skips addSource's refresh of the saved copies, which still hold the note under its
     // temporary id: they take the row, once, so the note opens and edits offline after a restart.
+    // A patch above drops the saved list (updateSource), so the list is also read back from the
+    // server, which just answered; if that read fails, the swap keeps whatever list was saved.
     updateCopy<Source[]>(userId, 'sources', input.debateId, (list) => list && [saved, ...list.filter((source) => source.id !== item.tempId && source.id !== id)]);
     updateCopy<Source | null>(userId, 'source', id, () => saved);
+    await fetchSources(userId, input.debateId).catch(() => undefined);
     notifySourcesChanged();
     return saved;
   }
 
@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+
+import { mergeRegeneratedSection } from './generate-output';
+import type { GenerateOutput } from './schemas/generate';
+
+const metadata = { side: 'pro' as const, format: 'custom', generatedAt: '2026-10-28T10:00:00.000Z' };
+
+describe('mergeRegeneratedSection', () => {
+  it('keeps an R2 case body when regenerating an older case whose body was in its arguments', () => {
+    // A pre-v2 R2 case: its body was three ordinary arguments.
+    const older: GenerateOutput = {
+      caseStructure: { thesis: 'Back up our case' },
+      contentions: [{ id: '1', claim: 'Air', reasoning: 'r', evidence: 'e', needsSource: false, impact: 'i' }],
+      counters: [],
+      metadata,
+    };
+    // A new R2 run answers with the backed-up arguments and no new ones.
+    const fresh: GenerateOutput = {
+      caseStructure: { thesis: 'Back up our case' },
+      contentions: [],
+      reinforce: [{ argument: 'Our first argument: clean air', text: 'Roadside NO2 fell within a year.' }],
+      counters: [],
+      metadata,
+    };
+    const merged = mergeRegeneratedSection(older, fresh, 'contentions');
+    expect(merged.contentions).toEqual([]);
+    expect(merged.reinforce).toEqual(fresh.reinforce);
+  });
+});
@@ -134,7 +134,15 @@ export function mergeRegeneratedSection(base: GenerateOutput, next: GenerateOutp
     ...base,
     // A new opening replaces an older case's exordio and its framework, burden and definitions.
     ...(section === 'opening' ? { opening: next.opening, exordio: next.exordio, caseStructure: next.caseStructure } : {}),
-    ...(section === 'contentions' ? { contentions: next.contentions } : {}),
+    // An older R2 or Conclusor case kept its body in contentions; a new run answers with reinforce or
+    // whyWeWin and no arguments, so those come across too rather than the section going empty.
+    ...(section === 'contentions'
+      ? {
+          contentions: next.contentions,
+          ...(next.contentions.length === 0 && next.reinforce?.length ? { reinforce: next.reinforce } : {}),
+          ...(next.contentions.length === 0 && next.whyWeWin?.length ? { whyWeWin: next.whyWeWin } : {}),
+        }
+      : {}),
     ...(section === 'counters' ? { counters: next.counters, predictedOpponentCase: next.predictedOpponentCase } : {}),
     ...(section === 'reinforce' ? { reinforce: next.reinforce } : {}),
     ...(section === 'whyWeWin' ? { whyWeWin: next.whyWeWin } : {}),