diff --git a/.claude/skills/verify-debatelab/features/case-generation.md b/.claude/skills/verify-debatelab/features/case-generation.md
index 943db2124..3ba4b2aa5 100644
--- a/.claude/skills/verify-debatelab/features/case-generation.md
+++ b/.claude/skills/verify-debatelab/features/case-generation.md
@@ -1,6 +1,6 @@
 # Case generation
 
-A signed-in user enters a motion on Generate and receives a structured debate case: thesis, framework, contentions, the predicted opponent case, and counters. The case can be saved to the account and reopened from History, or exported as PDF or DOCX.
+A signed-in user enters a motion on Generate and receives a structured debate case: an opening (hook and "we will show N arguments" line), arguments (title, point, explanation, evidence, why it matters), an "If they say…" list, a closing line and a sources list. The role shapes it: the Introductor may add one definition line; R2 brings no new arguments, only `Backing up our case` (the team's earlier arguments) and "If they say…" with one full answer for each thing the other side is likely to say; the Conclusor has 2-3 "Why we win" points instead of new arguments. Saved cases from before still show their old sections under plain names (`How to judge this debate`, `What we have to show`, `They may also say`) when they have content.
 
 ## Sub-features
 
@@ -10,8 +10,9 @@ A signed-in user enters a motion on Generate and receives a structured debate ca
 - `gen-quota` shows the dialog `Daily AI uses used up` when the account has no quota, without calling the provider.
 - `gen-save` saves a one-off case (the motion dialog answered with `Not now, use it once`) under a title into `cases` with `debate_id: null`. It appears in History under `One-off and unsorted work`, including from a fresh browser context.
 - `gen-regenerate` regenerates one section. Only that section shows the overlay `Regenerating <section>…`; the rest of the case and the result toolbar stay on screen, and every regenerate button and the form's submit button are disabled until it finishes.
+- `gen-roles` shows the role's shape: on `/app/generate` pick the `Speaker Role` option `Introductor (4 min)` and the Opening card holds a `What we mean:` line; pick `R2 - Rebuttal/Build (6 min)` and there is no `Arguments` section, `Backing up our case` holds the team's earlier arguments, and `If they say…` holds six full answers covering their main arguments, supporting points and answers to our case (standard length); pick `Conclusor (3 min)` and `Why we win` replaces `Arguments`.
 - `gen-export` downloads a `.pdf` (starting with `%PDF`) and a `.docx` (starting with `PK`).
-- `gen-flowchart` builds a flowchart from the Current Debate's case. `/app/flowchart` opens the template; the button `Build from current case` replaces it with the thesis, one node per contention (claim and evidence), the predicted attacks, and the counters, fitted to the canvas. Node titles the app wrote (`Thesis`, `Argument 1`) follow the UI language.
+- `gen-flowchart` builds a flowchart from the Current Debate's case. `/app/flowchart` opens the template; the button `Build from current case` replaces it with the thesis, one node per argument (title, point and evidence, or a Conclusor's reasons why we win), what the other side will say, and our answers, fitted to the canvas. Node titles the app wrote (`Thesis`, `Argument 1`) follow the UI language.
 
 ## How to get to it (user POV)
 
@@ -33,7 +34,7 @@ Preconditions:
 - **Cut off.** Call `await fake.truncate("generate")`, start the debate, and generate. The first reply stops halfway with `finish_reason: "length"`; the Edge Function retries once with a larger cap, and the case appears with no error. `fake.requests()` has two `generate` entries, the second with a larger `maxTokens`. Fake mode only.
 - **Cancel.** While a generation runs, the results column shows `Writing your case…` and a `Cancel` button. Cancel stops the request and shows no error.
 - **Quota.** Update `user_settings` to set `daily_limit_override: 0` through `admin`, start the debate, then generate. The dialog shows `Daily AI uses used up`. `fake.requests()` has no `generate` entry.
-- **Regenerate a section.** After generating, click the button named `Regenerate Arguments` (the section titles are `Case structure`, `Arguments`, `Predicted opponent case`, `Prepared counters`). Hold the request with `page.route("**/functions/v1/ai", ...)` to check the in-flight state: a `status` with `Regenerating Arguments` is visible and `Regenerate Case structure` is disabled. The toast `Section regenerated` follows. A full generation shows no toast: the result appears in place (and scrolls into view on phones).
+- **Regenerate a section.** After generating, click the button named `Regenerate Arguments` (the section titles are `Opening`, `Arguments`, `If they say…` and `Closing line`; an R2 case shows `Backing up our case` instead of `Arguments`, and a Conclusor case shows `Why we win` instead of `Arguments` and `If they say…`). Hold the request with `page.route("**/functions/v1/ai", ...)` to check the in-flight state: a `status` with `Regenerating Arguments` is visible and `Regenerate Opening` is disabled. The toast `Section regenerated` follows. A full generation shows no toast: the result appears in place (and scrolls into view on phones).
 - **Flowchart.** After generating in the debate, open `/app/flowchart` and click the button named `Build from current case` (Hungarian: `Létrehozás a jelenlegi esetből`). It appears only when the case belongs to the Current Debate, or to one-off work while no debate is chosen. The contention claims are visible, and an edge is a button named `From Thesis to Argument 1`.
 - **Export.** Wait for `page.waitForEvent("download")` while clicking the button named `PDF` or `DOCX` (use `exact`). Check the suggested filename's extension and the file's magic bytes.
 
diff --git a/.claude/skills/verify-debatelab/features/live-generation.md b/.claude/skills/verify-debatelab/features/live-generation.md
index 2defe01ea..aa0d74b00 100644
--- a/.claude/skills/verify-debatelab/features/live-generation.md
+++ b/.claude/skills/verify-debatelab/features/live-generation.md
@@ -4,7 +4,7 @@ Every AI answer appears while the model writes it. Generate, Attack, Brainstorm,
 
 ## Sub-features
 
-- `live-generate`: Generate's draft shows `Case structure` and later sections before the result, then the full result and its toolbar replace it.
+- `live-generate`: Generate's draft shows `Opening` and later sections before the result, then the full result and its toolbar replace it.
 - `live-cancel`: `Cancel` on the draft stops the request; no draft, result, or error stays on the page.
 - `live-tools`: Attack, Brainstorm, Factoids, and cited Ask each ask for live generation and receive an event stream.
 - `live-practice`: Crossfire turns and debriefs and Sparring speeches and scorecards ask for live generation (checked in `recipes/practice.spec.ts` with `expectStreamed`).
@@ -20,7 +20,7 @@ Preconditions:
 
 - Doctor passes. The user is signed in. `startDebate(page, motion)` avoids the motion dialog.
 
-- **Draft.** Click `Generate debate case`. `getByTestId("live-draft")` appears, holding a region named `Case structure`, one `live-caret`, and a `Cancel` button. It disappears when the result renders.
+- **Draft.** Click `Generate debate case`. `getByTestId("live-draft")` appears, holding a region named `Opening`, one `live-caret`, and a `Cancel` button. It disappears when the result renders.
 - **Request.** The page's `ai` request body has `stream: true`. The response is `text/event-stream`: `phase` events (`research`, `writing`, `checking`), many `delta` events with the model's raw text, an optional `reset` when a repair retry starts the answer again, and exactly one final `result` event `{status, body}` holding what a plain request would return. Read it with `readAIResponse(response)`.
 - **Provider.** `expectStreamed(["generate"])`: every provider call for the feature had `stream: true`. Research sub-calls (`research-decision`, `research-queries`) are never streamed.
 - **Errors.** Checks before the feature (auth, input, quota, model access) still answer with plain JSON and their real status. A failure after streaming starts arrives as a `result` with the error status, which the client turns into the same error a plain request gets.
diff --git a/.claude/skills/verify-debatelab/recipes/case-generation.spec.ts b/.claude/skills/verify-debatelab/recipes/case-generation.spec.ts
index 181585152..5020e69c3 100644
--- a/.claude/skills/verify-debatelab/recipes/case-generation.spec.ts
+++ b/.claude/skills/verify-debatelab/recipes/case-generation.spec.ts
@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { admin, AI_TIMEOUT, aiResponse, chooseForMotion, type Evidence, expect, expectProviderCalls, fake, LIVE, signIn, startDebate, test } from "./fixtures";
+import { admin, AI_TIMEOUT, aiResponse, chooseForMotion, type Evidence, expect, expectProviderCalls, fake, LIVE, providerCalls, signIn, startDebate, test } from "./fixtures";
 
 // Feature map: features/case-generation.md.
 const motion = "This House would make public transport free at the point of use";
@@ -149,6 +149,73 @@ test("gen-flowchart: the Flowchart builds from the Current Debate's case, and it
   await evidence.shot("02-built-from-case-hu");
 });
 
+test("gen-roles: the speaker role shapes the case: Introductor, R2 and Conclusor", async ({ signedIn: page, evidence }) => {
+  await openGenerate(page);
+  const pickRole = async (name: string) => {
+    await page.getByRole("combobox", { name: "Speaker Role" }).click();
+    await page.getByRole("option", { name }).click();
+  };
+  const run = async (role: string) => {
+    const response = aiResponse(page, "generate");
+    await page.getByRole("button", { name: "Generate debate case" }).click();
+    const body = await response;
+    const call = (await providerCalls()).filter((item) => item.feature === "generate").at(-1);
+    expect(call?.user).toContain(`Role: ${role}`);
+    return body.output as unknown as CaseOutput & {
+      opening?: { definition?: string };
+      counters: unknown[];
+      reinforce?: Array<{ argument: string; text: string }>;
+      whyWeWin?: string[];
+      closingLine?: string;
+    };
+  };
+
+  await pickRole("Introductor (4 min)");
+  const intro = await run("intro");
+  await expect(page.getByText(intro.caseStructure.thesis).first()).toBeVisible();
+  await expect(page.getByRole("button", { name: "Regenerate Opening" })).toBeVisible();
+  if (intro.opening?.definition) await expect(page.getByText("What we mean:")).toBeVisible();
+  if (!LIVE) expect(intro.opening?.definition).toBeTruthy();
+  await evidence.shot("01-introductor");
+  await evidence.aria("01-introductor");
+
+  await pickRole("R2 - Rebuttal/Build (6 min)");
+  const r2 = await run("r2");
+  await expect(page.getByText(r2.caseStructure.thesis).first()).toBeVisible();
+  // Only the Introductor defines a term.
+  expect(r2.opening?.definition).toBeFalsy();
+  await expect(page.getByText("What we mean:")).toHaveCount(0);
+  // R2 brings no new arguments: it backs up the team's, then answers theirs.
+  expect(r2.contentions).toEqual([]);
+  expect(r2.reinforce?.length ?? 0).toBeGreaterThanOrEqual(1);
+  await expect(page.getByRole("button", { name: "Regenerate Arguments" })).toHaveCount(0);
+  await expect(page.getByRole("button", { name: "Regenerate Backing up our case" })).toBeVisible();
+  for (const item of r2.reinforce ?? []) await expect(page.getByText(item.text).first()).toBeVisible();
+  await expect(page.getByRole("button", { name: "Regenerate If they say…" })).toBeVisible();
+  await expect(page.getByText("They say", { exact: true })).toHaveCount(r2.counters.length);
+  // One full answer for each thing they are likely to say: standard length
+  // asks for six, and the Edge Function keeps a live reply with at least four.
+  if (LIVE) {
+    expect(r2.counters.length).toBeGreaterThanOrEqual(4);
+    expect(r2.counters.length).toBeLessThanOrEqual(6);
+  } else {
+    expect(r2.counters).toHaveLength(6);
+  }
+  await evidence.shot("02-r2");
+  await evidence.aria("02-r2");
+
+  await pickRole("Conclusor (3 min)");
+  const conc = await run("conc");
+  expect(conc.contentions).toEqual([]);
+  expect(conc.whyWeWin?.length ?? 0).toBeGreaterThanOrEqual(2);
+  await expect(page.getByRole("button", { name: "Regenerate Why we win" })).toBeVisible();
+  await expect(page.getByRole("button", { name: "Regenerate Arguments" })).toHaveCount(0);
+  for (const reason of conc.whyWeWin ?? []) await expect(page.getByText(reason).first()).toBeVisible();
+  if (conc.closingLine) await expect(page.getByText(conc.closingLine).first()).toBeVisible();
+  await evidence.shot("03-conclusor");
+  await evidence.aria("03-conclusor");
+});
+
 test("gen-research: generation researches the web and cites what it found", async ({ signedIn: page, evidence }) => {
   const { body } = await generate(page);
   await evidence.json("01-generate-response", body);
@@ -161,8 +228,10 @@ test("gen-research: generation researches the web and cites what it found", asyn
   }
   expect(sources.length, "web sources found by research").toBeGreaterThan(0);
   expect(sources.every((source) => /^https?:\/\//.test(source.url))).toBe(true);
-  const panel = page.getByText("Researched sources").locator("..");
+  // The sources fold under the result header; open them as a student would.
+  const panel = page.getByRole("group").filter({ hasText: /^Researched sources/ });
   await expect(panel).toBeVisible();
+  await panel.getByText(/^Researched sources/).click();
   await expect(panel.getByRole("link").first()).toHaveAttribute("href", /^https?:\/\//);
   await evidence.shot("03-researched-sources");
 });
@@ -202,7 +271,7 @@ test("gen-regenerate: regenerating one section keeps the rest of the case and it
   await expect(overlay).toBeVisible();
   await expect(page.getByText(thesis).first()).toBeVisible();
   await expect(page.getByRole("button", { name: "PDF", exact: true })).toBeVisible();
-  await expect(page.getByRole("button", { name: "Regenerate Case structure" })).toBeDisabled();
+  await expect(page.getByRole("button", { name: "Regenerate Opening" })).toBeDisabled();
   // The form button reads "Generating..." while busy, so find it by its tour anchor.
   await expect(page.locator('[data-tour="generate-button"]')).toBeDisabled();
   await evidence.shot("02-regenerating-one-section");
@@ -214,7 +283,7 @@ test("gen-regenerate: regenerating one section keeps the rest of the case and it
   await expect(page.getByText("Section regenerated").first()).toBeVisible({ timeout: AI_TIMEOUT });
   await expect(overlay).toHaveCount(0);
   await expect(page.getByText(thesis).first()).toBeVisible();
-  await expect(page.getByRole("button", { name: "Regenerate Case structure" })).toBeEnabled();
+  await expect(page.getByRole("button", { name: "Regenerate Opening" })).toBeEnabled();
   await evidence.shot("03-regenerated");
 });
 
diff --git a/.claude/skills/verify-debatelab/recipes/live-generation.spec.ts b/.claude/skills/verify-debatelab/recipes/live-generation.spec.ts
index 214059c9b..941d84651 100644
--- a/.claude/skills/verify-debatelab/recipes/live-generation.spec.ts
+++ b/.claude/skills/verify-debatelab/recipes/live-generation.spec.ts
@@ -43,7 +43,7 @@ test("live-generate: a case fills in section by section while the model writes i
   // Before the answer is complete, the draft shows what is written so far.
   const draft = page.getByTestId("live-draft");
   await expect(draft).toBeVisible({ timeout: AI_TIMEOUT });
-  await expect(draft.getByRole("region", { name: "Case structure" })).toBeVisible();
+  await expect(draft.getByRole("region", { name: "Opening" })).toBeVisible();
   await expect(draft.getByTestId("live-caret")).toHaveCount(1);
   await expect(draft.getByRole("button", { name: "Cancel" })).toBeVisible();
   await evidence.shot("01-writing-live");
diff --git a/agentic/case-generation.e2e.ts b/agentic/case-generation.e2e.ts
index 581ddeb82..50183c37d 100644
--- a/agentic/case-generation.e2e.ts
+++ b/agentic/case-generation.e2e.ts
@@ -18,7 +18,7 @@ test("a student starts a debate and generates a case for it", { ...agentic, tags
     return data;
   }, { timeout: 15_000 }).toEqual([{ debates: { motion: MOTION } }]);
 
-  await agent.assert("The page shows a generated debate case: a thesis and several contentions, each with a claim and supporting reasoning.");
+  await agent.assert("The page shows a generated debate case: an opening and several arguments, each with a point and an explanation of why it is true.");
   if (LIVE) {
     // Recipes never assert on model wording; a judge can check that the case is on topic.
     await agent.assert(`The generated case argues about the motion "${MOTION}", not about an unrelated topic.`);
@@ -29,5 +29,5 @@ test("a student starts a debate and generates a case for it", { ...agentic, tags
   await agent.act("Open History and load the debate case you generated.");
   await expect(screen.getByRole("button", "Regenerate Arguments")).toBeVisible();
   if (!LIVE) await expect(fakeAnswer(screen)).toBeVisible();
-  await agent.assert("A debate case with a thesis and contentions is open again on screen.");
+  await agent.assert("A debate case with an opening and arguments is open again on screen.");
 });
diff --git a/apps/mobile/AGENTS.md b/apps/mobile/AGENTS.md
index 24bfe383e..66df16541 100644
--- a/apps/mobile/AGENTS.md
+++ b/apps/mobile/AGENTS.md
@@ -18,7 +18,7 @@ The iOS app DebateOwl (`@debatelab/mobile`; the bundle id is still `com.adam.deb
 
 ## Layout
 
-- `src/app/`: routes. `sign-in.tsx`; `(tabs)/` with one route group per tab: Debate, Prepare, Practice, Library, You; the form sheets `debates.tsx` (switcher), `new-debate.tsx`, `delete-account.tsx`, `delete-data.tsx`, `add-link.tsx`, `new-note.tsx`, `add-file.tsx` (Import file), `source/[id].tsx`, `edit-debate.tsx` (Edit settings), `debate-check.tsx` (the five-day check), `limit.tsx` (the website's limit-reached and model-restricted dialogs), `save-case.tsx` (Save case with a title) and `context-review.tsx` (the debate context Review); and `ask.tsx`, `generate.tsx`, `case/[id].tsx`, `attack/`, `brainstorm/`, `factoids/` and `sparring/` (each a form `index.tsx` and a document `[id].tsx`), `crossfire.tsx` and `timer.tsx` (a full-screen modal), `flowchart/` (the screen `index.tsx` with its `card`, `claim` and `maps` form sheets), and `history.tsx`, full screen above the tabs. All are declared in the root `_layout.tsx`. Every Practice tool is in the app, so `(practice)/soon/[tool].tsx` is no longer reached from the Practice tab.
+- `src/app/`: routes. `sign-in.tsx`; `(tabs)/` with one route group per tab: Debate, Prepare, Practice, Library, You; the form sheets `debates.tsx` (switcher), `new-debate.tsx`, `delete-account.tsx`, `delete-data.tsx`, `add-link.tsx`, `new-note.tsx`, `add-file.tsx` (Import file), `source/[id].tsx`, `edit-debate.tsx` (Edit settings), `debate-check.tsx` (the five-day check), `limit.tsx` (the website's limit-reached and model-restricted dialogs), `save-case.tsx` (Save case with a title), `context-review.tsx` (the debate context Review) and `welcome.tsx` (Ollie's welcome and the first-run tour); `share/[code].tsx`, the read-only viewer for a share link, outside the sign-in guard; `+native-intent.tsx`, which maps website links to app routes; and `ask.tsx`, `generate.tsx`, `case/[id].tsx`, `attack/`, `brainstorm/`, `factoids/` and `sparring/` (each a form `index.tsx` and a document `[id].tsx`), `crossfire.tsx` and `timer.tsx` (a full-screen modal), `flowchart/` (the screen `index.tsx` with its `card`, `claim` and `maps` form sheets), and `history.tsx`, full screen above the tabs. All are declared in the root `_layout.tsx`. Every Practice tool is in the app, so `(practice)/soon/[tool].tsx` is no longer reached from the Practice tab.
 - `src/components/`: shared UI. `app-tabs.tsx` uses native tabs; `app-tabs.web.tsx` draws the mock's tab bar for the web preview.
 - `src/lib/`: auth (`auth.tsx`), `native-capabilities.ts` (what the running binary has beyond Expo Go), the Supabase client, session storage (AES key in SecureStore, ciphertext in AsyncStorage) and i18n. `debates.ts`, `settings.tsx`, `subscription.ts` and `account.ts` read and write the website's tables the way its stores do (`src/lib/stores/debate-store.ts`, `settings-store.ts`, `src/hooks/use-subscription.ts`, `src/lib/account.ts`), so the app and the website share one Current Debate and one set of settings. Change them together with the website code they mirror.
 - `sources.ts` mirrors the session store's source actions (`addSource` with Undo's restore, `updateSource`, `removeSource`, `toggleSource` and `setFolderActive` as `setSourcesActive`, the folder actions and `clearLibrary`) and `src/lib/source-import.ts`. Switch changes run in one serial queue, so they reach the server in the order the student made them; a screen shows a change at once and puts it back when the write fails (`source-actions.ts`, with the website's messages). The Library always shows the Current Debate, also in one-off mode, as on the website. Its folder list, search and eight sort orders are the website's, in `packages/core/src/library.ts`. Scan pages is not in the app yet.
@@ -27,7 +27,7 @@ The iOS app DebateOwl (`@debatelab/mobile`; the bundle id is still `com.adam.deb
 - Debates: `new-debate.tsx` and `edit-debate.tsx` share `components/debate-form.tsx`, the website's DebateForm plus the judge (`settings.judge`, which the website's prompts read but its form does not show). The switcher deletes any debate but the current one (the database cascades its sources and work). `use-inactive-debate-check.ts` opens `debate-check.tsx`, the website's five-day check; closing it counts as Continue.
 - Rows of saved work and sources are `Link`s with `Link.Preview` and `Link.Menu`: a long press shows the document and its actions (`work-actions.ts`: Discuss, Share, and Delete where the website's History deletes).
 - Ask mirrors `src/lib/ai/streaming.ts` and `askChat` in `src/lib/ai/client.ts`: `ask.ts` sends the requests (plain questions stream from `ai-stream` through `expo/fetch`; with Citations, Web search, Pros/Cons or Argument map on, the whole answer comes from `ai`, because `ai-stream` refuses those options), `ai-request.ts` holds the shared POST with the website's headers, timeout and error kinds, `feature-config.ts` reads each tool's model from `user_settings.feature_configs` (the model picker, `components/model-picker.tsx`, writes it back through `settings.tsx`'s serial queue in the website's canonical shape; tools read it through the same queue, so they run with the model just picked), `context-request.ts` builds the Current Debate context from `context-plan.ts`, which reads a debate's list of material when a form opens, and the text only of the items a request sends (kept in `context-texts.ts` under each row's version: a case's generatedAt, a chat's message count, a round's updated_at; source text is read again after each list read, and `updateResult` and `saveChat` forget what they change), and plans it with the website's planner (`packages/core/src/debate/context-plan.ts`), with the Review choices for one request (Crossfire keeps them for its round) and the pins in `debate_context_pins` (three at most); the line on each tool form, Crossfire, Sparring and Ask (`components/context-line.tsx`) and its Review sheet read the same plan, and `chats.ts` saves finished exchanges to `chats` and `messages`. The SSE parser is shared in `packages/core/src/ai/sse.ts`. `markdown.ts` reads answers, because react-markdown needs the DOM.
-- Generate and Attack mirror `generateCase` and `attackCase` in `src/lib/ai/client.ts` and the session store's `recordResult`: `results.ts` sends the requests through `ai-request.ts`'s `postAI`, which streams them as the website does (`stream: true` with a `resultKey`; the reader is `packages/core/src/ai/live.ts`, shared with the website's `src/lib/ai/live.ts`) and reads a dropped stream's answer back from `ai_run_results` (`packages/core/src/ai/run-recovery.ts`). The four tool screens show the draft with `components/live-run.tsx` (the website's `LiveToolRun`; the sections come from `packages/core/src/ai/live-sections.ts`). `results.ts` also checks the output with the website's transform (moved to `packages/core/src/ai/generate-output.ts`), keeps researched sources in the debate's Auto-saved folder (`packages/core/src/ai/discovered-sources.ts`), saves the server's source rankings onto the Library sources a result used (`packages/core/src/ai/source-assessments.ts`, also for Ask's whole answers), says when the server shortened the input, and saves rows to `cases` and `attacks`. `motion.ts` and `motion-gate.ts` are the website's motion gate. `open-results.ts` holds results made in this session, so one-off work and failed saves still open as documents. It and the last Generate and Attack forms live in `session-memory.ts`, which the auth provider clears on every account change, including sign-out. `components/document.tsx` draws results as documents (mock 03); Brainstorm and Factoids reuse it. Export renders `export-html.ts` to a PDF with expo-print and shares it (`export.ts`); the web preview cannot print, so `export.web.ts` keeps the HTML and copied text on `window` for the screenshot script. Word export and Google Docs are not in the app.
+- Generate and Attack mirror `generateCase` and `attackCase` in `src/lib/ai/client.ts` and the session store's `recordResult`: `results.ts` sends the requests through `ai-request.ts`'s `postAI`, which streams them as the website does (`stream: true` with a `resultKey`; the reader is `packages/core/src/ai/live.ts`, shared with the website's `src/lib/ai/live.ts`) and reads a dropped stream's answer back from `ai_run_results` (`packages/core/src/ai/run-recovery.ts`). The four tool screens show the draft with `components/live-run.tsx` (the website's `LiveToolRun`; the sections come from `packages/core/src/ai/live-sections.ts`). `results.ts` also checks the output with the website's transform (moved to `packages/core/src/ai/generate-output.ts`), keeps researched sources in the debate's Auto-saved folder (`packages/core/src/ai/discovered-sources.ts`), saves the server's source rankings onto the Library sources a result used (`packages/core/src/ai/source-assessments.ts`, also for Ask's whole answers), says when the server shortened the input, and saves rows to `cases` and `attacks`. `motion.ts` and `motion-gate.ts` are the website's motion gate. `open-results.ts` holds results made in this session, so one-off work and failed saves still open as documents. It and the last Generate and Attack forms live in `session-memory.ts`, which the auth provider clears on every account change, including sign-out. `components/document.tsx` draws results as documents (mock 03); Brainstorm and Factoids reuse it. Export renders `export-html.ts` to a PDF with expo-print and shares it (`export.ts`); the web preview cannot print, so `export.web.ts` keeps the HTML and copied text on `window` for the screenshot script. Word export uses the website's builders, moved to `packages/core/src/export/docx.ts`: `export-docx.ts` packs them with `Packer.toBase64String` and shares the .docx (`export-docx.web.ts` keeps it on `window` for the screenshot script). Google Docs is not in the app.
 - Brainstorm and Factoids mirror `brainstorm` and `factoids` in `src/lib/ai/client.ts` and their pages, through the same `results.ts`: the brainstorm transform and the verified-factoid selection live in `packages/core/src/ai/brainstorm-output.ts` and `factoids-output.ts`, rows go to `brainstorms` and `factoids`. Brainstorm has the motion gate; Factoids, like Attack, follows the Current Debate and saves with side `neutral`. A factoid's bookmark saves it to the Current Debate's `Factoids` folder, and a search suggestion reopens the Factoids form with that query. `prepareToolHref` in `components/prepare-tools.ts` is where both tabs open a tool.
 - A case's Regenerate and Undo are `case-edits.ts`: one part is replaced from a new generation with the website's merge (`mergeRegeneratedSection` in `packages/core/src/ai/generate-output.ts`), earlier versions are kept for the session, and Undo writes the restored version back to the saved row (`updateResult`). Held results are observable (`subscribeOpenResults`), so the document shows a change made from its menu or its sheets.
 - Ask's Stop keeps the answer so far, marked as stopped. Its General and Clarify modes go in the request; Clarify and the options `ai-stream` refuses stream live from the `ai` function through `postAI`. An answer saves to the Current Debate's `Ask` folder. Attachments (`ask-attachments.ts`, expo-document-picker, in Expo Go) are read on the phone (`read-file.ts`) and sent in the website's format (`packages/core/src/ai/ask-files.ts`).
@@ -41,11 +41,15 @@ The iOS app DebateOwl (`@debatelab/mobile`; the bundle id is still `com.adam.deb
 - Announcements mirror the website's banner (`AppLayout.tsx`, `AnnouncementBanner.tsx`) at the top of the Debate tab: `announcements.ts` lists and dismisses through the `announcements` Edge Function, and `use-announcements.ts` keeps the website's startsAt/expiresAt filter (shared in `packages/core/src/announcements.ts`), its one-minute reload guard, and reloads on focus, foreground and account change. Dismissals are stored on the server, so they are shared with the website.
 - You mirrors the website's Settings for what the app can do: Download my data (`exportAccountData` in `account.ts`, the `account` function's export written as `debatelab-data-<date>.json` and shared through `shareJson`), Delete all my data (`delete-data.tsx`, the email-typed confirmation and `clear_current_user_data`; afterwards session memory is forgotten, one-off mode turns off and the debates reload, as the website clears its stores), and Terms and Privacy, opened in the in-app browser from `app.config.ts`'s `extra.websiteUrl` (`website.ts`). The plan card shows the website's billing states, dates and wording (`SubscriptionStatus.tsx`): `subscription.ts` reads `user_settings`, Stripe `subscriptions` and `app_store_subscriptions` through the shared reader (`packages/core/src/supabase/billing.ts`, via `billing-query.ts`) and resolves them with the resolver the AI functions use (`supabase/functions/_shared/billing-state.ts`); usage is the server's own counter (`ai_usage_today`). Upgrade, Manage subscription and promo codes wait for in-app purchase.
 - One-off mode is session-only and never written, as on the website; only maps saved in it are kept, with no debate, as the website keeps them. The switcher turns it on with or without a Current Debate, and `OneOffNotice` shows it on the Debate tab, Prepare, Ask, Library and the Generate, Attack, Brainstorm, Factoids, Crossfire and Sparring forms (through `WorkingIn`) and the Flowchart. The Debate tab, Prepare and Library still list the Current Debate's work in one-off mode, as the website's home does. Students prepare both sides of a motion, so a debate has no side: the Debate tab's In favor / Against toggle only chooses which side's work it shows, using the website's rule (`'both'` counts for either side, neutral and side-less work for neither). It starts on In favor and is never stored.
-- Offline reading: `offline-cache.ts` keeps a copy of every read in `debates.ts`, `sources.ts`, `results.ts`, `flowcharts.ts`, `chats.ts`, `sparring.ts` and `history.ts` (the debates list, counts and recent work, Library sources with their text, saved results, maps, chats, judged Sparring rounds and History's lists) in AsyncStorage under the user id. A read goes to the network first and saves its answer; when no answer comes back (supabase-js status 0: no connection, DNS, timeout), or `network-status.ts` (expo-network) says the device is offline, the copy answers and `OfflineNotice` shows at the top of `Screen`, `DocumentScreen` (including its iPad outline rail), the Flowchart and the iPad Library list until each copy shown is read from the server again or the screen showing it closes, moves on or leaves view (a screen passes `useCopyHolder().mark()` with its reads). A server error (an expired session, a policy, a 5xx) is thrown, never answered from a copy; a read made of several queries runs them through `readAll` (or `pickFailure`), so one query's refusal wins over another's missing answer. A slower answer never replaces a newer copy, each group keeps its most recently fetched copies only (`LIMITS`), and the auth provider calls `setCacheOwner` before it adopts a session, so another account's copies are removed before its first read. Nothing is written offline: AI and saving fail with their network errors, and there is no write queue. A read added to those modules goes through `cachedRead`, takes an optional `CopyMark`, and throws `readFailed(error, status)`. Every write that succeeds calls `afterWrite` with the copies it changed (`debateListScopes` names a debate's counts and lists; a delete uses `deletedListScopes`, which drops every debate's when no row came back), which drops them and stops older reads from saving over them, or `updateCopy` when it knows the new value. `debateListScopes` also names History's copy (`one-off` for work outside every debate); History's add-to-debate and filing a judged Sparring round into its debate both drop the item's copies on both sides, and Delete all my data drops every copy (`ALL_COPIES`).
+- Offline reading: `offline-cache.ts` keeps a copy of every read in `debates.ts`, `sources.ts`, `results.ts`, `flowcharts.ts`, `chats.ts`, `sparring.ts` and `history.ts` (the debates list, counts and recent work, Library sources with their text, saved results, maps, chats, judged Sparring rounds and History's lists) in AsyncStorage under the user id. A read goes to the network first and saves its answer; when no answer comes back (supabase-js status 0: no connection, DNS, timeout), or `network-status.ts` (expo-network) says the device is offline, the copy answers and `OfflineNotice` shows at the top of `Screen`, `DocumentScreen` (including its iPad outline rail), the Flowchart and the iPad Library list until each copy shown is read from the server again or the screen showing it closes, moves on or leaves view (a screen passes `useCopyHolder().mark()` with its reads). A server error (an expired session, a policy, a 5xx) is thrown, never answered from a copy; a read made of several queries runs them through `readAll` (or `pickFailure`), so one query's refusal wins over another's missing answer. A slower answer never replaces a newer copy, each group keeps its most recently fetched copies only (`LIMITS`), and the auth provider calls `setCacheOwner` before it adopts a session, so another account's copies are removed before its first read. AI and saving results fail offline with their network errors. New notes, source edits and Active switches go through `offline-queue.ts` instead (`use-offline-queue.ts` starts it in the root layout): kept on the phone under the user id, replayed in order on launch, reconnect, foreground and every 30 seconds while anything waits, merged per source, dropped and reported when the server refuses them, and shown as "Waiting to sync" meanwhile. A queued note has a `local:` id until it syncs. A read added to those modules goes through `cachedRead`, takes an optional `CopyMark`, and throws `readFailed(error, status)`. Every write that succeeds calls `afterWrite` with the copies it changed (`debateListScopes` names a debate's counts and lists; a delete uses `deletedListScopes`, which drops every debate's when no row came back), which drops them and stops older reads from saving over them, or `updateCopy` when it knows the new value. `debateListScopes` also names History's copy (`one-off` for work outside every debate); History's add-to-debate and filing a judged Sparring round into its debate both drop the item's copies on both sides, and Delete all my data drops every copy (`ALL_COPIES`).
 - Push: `push.ts` asks for permission and files the Expo push token under the signed-in user with the `register_push_token` RPC; the You tab's Notifications switch turns it on and off, the root layout registers again on launch and when the language changes, and sign-out releases the registration with the account's own access token, after any registration still in flight. Every registration carries the ID of the local record, and `release_push_token` withdraws that ID and deletes only the rows it wrote, so a registration the app gave up on is refused if it reaches the database after the release. Once a release is sent for an ID, the record is marked released and the next registration gets a new ID, so a late release cannot delete it. The local record is cleared only once a release succeeds; otherwise the next change on the phone, from any account, releases it first. The server side is in [supabase/README.md](../../supabase/README.md#push-notifications). `push.web.ts` registers nothing and only flips the switch for the screenshot script.
   - No build can get a token until `app.config.ts` has `extra.eas.projectId`, from `eas init` on build day (see [docs/development.md](../../docs/development.md#build-day)). Until then the switch shows as unavailable, on Expo Go too. Expo Go on Android has no remote push since SDK 53, and Expo recommends a development build for remote push on iOS as well.
   - Prebuild applies the `expo-notifications` config plugin automatically once the package is installed, even though `app.config.ts` does not list it, and the plugin sets the `aps-environment` entitlement. `DEBATELAB_BUILD=dev` removes it again (`withoutPushEntitlement`), because the borrowed Signulous profile has no push, so a development build cannot get a token even with a project ID: turning the switch on there fails. Real push needs a provisioning profile with the Push Notifications capability and an APNs key uploaded to EAS, both from Adam's own Apple Developer account; only then can `withoutPushEntitlement` go.
-- iPad layouts (iPad mock A, with mock C's docked claim) come from one hook, `useLayoutClass()` in `src/lib/layout.ts`, which also holds every width they use: `phone` on every iPhone and in iPad windows under 700 points, `regular` from 700, `wide` from 1100. Phone layouts must not change, so each screen keeps its phone JSX and branches before it; compare iPhone screenshots before and after. NativeTabs is `sidebarAdaptable` (the iPadOS 18 sidebar; `app-tabs.web.tsx` draws a sidebar or a top tab bar for the preview). The Library opens a source beside its list (`SourceView`, shared with the source sheet), Ask lists its conversations beside the chat (`ask-chat-list.tsx`), the Debate tab is a two-column dashboard, saved documents get an "On this page" rail from 900 points (`DocumentScreen`'s `outline`, `components/outline.tsx`), and the Flowchart docks a card's claim beside the map (`ClaimPanel` in `claim-panel.tsx`, shared with the claim sheet). A docked claim or a source open beside its list is dropped when that map, debate, account or row is no longer the one on screen. All are plain views sized from the window, so they run in Expo Go.
+- iPad layouts (iPad mock A, with mock C's docked claim) come from one hook, `useLayoutClass()` in `src/lib/layout.ts`, which also holds every width they use: `phone` on every iPhone and in iPad windows under 700 points, `regular` from 700, `wide` from 1100. Phone layouts must not change, so each screen keeps its phone JSX and branches before it; compare iPhone screenshots before and after. A full-screen iPad window from the regular width shows the app's own sidebar (`components/app-sidebar.tsx`, rows in `sidebar-items.ts`) beside the root stack, so it stays while a tool is open: the Current Debate switcher, then every tool under collapsible Debate, Prepare, Practice, Library and You sections (closed sections are kept on the device). NativeTabs hides its bar there (`hidden`), and `app-tabs.web.tsx` hides the preview's; Split View, Slide Over, Stage Manager windows and widths under 700 keep the tab bar (`sidebarWidthFor`). A sidebar row closes the screens above the tabs before it opens its own, so the sidebar never stacks tools. Screens lay out for the room beside the sidebar: `useLayoutClass()` and `useContentWidth()` subtract `ReservedWidth`, which sheets reset to 0; never size a screen from `useWindowDimensions()` directly. The Prepare and Practice tab pages are not in the sidebar: the Debate dashboard and History cover their lists. The Library opens a source beside its list (`SourceView`, shared with the source sheet), Ask lists its conversations beside the chat (`ask-chat-list.tsx`), the Debate tab is a two-column dashboard, saved documents get an "On this page" rail from 900 points (`DocumentScreen`'s `outline`, `components/outline.tsx`), and the Flowchart docks a card's claim beside the map (`ClaimPanel` in `claim-panel.tsx`, shared with the claim sheet). A docked claim or a source open beside its list is dropped when that map, debate, account or row is no longer the one on screen. All are plain views sized from the window, so they run in Expo Go.
+- Share links (`share-links.ts`, `use-share-link.ts`): a saved case, attack, brainstorm or factoids document's menu calls the `share` Edge Function with the session and reuses a link made this session for the same unchanged result, because every call makes a new link and counts toward the daily limit. With no browser Origin the function builds debateowl.com links, so links made against staging open production's site. `share/[code].tsx` reads a link back with the public `get_shared_item` RPC. Universal links (`deep-links.ts`, a tested parser that honours only https debateowl.com and www) need the Associated Domains entitlement, which `app.config.ts` adds to development builds, and the website's apple-app-site-association file, which is not deployed.
+- The first run (`first-run.ts`, `use-first-run.ts`, `welcome.tsx`) uses the website's keys: Ollie's welcome once per phone, the four-step tour once per account. The web preview opens it only with `?intro=show` (`first-run.web.ts`). `components/trial-banner.tsx` is the website's trial reminder (days left from `packages/core/src/trial.ts`); `auth.tsx`'s `sessionExpired` is set when the server ends a session (a refused refresh), never for a sign-out the student asked for, and the sign-in screen shows the website's notice.
+- Accessibility: every text field is `AppTextInput` (`components/app-text-input.tsx`), with the one Done bar above the keyboard (`KeyboardDoneBar` in the root layout); `Screen`, `DocumentScreen` and sheets scroll fields clear of the keyboard. Text grows with Dynamic Type; only fixed chrome sets `maxFontSizeMultiplier` (floating action-bar buttons and segmented controls 1.6, the sidebar 1.35). The web preview draws a text size from `window.__debateowlFontScale` (`theme/font-scale.web.ts`, the script's `FONT_SCALE`). `a11y.ts` announces a finished Ask answer, Crossfire reply, Sparring speech or tool result once; never make streamed text a live region. iPad shortcuts (⌘N, ⌘K, ⌘↩) go through `key-commands.ts`, which works in the web preview only until a UIKeyCommand module is in the development build; the timer's space bar belongs to the timer work.
+- The Current Debate widget (`widgets/current-debate.tsx`, published by `debate-widget.ts` from the debate context and the Debate tab) needs a development build with `DEBATELAB_APP_GROUP`. Quick actions (`quick-actions.ts`) and Spotlight (`spotlight.ts`) switch on only when `expo-quick-actions` or `expo-core-spotlight` is installed; neither is yet. `app.config.ts`'s round-4 section adds their native config for development builds only.
 - `src/theme/`: the website's DebateOwl design tokens (`src/styles/tokens.css` and the roles in `src/index.css`) in light and dark. `primary` is the blue that passes as text; `primaryFill` with `primaryLedge` is the button face and the ledge it sits on. Success is mint and always comes with a check mark. Fredoka (`weight="display"`) is for titles, the motion and button labels, Nunito for everything else, loaded with expo-font from `@expo-google-fonts`. Buttons are the website's tactile ones (`components/buttons.tsx`), which sink onto their ledge while pressed. Cards and fields have 2pt edges.
 - `components/owl.tsx`: Ollie, from PNGs of the website's owl SVGs (`src/assets/owl`, `public/owl-mark.svg`), in the pose the website uses for each place: `point` for an empty start, `coach` beside Ask's answers, `arguing` for the Sparring opponent, `reading`, `surprised` and `sleepy` in empty states (`components/empty-state.tsx`), and a tool's pose while it works (`ToolProgress`). `scripts/render-owls.ts` renders them, the app icon, the splash image and the Android icons again after the website's owl changes.
 - `scripts/screenshots.ts`: web-export screenshots. `scripts/render-tab-icons.ts` redraws the tab bar PNGs.
diff --git a/apps/mobile/app.config.ts b/apps/mobile/app.config.ts
index 14320679f..e3b322bec 100644
--- a/apps/mobile/app.config.ts
+++ b/apps/mobile/app.config.ts
@@ -1,9 +1,11 @@
 import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 
 import type { ConfigContext, ExpoConfig } from 'expo/config';
 import { type ConfigPlugin, withEntitlementsPlist } from 'expo/config-plugins';
 
+
 // One config for Expo Go, the web export and the development build.
 // DEBATELAB_BUILD=dev (set by the `development` profile in eas.json) adds the
 // native modules Expo Go lacks. Without it the config is the one Expo Go has
@@ -52,6 +54,107 @@ const withoutPushEntitlement: ConfigPlugin = (config) =>
     return mod;
   });
 
+// Native config for the Current Debate widget, Home Screen quick actions and
+// Spotlight. Called only for a development build (DEBATELAB_BUILD=dev), after the
+// expo-widgets entry, so the Expo Go
+// config never changes. Each part turns on only when it can work:
+// - the widget needs the App Group, which is when app.config.ts adds expo-widgets;
+// - quick actions need expo-quick-actions to hand the picked item to the app;
+// - Spotlight needs expo-core-spotlight@^2 and its plugin (SDK 56 and 57).
+// Strings come from src/locales; a missing key fails the config with its name.
+
+type Language = 'en' | 'es' | 'hu';
+const LANGUAGES: Language[] = ['en', 'es', 'hu'];
+
+/** The widget's name in src/widgets/current-debate.tsx's createWidget call. */
+const WIDGET_NAME = 'CurrentDebate';
+
+/**
+ * Info.plist titles are keys into each language's InfoPlist.strings, which
+ * prebuild writes as `KEY = "value";` without quoting the key, so they are
+ * plain identifiers. The types are the routes in src/lib/quick-actions.ts.
+ */
+const QUICK_ACTIONS = [
+  { type: 'new-debate', titleKey: 'QuickActionNewDebate', catalogKey: 'mobile.debates.newDebate', symbol: 'plus.bubble' },
+  { type: 'timer', titleKey: 'QuickActionStartTimer', catalogKey: 'mobile.quickActions.startTimer', symbol: 'timer' },
+  { type: 'ask', titleKey: 'QuickActionAsk', catalogKey: 'askChat.title', symbol: 'questionmark.bubble' },
+] as const;
+
+type WidgetsPluginOptions = { widgets?: { name: string }[] };
+
+export function withRound4(config: ExpoConfig, opts: { appGroup?: string; projectRoot: string }): ExpoConfig {
+  const catalogs = new Map<Language, unknown>();
+  const text = (language: Language, key: string): string => {
+    if (!catalogs.has(language)) {
+      const file = path.join(opts.projectRoot, '../../src/locales', `${language}.json`);
+      catalogs.set(language, JSON.parse(readFileSync(file, 'utf8')));
+    }
+    const value = key.split('.').reduce<unknown>(
+      (node, part) => (node !== null && typeof node === 'object' ? (node as Record<string, unknown>)[part] : undefined),
+      catalogs.get(language),
+    );
+    if (typeof value !== 'string' || value === '') {
+      throw new Error(`app.config.ts: src/locales/${language}.json has no "${key}".`);
+    }
+    return value;
+  };
+  const resolve = createRequire(path.join(opts.projectRoot, 'package.json')).resolve;
+  const installed = (name: string) => {
+    try {
+      resolve(`${name}/package.json`);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  if (opts.appGroup) {
+    const entry = config.plugins?.find((plugin) => Array.isArray(plugin) && plugin[0] === 'expo-widgets');
+    if (!Array.isArray(entry) || entry.length < 2) {
+      throw new Error(
+        'app.config.ts: withRound4 must run after app.config.ts adds the expo-widgets plugin (its DEBATELAB_APP_GROUP block).',
+      );
+    }
+    const options = entry[1] as WidgetsPluginOptions;
+    // The gallery's name and description are compiled into the extension in English.
+    options.widgets = [
+      ...(options.widgets ?? []).filter((widget) => widget.name !== WIDGET_NAME),
+      {
+        name: WIDGET_NAME,
+        displayName: text('en', 'nav.currentDebate'),
+        description: text('en', 'mobile.widget.description'),
+        ios: { supportedFamilies: ['systemSmall', 'systemMedium'] },
+      } as { name: string },
+    ];
+  }
+
+  if (installed('expo-quick-actions')) {
+    config.ios = { ...config.ios, infoPlist: { ...config.ios?.infoPlist } };
+    config.ios.infoPlist!.UIApplicationShortcutItems = QUICK_ACTIONS.map((action) => ({
+      UIApplicationShortcutItemType: action.type,
+      UIApplicationShortcutItemTitle: action.titleKey,
+      UIApplicationShortcutItemIconSymbolName: action.symbol,
+    }));
+    const locales = (config.locales ??= {});
+    for (const language of LANGUAGES) {
+      const current = locales[language];
+      if (typeof current === 'string') {
+        throw new Error(`app.config.ts: locales.${language} is a file path; it needs to be an object to add the quick actions.`);
+      }
+      const titles = Object.fromEntries(
+        QUICK_ACTIONS.map((action) => [action.titleKey, stringsValue(text(language, action.catalogKey))]),
+      );
+      locales[language] = { ...current, ios: { ...current?.ios, ...titles } };
+    }
+  }
+
+  if (installed('expo-core-spotlight')) {
+    config.plugins = [...(config.plugins ?? []).filter((plugin) => plugin !== 'expo-core-spotlight'), 'expo-core-spotlight'];
+  }
+
+  return config;
+}
+
 export default ({ projectRoot }: ConfigContext): ExpoConfig => {
   const config: ExpoConfig = {
     name: 'DebateOwl',
@@ -111,6 +214,10 @@ export default ({ projectRoot }: ConfigContext): ExpoConfig => {
     es: iosLocale(permissionStrings(projectRoot, 'es')),
     hu: iosLocale(permissionStrings(projectRoot, 'hu')),
   };
+  // Universal links for debateowl.com/share/* and /app/* (src/app/+native-intent.tsx). They work
+  // once the provisioning profile has Associated Domains and the website serves
+  // apple-app-site-association; Expo Go cannot have them.
+  config.ios!.associatedDomains = ['applinks:debateowl.com', 'applinks:www.debateowl.com'];
   config.plugins!.push(
     'expo-dev-client',
     [
@@ -129,6 +236,8 @@ export default ({ projectRoot }: ConfigContext): ExpoConfig => {
       },
     ]);
   }
+  // The Current Debate widget (with the App Group), quick actions and Spotlight; see withRound4 above.
+  withRound4(config, { appGroup, projectRoot });
   // Registered before Expo applies the plugins list. Mods registered later act
   // first, so this one runs after the plugins have written their entitlements.
   return withoutPushEntitlement(config);
diff --git a/apps/mobile/package.json b/apps/mobile/package.json
index 49c78b0e8..e79921725 100644
--- a/apps/mobile/package.json
+++ b/apps/mobile/package.json
@@ -13,12 +13,14 @@
     "@expo-google-fonts/fredoka": "^0.4.1",
     "@expo-google-fonts/nunito": "^0.4.2",
     "@expo/dom-webview": "~57.0.1",
+    "@expo/ui": "~57.0.22",
     "@formatjs/intl-listformat": "^8.3.15",
     "@formatjs/intl-pluralrules": "^6.3.15",
     "@react-native-async-storage/async-storage": "2.2.0",
     "@supabase/supabase-js": "^2.49.1",
     "aes-js": "^3.1.2",
     "date-fns": "^3.6.0",
+    "docx": "^9.5.1",
     "expo": "~57.0.27",
     "expo-audio": "~57.0.5",
     "expo-clipboard": "~57.0.2",
diff --git a/apps/mobile/scripts/screenshots.ts b/apps/mobile/scripts/screenshots.ts
index f089e1ebe..726577cdc 100644
--- a/apps/mobile/scripts/screenshots.ts
+++ b/apps/mobile/scripts/screenshots.ts
@@ -12,9 +12,10 @@
  * separate several with commas (ONLY=iphone-light-en,ipad-dark-hu).
  * SCREENS=you,timer limits the signed-in screens to those groups: debate,
  * debate-check, library, prepare, practice, you, empty, ask, results, brainstorm,
- * factoids, case-edits, context, limits,
+ * factoids, case-edits, context, limits, sidebar, first-run, share,
  * timer, crossfire, sparring, flowchart, one-off, history, announcements,
  * account, model. Sign-in screens are always shot.
+ * KEEP_GOING=1 carries on past a failed group (see groupFailed).
  * ONLY=offline runs only the offline reading check (see shootOfflineScreens).
  *
  * The iPad sizes are portrait (1024x1366), landscape (1366x1024), an 11-inch
@@ -25,8 +26,9 @@
  * script signs in once through the real sign-in screen and also checks that a
  * cold start without a network keeps the user signed in. The deployed Edge
  * Functions only accept browser calls from a few origins, so for that run use
- * PORT=18080 (http://127.0.0.1:18080). Never print the code or put it in a
- * screenshot.
+ * PORT=18080 (http://127.0.0.1:18080), or another port with
+ * FUNCTIONS_ORIGIN=http://127.0.0.1:18080 (see newContext). Never print the
+ * code or put it in a screenshot.
  *
  * Signed in, the app applies the account's saved language and theme, which
  * would override the locale and colour scheme under test. Screenshot runs
@@ -132,6 +134,60 @@ const SIGNED_IN_ROUTES = { prepare: '/prepare', practice: '/practice', you: '/yo
 const NOTIFICATIONS = { en: 'Notifications', hu: 'Értesítések', es: 'Notificaciones' } as const;
 const REST = `https://${STAGING_HOST}/rest/v1`;
 
+/**
+ * The deployed Edge Functions answer browser calls only from a few origins
+ * (supabase/functions/_shared/cors.ts), 127.0.0.1:18080 among them. When
+ * several worktrees take screenshots at once, set FUNCTIONS_ORIGIN to that
+ * origin and use any PORT: each function call the page makes is sent again
+ * from Node with that Origin and its answer handed back to the page. Staging only.
+ */
+const FUNCTIONS_ORIGIN = process.env.FUNCTIONS_ORIGIN;
+
+/**
+ * FONT_SCALE draws a Dynamic Type size (src/theme/font-scale.web.ts): 3.1 is
+ * iOS's largest accessibility size for body text. Use it with SHOTS_DIR, so
+ * the large-text shots do not replace the usual ones.
+ */
+const FONT_SCALE = Number(process.env.FONT_SCALE ?? '1');
+
+/**
+ * Screenshots show each screen at rest: contexts prefer reduced motion, which the app's
+ * animations follow (Reanimated and react-native-web read prefers-reduced-motion), so
+ * confetti, count-ups, entrances and springs land at once. MOTION=1 plays them; with
+ * RECORD_DIR set, every page is also recorded as a video there.
+ */
+const MOTION = process.env.MOTION === '1';
+const RECORD_DIR = process.env.RECORD_DIR;
+
+async function newContext(browser: Browser, options: BrowserContextOptions): Promise<BrowserContext> {
+  const context = await browser.newContext({
+    reducedMotion: MOTION ? 'no-preference' : 'reduce',
+    ...(RECORD_DIR && options.viewport ? { recordVideo: { dir: RECORD_DIR, size: options.viewport } } : {}),
+    ...options,
+  });
+  if (FONT_SCALE > 0 && FONT_SCALE !== 1) {
+    await context.addInitScript((scale) => {
+      (window as unknown as { __debateowlFontScale?: number }).__debateowlFontScale = scale;
+    }, FONT_SCALE);
+  }
+  if (FUNCTIONS_ORIGIN && FUNCTIONS_ORIGIN !== ORIGIN) {
+    // Context routes run after page routes, so a page that fakes a function keeps its fake.
+    await context.route(`https://${STAGING_HOST}/functions/v1/**`, async (route) => {
+      const request = route.request();
+      const cors = { 'access-control-allow-origin': ORIGIN, 'access-control-allow-headers': '*', 'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS', vary: 'Origin' };
+      if (request.method() === 'OPTIONS') return route.fulfill({ status: 204, headers: cors });
+      // A page that closes mid-call ends the relay quietly: Playwright's error would print the request's headers, session included.
+      try {
+        const response = await route.fetch({ headers: { ...request.headers(), origin: FUNCTIONS_ORIGIN } });
+        await route.fulfill({ response, headers: { ...response.headers(), ...cors } });
+      } catch {
+        await route.abort().catch(() => undefined);
+      }
+    });
+  }
+  return context;
+}
+
 const TYPES: Record<string, string> = {
   '.html': 'text/html; charset=utf-8',
   '.js': 'text/javascript',
@@ -146,8 +202,8 @@ const TYPES: Record<string, string> = {
 function serve(): Promise<Server> {
   const server = createServer((req, res) => {
     const path = normalize(decodeURIComponent(new URL(req.url ?? '/', ORIGIN).pathname)).replace(/^(\.\.[/\\])+/, '');
-    // A dynamic route such as /case/<id> is exported once, as case/[id].html.
-    const candidates = [join(DIST, path), join(DIST, `${path}.html`), join(DIST, path, 'index.html'), join(DIST, dirname(path), '[id].html')];
+    // A dynamic route such as /case/<id> is exported once, as case/[id].html (share/[code].html for /share/<code>).
+    const candidates = [join(DIST, path), join(DIST, `${path}.html`), join(DIST, path, 'index.html'), join(DIST, dirname(path), '[id].html'), join(DIST, dirname(path), '[code].html')];
     const file = candidates.find((candidate) => candidate.startsWith(DIST) && existsSync(candidate) && statSync(candidate).isFile());
     if (!file) {
       res.writeHead(404).end('Not found');
@@ -217,6 +273,19 @@ async function shoot(page: Page, name: string) {
   await page.screenshot({ path: join(OUT, `${name}.png`), mask: [page.getByTestId('account-email'), page.getByTestId('delete-data-confirmation')] });
 }
 
+/**
+ * A finished round or case opens under its celebration: shoot it as `name`, then tap it away
+ * (unless it already went on its own) and wait until the screen underneath is clear.
+ */
+async function shootCelebration(page: Page, name: string) {
+  const celebration = page.getByTestId('celebration');
+  await celebration.waitFor({ timeout: 30_000 });
+  await page.waitForTimeout(400);
+  await shoot(page, name);
+  await celebration.click({ timeout: 2_000 }).catch(() => {});
+  await celebration.waitFor({ state: 'detached', timeout: 5_000 });
+}
+
 /** Answers user_settings reads with the run's language and the System theme (see the header). */
 async function pinSettings(page: Page, language: string) {
   await pinDebateActivity(page, 0);
@@ -252,9 +321,31 @@ async function pinDebateActivity(page: Page, ageMs: number) {
 }
 
 /** Waits until the screen's data has arrived, so no spinner is caught mid-load. */
+/** The app's navigation: the tab bar on iPhone and in Split View, the sidebar in a full-screen iPad window. */
+const appShell = (page: Page) => page.locator(':is([data-testid="app-tab-bar"], [data-testid="app-sidebar"]):visible').first();
+
+/** Opens a Prepare tool the way the layout offers it: from the iPad sidebar, or from the Prepare tab's tile. */
+async function openPrepareTool(page: Page, tool: string) {
+  const sidebar = page.getByTestId('app-sidebar');
+  if (await sidebar.isVisible()) {
+    await sidebar.getByTestId(`sidebar-item-${tool}`).click();
+    return;
+  }
+  if (!(await page.getByTestId(`prepare-tool-${tool}`).filter({ visible: true }).isVisible())) {
+    await page.getByRole('tab', { name: /^(Prepare|Felkészülés|Preparar)$/ }).click();
+  }
+  await page.getByTestId(`prepare-tool-${tool}`).filter({ visible: true }).click();
+}
+
 async function settle(page: Page) {
   await page.waitForLoadState('networkidle');
-  await page.waitForFunction(() => document.querySelectorAll('[role="progressbar"]').length === 0, undefined, { timeout: 15_000 });
+  // Only what shows: a screen opened from a link has the Debate tab mounted, unfocused, beneath it,
+  // and that tab loads only once it is shown.
+  await page.waitForFunction(
+    () => Array.from(document.querySelectorAll('[role="progressbar"]')).every((el) => !(el as HTMLElement).checkVisibility()),
+    undefined,
+    { timeout: 15_000 },
+  );
 }
 
 async function shootDebateScreens(page: Page, prefix: string) {
@@ -411,16 +502,19 @@ async function fakeAsk(page: Page, hold: boolean) {
 }
 
 // A made-up case in GenerateOutput's shape, after mock 03: three arguments for a Standard case.
+// A made-up case in the new format (#244): opening, titled arguments, "If they say…", closing line and sources.
 const FAKE_CASE = {
+  opening: {
+    hook: 'Picture a school run where the loudest thing on the street is children talking.',
+    definition: 'City centre: the area inside the inner ring road, with exemptions for disabled drivers and deliveries.',
+  },
   caseStructure: {
-    thesis: 'City centres are shared public space, and private cars take the most of it while costing everyone else their health.',
-    framework: 'City centres are shared public space. The motion asks who gets to use that space, and at what cost to everyone else\'s health.',
-    keyDefinitions: ['City centre: the area inside a city\'s inner ring road', 'Private cars: privately owned passenger vehicles, with exemptions for disabled drivers'],
-    burdenOfProof: 'We must show that removing private cars improves health and access for most people who use the centre.',
+    thesis: 'We will show three arguments that prove city centres work better for everyone without private cars: cleaner air, streets back for people, and buses that run on time.',
   },
   contentions: [
     {
       id: '1',
+      title: 'Clean air',
       claim: 'Clean air is a public health duty',
       reasoning: 'Traffic is the largest source of roadside pollution, and the people who breathe it most are pedestrians, cyclists and residents, not drivers.',
       evidence: 'Low-traffic zones cut roadside NO₂ within their first year, according to the Clean Streets Review.',
@@ -429,7 +523,8 @@ const FAKE_CASE = {
     },
     {
       id: '2',
-      claim: 'Streets back for people',
+      title: 'Streets back for people',
+      claim: 'Cars take most of the street while carrying a minority of the people in it',
       reasoning: 'Parked and moving cars take most of a centre\'s street space while carrying a minority of the people in it.',
       evidence: 'The Street Space Audit found cars use most of the road area; the Footfall Study found shops gain visits when streets close to traffic.',
       needsSource: false,
@@ -437,6 +532,7 @@ const FAKE_CASE = {
     },
     {
       id: '3',
+      title: 'Buses on time',
       claim: 'Transit works when it isn\'t stuck in traffic',
       reasoning: 'Buses lose most of their delay to congestion caused by private cars.',
       evidence: 'Bus journeys became quicker and more reliable after the centre closed to through traffic, per the Clean Streets Review.',
@@ -444,13 +540,16 @@ const FAKE_CASE = {
       impact: 'Faster, more reliable buses make the ban fair to people who cannot walk or cycle.',
     },
   ],
-  predictedOpponentCase: {
-    likelyArguments: ['Shift workers and carers need cars at hours when transit is thin', 'Businesses lose customers who drive in'],
-    strategicWeaknesses: ['Depends on exemptions working in practice'],
-    keyClashes: ['Access for the few against health for the many', 'Shops and footfall'],
-  },
   counters: [
-    { targetArgument: 'Shift workers need cars', counterpoint: 'Exemptions and night buses cover them.', rebuttal: 'Every real ban exempts carers and shift workers, and transit follows demand.' },
+    { targetArgument: 'Shift workers and carers need cars at night', counterpoint: 'Every real ban exempts carers and shift workers, and night buses follow demand.', source: 'Clean Streets Review' },
+    { targetArgument: 'Shops lose customers who drive in', counterpoint: 'Footfall rose when streets closed to traffic: people on foot shop more often than drivers.', source: 'Footfall Study' },
+    { targetArgument: 'It just moves traffic to the suburbs', counterpoint: 'Through traffic falls overall when the centre closes, because some trips stop being made by car at all.' },
+  ],
+  closingLine: 'A city centre should belong to the people in it, not the cars passing through it.',
+  sources: [
+    { org: 'Clean Streets Review', year: '2025', claim: 'Low-traffic zones cut roadside NO₂ within a year', url: 'https://example.org/clean-streets' },
+    { org: 'Street Space Audit', year: '2024', claim: 'Cars use most of the road area in city centres', url: 'https://example.org/street-space' },
+    { org: 'Footfall Study', claim: 'Shops gain visits when streets close to traffic', url: 'https://example.org/footfall' },
   ],
   metadata: {
     side: 'pro',
@@ -636,6 +735,7 @@ async function shootResultScreens(context: BrowserContext, prefix: string, langu
   await page.getByTestId('generate-motion').waitFor({ timeout: 30_000 });
   await page.waitForFunction(() => (document.querySelector('[data-testid="generate-motion"]') as HTMLTextAreaElement | null)?.value.trim());
   await page.getByRole('button', { name: /^(Generate debate case|Vitaeset generálása|Generar caso de debate)$/i }).click();
+  await shootCelebration(page, `${prefix}-case-celebration`);
   await page.getByTestId('case-document').waitFor({ timeout: 30_000 });
   await page.waitForTimeout(400);
   await shoot(page, `${prefix}-case`);
@@ -695,7 +795,7 @@ async function shootResultScreens(context: BrowserContext, prefix: string, langu
 
   await page.getByTestId('attack-this-case').click();
   await page.getByTestId('attack-case-text').waitFor({ timeout: 15_000 });
-  await page.waitForFunction(() => (document.querySelector('[data-testid="attack-case-text"]') as HTMLTextAreaElement | null)?.value.startsWith('THESIS:'));
+  await page.waitForFunction(() => (document.querySelector('[data-testid="attack-case-text"]') as HTMLTextAreaElement | null)?.value.startsWith('OPENING:'));
   await shoot(page, `${prefix}-attack-form`);
   await page.getByRole('button', { name: /^(Find weaknesses|Gyengeségek keresése|Encontrar debilidades)$/i }).click();
   await page.getByTestId('attack-document').waitFor({ timeout: 30_000 });
@@ -786,6 +886,7 @@ const MENU = {
   regenerate: /^(Regenerate a section|Szakasz újragenerálása|Regenerar una sección)$/,
   arguments: /^(Regenerate Arguments|Érvek újragenerálása|Regenerar Argumentos)$/,
   save: /^(Save|Mentés|Guardar)$/,
+  shareLink: /^(Share link|Link megosztása|Compartir enlace)$/,
 };
 
 /**
@@ -822,6 +923,9 @@ async function shootCaseEdits(context: BrowserContext, prefix: string, language:
     await page.waitForFunction(() => (document.querySelector('[data-testid="generate-motion"]') as HTMLTextAreaElement | null)?.value.trim());
     await page.getByRole('button', { name: /^(Generate debate case|Vitaeset generálása|Generar caso de debate)$/i }).click();
     await page.getByTestId('case-document').waitFor({ timeout: 30_000 });
+    // A new case opens with its celebration (shot in the results group); tap it away first.
+    await page.getByTestId('celebration').click({ timeout: 5_000 }).catch(() => {});
+    await page.getByTestId('celebration').waitFor({ state: 'detached', timeout: 5_000 });
     await page.waitForTimeout(3800); // The arrival notice fades.
     return { page, seen };
   };
@@ -1064,9 +1168,7 @@ async function shootFlowchart(context: BrowserContext, prefix: string, language:
   if (!(await toggle.isChecked())) throw new Error('The one-off switch did not turn on');
   await oneOff.getByTestId('debates-sheet').getByRole('button', { name: /^(Done|Kész|Listo)$/ }).click();
   await oneOff.getByTestId('debates-sheet').waitFor({ state: 'detached' });
-  await oneOff.getByRole('tab', { name: /^(Prepare|Felkészülés|Preparar)$/ }).click();
-  await oneOff.getByTestId('prepare-tool-flowchart').waitFor({ timeout: 30_000 });
-  await oneOff.getByTestId('prepare-tool-flowchart').click();
+  await openPrepareTool(oneOff, 'flowchart');
   await oneOff.getByTestId('flowchart-screen').getByTestId('one-off-notice').waitFor({ timeout: 30_000 });
   await oneOff.getByTestId('flow-card').first().waitFor({ timeout: 30_000 });
   await settle(oneOff);
@@ -1136,6 +1238,13 @@ async function fakeLibrary(page: Page) {
       rows = (rows ?? []).filter((row) => row.id !== id);
       return route.fulfill({ status: 200, headers: CORS, json: removed.map((row) => ({ debate_id: row.debate_id })) });
     }
+    if (request.method() === 'PATCH') {
+      // An edit or an Active switch, kept as the server keeps it, so the list read after a write shows it.
+      const filter = url.searchParams.get('id') ?? '';
+      const ids = filter.startsWith('eq.') ? [filter.slice(3)] : filter.startsWith('in.(') ? filter.slice(4, -1).split(',').map((id) => id.replace(/"/g, '')) : [];
+      const body = request.postDataJSON() as Record<string, unknown>;
+      rows = (rows ?? []).map((row) => (ids.includes(String(row.id)) ? { ...row, ...body } : row));
+    }
     return route.fulfill({ status: 204, headers: CORS });
   });
 }
@@ -1413,6 +1522,7 @@ async function shootCrossfireScreens(context: BrowserContext, prefix: string, la
   await shoot(page, `${prefix}-crossfire-exchange`);
 
   await page.getByTestId('crossfire-end').click();
+  await shootCelebration(page, `${prefix}-crossfire-celebration`);
   await page.getByTestId('crossfire-debrief').waitFor({ timeout: 15_000 });
   await page.waitForTimeout(400);
   await shoot(page, `${prefix}-crossfire-debrief`);
@@ -1557,6 +1667,7 @@ async function shootSparringScreens(context: BrowserContext, prefix: string, lan
   await shoot(page, `${prefix}-sparring-judging`);
   fake.release('score');
 
+  await shootCelebration(page, `${prefix}-sparring-celebration`);
   await page.getByTestId('sparring-scorecard').waitFor({ timeout: 15_000 });
   await page.waitForTimeout(400);
   await shoot(page, `${prefix}-sparring-scorecard`);
@@ -1612,20 +1723,27 @@ async function shootOneOffTools(page: Page, prefix: string) {
   await settle(page);
   await turnOnOneOff(page);
   await closeSwitcher(page);
-  await page.getByRole('tab', { name: /^(Prepare|Felkészülés|Preparar)$/ }).click();
-  await page.getByTestId('prepare-tool-generate').waitFor({ timeout: 30_000 });
-  // The Debate tab stays mounted behind Prepare with its own notice; only the visible one is Prepare's.
-  await page.getByTestId('one-off-notice').filter({ visible: true }).waitFor();
-  await settle(page);
-  await shoot(page, `${prefix}-prepare-oneoff`);
+  // The iPad sidebar lists the tools themselves, so there is no Prepare tab to shoot there.
+  const sidebar = await page.getByTestId('app-sidebar').isVisible();
+  if (!sidebar) {
+    await page.getByRole('tab', { name: /^(Prepare|Felkészülés|Preparar)$/ }).click();
+    await page.getByTestId('prepare-tool-generate').waitFor({ timeout: 30_000 });
+    // The Debate tab stays mounted behind Prepare with its own notice; only the visible one is Prepare's.
+    await page.getByTestId('one-off-notice').filter({ visible: true }).waitFor();
+    await settle(page);
+    await shoot(page, `${prefix}-prepare-oneoff`);
+  }
   // Brainstorm and Factoids say it through the same strip; a reload would end one-off mode, so go back in the app.
   for (const tool of ['brainstorm', 'factoids'] as const) {
-    await page.getByTestId(`prepare-tool-${tool}`).click();
+    await openPrepareTool(page, tool);
     await page.getByTestId(`${tool}-screen`).getByTestId('one-off-notice').waitFor({ timeout: 30_000 });
-    await page.goBack();
-    await page.getByTestId('prepare-tool-generate').filter({ visible: true }).waitFor();
+    // The sidebar goes from tool to tool; on a phone the tool goes back to Prepare's tiles.
+    if (!sidebar) {
+      await page.goBack();
+      await page.getByTestId('prepare-tool-generate').filter({ visible: true }).waitFor();
+    }
   }
-  await page.getByTestId('prepare-tool-generate').click();
+  await openPrepareTool(page, 'generate');
   await page.getByTestId('generate-motion').waitFor({ timeout: 30_000 });
   const notice = page.getByTestId('generate-screen').getByTestId('one-off-notice');
   await notice.waitFor();
@@ -1635,6 +1753,228 @@ async function shootOneOffTools(page: Page, prefix: string) {
   await page.getByTestId('generate-screen').getByTestId('working-in').waitFor();
 }
 
+/**
+ * The iPad sidebar (ipad devices only): every tool under Debate, Prepare,
+ * Practice, Library and You. It shoots the sidebar fully expanded, then with
+ * Practice and Library closed while Generate is open, and checks that the
+ * closed sections stay closed after a reload, that a row highlights the screen
+ * it opens, that picking another row from an open tool replaces that tool
+ * instead of stacking a second screen, and that a 600-point window (Split View)
+ * has the tab bar instead.
+ */
+async function shootSidebar(context: BrowserContext, prefix: string, language: string, problems: string[]): Promise<number> {
+  const page = await context.newPage();
+  watchErrors(page, problems, `${prefix} sidebar`);
+  await pinSettings(page, language);
+  const viewport = page.viewportSize();
+  await page.goto(`${ORIGIN}/`);
+  await page.evaluate(() => localStorage.removeItem('debateowl.sidebar.collapsed'));
+  await page.goto(`${ORIGIN}/`);
+  const sidebar = page.getByTestId('app-sidebar');
+  if (viewport && viewport.width < 700) {
+    await page.getByTestId('app-tab-bar').waitFor();
+    if (await sidebar.isVisible()) throw new Error(`${prefix}: a ${viewport.width}-point window shows the sidebar`);
+    await page.close();
+    return 0;
+  }
+  await sidebar.waitFor({ timeout: 30_000 });
+  if (await page.getByTestId('app-tab-bar').isVisible()) throw new Error(`${prefix}: the tab bar shows beside the sidebar`);
+  await page.getByTestId('current-debate-motion').waitFor({ timeout: 30_000 });
+  await settle(page);
+  const selected = async () => sidebar.locator('[aria-selected="true"]').getAttribute('data-testid');
+  if ((await selected()) !== 'sidebar-item-dashboard') throw new Error(`${prefix}: the Debate tab does not highlight Dashboard`);
+  await shoot(page, `${prefix}-sidebar-expanded`);
+
+  // Generate from the sidebar, then Attack from Generate: the sidebar replaces the open tool.
+  await sidebar.getByTestId('sidebar-item-generate').click();
+  await page.getByTestId('generate-motion').waitFor({ timeout: 30_000 });
+  await sidebar.getByTestId('sidebar-item-attack').click();
+  await page.waitForURL('**/attack**');
+  await sidebar.getByTestId('sidebar-item-generate').click();
+  await page.getByTestId('generate-motion').waitFor({ timeout: 30_000 });
+  if ((await selected()) !== 'sidebar-item-generate') throw new Error(`${prefix}: Generate is not highlighted on Generate`);
+  await page.goBack();
+  await page.waitForURL((url) => url.pathname === '/');
+  await page.getByTestId('current-debate-motion').waitFor({ timeout: 30_000 });
+  await sidebar.getByTestId('sidebar-item-generate').click();
+  await page.getByTestId('generate-motion').waitFor({ timeout: 30_000 });
+
+  // A tool opened cold, as from a link: the sidebar still replaces it, and Back reaches the tabs.
+  await page.goto(`${ORIGIN}/generate`);
+  await page.getByTestId('generate-motion').waitFor({ timeout: 30_000 });
+  await sidebar.getByTestId('sidebar-item-ask').click();
+  await page.waitForURL('**/ask**');
+  await sidebar.getByTestId('sidebar-item-attack').click();
+  await page.waitForURL('**/attack**');
+  // The app's own Back (browser history on the web does not follow the stack).
+  await page.getByTestId('document-back').filter({ visible: true }).click();
+  await page.waitForURL((url) => url.pathname === '/', { timeout: 15_000 });
+  // The dashboard drops a load it loses focus during, so let it finish before covering it again.
+  await page.getByTestId('current-debate-motion').waitFor({ timeout: 30_000 });
+  await settle(page);
+  await sidebar.getByTestId('sidebar-item-generate').click();
+  await page.getByTestId('generate-motion').waitFor({ timeout: 30_000 });
+
+  for (const section of ['practice', 'library']) {
+    const toggle = sidebar.getByTestId(`sidebar-toggle-${section}`);
+    await toggle.click();
+    if ((await toggle.getAttribute('aria-expanded')) !== 'false') throw new Error(`${prefix}: ${section} did not collapse`);
+  }
+  await settle(page);
+  await shoot(page, `${prefix}-sidebar-collapsed`);
+
+  await page.goto(`${ORIGIN}/library`);
+  await sidebar.waitFor({ timeout: 30_000 });
+  for (const section of ['practice', 'library']) {
+    if (await sidebar.getByTestId(`sidebar-section-${section}`).locator('[data-testid^="sidebar-item-"]').count()) {
+      throw new Error(`${prefix}: ${section} opened again after a reload`);
+    }
+  }
+  // A closed section still marks the screen it holds.
+  await sidebar.getByTestId('sidebar-toggle-library').click();
+  if ((await selected()) !== 'sidebar-item-sources') throw new Error(`${prefix}: Sources is not highlighted on the Library`);
+
+  // Split View: the same iPad at 600 points keeps the tab bar.
+  if (viewport) {
+    await page.setViewportSize({ width: 600, height: viewport.height });
+    await page.getByTestId('app-tab-bar').waitFor();
+    if (await sidebar.isVisible()) throw new Error(`${prefix}: the sidebar stays in a 600-point window`);
+    await page.setViewportSize(viewport);
+  }
+  await page.close();
+  return 2;
+}
+
+/**
+ * A share link, end to end on staging: the made-up saved case's Share link
+ * calls the real `share` function (one new link), and the link's code opens
+ * the in-app viewer, which reads it back with the public get_shared_item RPC.
+ */
+async function shootShareLink(context: BrowserContext, prefix: string, language: string, problems: string[]): Promise<number> {
+  const page = await context.newPage();
+  watchErrors(page, problems, `${prefix} share`);
+  await pinSettings(page, language);
+  await fakeSavedCase(page);
+  await page.goto(`${ORIGIN}/case/${SAVED_CASE_ID}`);
+  await page.getByTestId('case-document').waitFor({ timeout: 30_000 });
+  await page.getByTestId('document-more').click();
+  await page.getByRole('menuitem', { name: MENU.shareLink }).last().click();
+  await page.waitForFunction(() => Boolean((window as unknown as { __debatelabExport?: { sharedUrl?: string } }).__debatelabExport?.sharedUrl), undefined, { timeout: 30_000 });
+  const url = await page.evaluate(() => (window as unknown as { __debatelabExport?: { sharedUrl?: string } }).__debatelabExport?.sharedUrl ?? '');
+  const code = /^\/share\/([A-Za-z0-9_-]+)$/.exec(new URL(url).pathname)?.[1];
+  if (!code) throw new Error(`The share link has no code: ${new URL(url).host}${new URL(url).pathname.replace(/[^/]+$/, '…')}`);
+  console.log(`${prefix}: share link on ${new URL(url).host}, a ${code.length}-character code`);
+  await page.close();
+
+  const viewer = await context.newPage();
+  watchErrors(viewer, problems, `${prefix} shared view`);
+  await viewer.goto(`${ORIGIN}/share/${code}`);
+  await viewer.getByTestId('shared-document').waitFor({ timeout: 30_000 });
+  await viewer.getByTestId('case-opening').waitFor();
+  await settle(viewer);
+  await shoot(viewer, `${prefix}-shared-case`);
+  await viewer.close();
+  return 1;
+}
+
+/**
+ * The first run and two account notices, each in a context of its own:
+ * Ollie's welcome (asked for with ?intro=show, as on the website) and the
+ * tour's first and last steps; the trial reminder, from a user_settings read
+ * answered as a trial ending in two days with no subscription rows; and the
+ * expired-session notice, from a stored session whose refresh the page
+ * answers with invalid_grant. Nothing is written.
+ */
+async function shootFirstRun(
+  browser: Browser,
+  options: BrowserContextOptions,
+  session: StorageState,
+  prefix: string,
+  language: string,
+  problems: string[],
+): Promise<number> {
+  let shots = 0;
+  const welcome = await newContext(browser, { ...options, storageState: session });
+  const page = await welcome.newPage();
+  watchErrors(page, problems, `${prefix} welcome`);
+  await pinSettings(page, language);
+  await page.goto(`${ORIGIN}/?intro=show`);
+  await page.getByTestId('debateowl-intro').waitFor({ timeout: 30_000 });
+  // The owl's lines land over 6.6 seconds.
+  await page.waitForTimeout(7_000);
+  await shoot(page, `${prefix}-welcome`);
+  await page.getByTestId('intro-done').click();
+  await page.getByTestId('tour-step-debate').waitFor();
+  await shoot(page, `${prefix}-tour-debate`);
+  for (const step of ['library', 'generate', 'ready']) {
+    await page.getByTestId('tour-next').click();
+    await page.getByTestId(`tour-step-${step}`).waitFor();
+  }
+  await shoot(page, `${prefix}-tour-ready`);
+  await page.getByTestId('tour-next').click();
+  await page.getByTestId('tour-step-ready').waitFor({ state: 'detached' });
+  shots += 3;
+  await page.unrouteAll({ behavior: 'ignoreErrors' });
+  await welcome.close();
+
+  const trial = await newContext(browser, { ...options, storageState: session });
+  const trialPage = await trial.newPage();
+  watchErrors(trialPage, problems, `${prefix} trial`);
+  await pinSettings(trialPage, language);
+  const endsAt = new Date(Date.now() + 2 * 24 * 60 * 60 * 1000 + 60 * 60 * 1000).toISOString();
+  await trialPage.route(`${REST}/user_settings*`, async (route) => {
+    if (route.request().method() !== 'GET' || !route.request().url().includes('trial_ends_at')) return route.fallback();
+    // A read still running when the context closes ends quietly: Playwright's error would print the request's headers.
+    try {
+      const response = await route.fetch();
+      const body: unknown = await response.json();
+      const asTrial = (row: Record<string, unknown>) => ({ ...row, subscription_tier: 'trial', trial_ends_at: endsAt, grace_period_ends_at: null, daily_limit_override: null });
+      await route.fulfill({ response, json: Array.isArray(body) ? body.map((row) => asTrial(row as Record<string, unknown>)) : asTrial(body as Record<string, unknown>) });
+    } catch {
+      await route.abort().catch(() => undefined);
+    }
+  });
+  for (const table of ['subscriptions', 'app_store_subscriptions']) {
+    await trialPage.route(`${REST}/${table}*`, (route) => route.fulfill({ status: 200, contentType: 'application/json', json: [] }));
+  }
+  await trialPage.goto(`${ORIGIN}/`);
+  await trialPage.getByTestId('trial-banner').waitFor({ timeout: 30_000 });
+  await settle(trialPage);
+  await shoot(trialPage, `${prefix}-trial-banner`);
+  await trialPage.getByTestId('trial-banner-dismiss').click();
+  await trialPage.getByTestId('trial-banner').waitFor({ state: 'detached' });
+  shots += 1;
+  await trialPage.unrouteAll({ behavior: 'ignoreErrors' });
+  await trial.close();
+
+  // The stored session's access token has expired and the server refuses its refresh token.
+  const expired = await newContext(browser, { ...options, storageState: session });
+  await expired.addInitScript(() => {
+    for (const key of Object.keys(localStorage)) {
+      if (!key.includes('auth')) continue;
+      try {
+        const value = JSON.parse(localStorage.getItem(key) ?? 'null') as { expires_at?: number } | null;
+        if (value && typeof value === 'object' && 'expires_at' in value) localStorage.setItem(key, JSON.stringify({ ...value, expires_at: 1 }));
+      } catch {
+        // Not a session.
+      }
+    }
+  });
+  await expired.route(`https://${STAGING_HOST}/auth/v1/token*`, (route) =>
+    route.fulfill({ status: 400, contentType: 'application/json', json: { error: 'invalid_grant', error_description: 'Invalid Refresh Token: Refresh Token Not Found', code: 'refresh_token_not_found' } }),
+  );
+  // The refused refresh is the point of this page, so its 400 is not reported as a problem.
+  const expiredPage = await expired.newPage();
+  await expiredPage.goto(`${ORIGIN}/`);
+  await expiredPage.getByTestId('session-expired').waitFor({ timeout: 45_000 });
+  await shoot(expiredPage, `${prefix}-session-expired`);
+  shots += 1;
+  await expiredPage.unrouteAll({ behavior: 'ignoreErrors' });
+  await expired.unrouteAll({ behavior: 'ignoreErrors' });
+  await expired.close();
+  return shots;
+}
+
 async function shootEmptyDebate(page: Page, prefix: string) {
   await page.route(`${REST}/current_debates*`, (route) =>
     route.fulfill({ status: 200, contentType: 'application/json', json: [] }),
@@ -1826,16 +2166,31 @@ async function shootModelPicker(context: BrowserContext, prefix: string, languag
 }
 
 /** Shoots whatever page of the group is open when it fails, and names the group in the error. */
+/**
+ * KEEP_GOING=1 records a failed group and runs the rest, so one flaky step
+ * does not cost every later shot; the run still exits with 1 and lists them.
+ */
+const KEEP_GOING = process.env.KEEP_GOING === '1';
+const groupFailures: string[] = [];
+
+function groupFailed(label: string, error: unknown): number {
+  const message = `${label}: ${(error instanceof Error ? error.message : String(error)).split('\n')[0]}`;
+  if (!KEEP_GOING) throw new Error(message);
+  console.error(`FAILED ${message}`);
+  groupFailures.push(message);
+  return 0;
+}
+
 function failedIn(context: BrowserContext, prefix: string, group: string) {
-  return async (error: unknown) => {
+  return async (error: unknown): Promise<number> => {
     const page = context.pages().at(-1);
     if (page) await shoot(page, `${prefix}-failed-${group}`).catch(() => undefined);
-    throw new Error(`${group}: ${error instanceof Error ? error.message : String(error)}`);
+    return groupFailed(`${prefix} ${group}`, error);
   };
 }
 
 async function signIn(browser: Browser, problems: string[]): Promise<StorageState> {
-  const context = await browser.newContext({ ...DEVICES.iphone, locale: LOCALES.en });
+  const context = await newContext(browser, { ...DEVICES.iphone, locale: LOCALES.en });
   const page = await context.newPage();
   watchErrors(page, problems, 'sign-in');
   const authHosts: string[] = [];
@@ -1872,7 +2227,7 @@ async function checkOfflineColdStart(browser: Browser, state: StorageState, prob
   session.expires_at = Math.floor(Date.now() / 1000) - 60;
   entry.value = JSON.stringify(session);
 
-  const context = await browser.newContext({ ...DEVICES.iphone, locale: LOCALES.en, storageState: expired });
+  const context = await newContext(browser, { ...DEVICES.iphone, locale: LOCALES.en, storageState: expired });
   const page = await context.newPage();
   // Offline for the backend only; the page itself still loads from the local server.
   const toBackend = (url: URL) => url.host === STAGING_HOST;
@@ -1961,7 +2316,7 @@ async function openFlowchart(page: Page) {
  */
 async function shootOfflineScreens(browser: Browser, state: StorageState, problems: string[], run: (typeof OFFLINE_RUNS)[number], isolation: boolean) {
   const { prefix, scheme, language } = run;
-  const context = await browser.newContext({ ...DEVICES.iphone, colorScheme: scheme, locale: LOCALES[language], storageState: state });
+  const context = await newContext(browser, { ...DEVICES.iphone, colorScheme: scheme, locale: LOCALES[language], storageState: state });
   const page = await context.newPage();
   try {
     return await readOffline(context, page, problems, run, isolation);
@@ -2130,7 +2485,7 @@ async function main() {
         for (const [language, locale] of Object.entries(LOCALES)) {
           const prefix = `${device}-${scheme}-${language}`;
           if (ONLY.length > 0 && !ONLY.some((only) => prefix.startsWith(only))) continue;
-          const signedOut = await browser.newContext({ ...options, colorScheme: scheme, locale });
+          const signedOut = await newContext(browser, { ...options, colorScheme: scheme, locale });
           const page = await signedOut.newPage();
           watchErrors(page, problems, prefix);
           await page.goto(`${ORIGIN}/sign-in`);
@@ -2145,14 +2500,14 @@ async function main() {
           await signedOut.close();
 
           if (!session) continue;
-          const signedIn = await browser.newContext({ ...options, colorScheme: scheme, locale, storageState: session });
+          const signedIn = await newContext(browser, { ...options, colorScheme: scheme, locale, storageState: session });
           const tabPage = await signedIn.newPage();
           watchErrors(tabPage, problems, `${prefix} signed in`);
           await pinSettings(tabPage, language);
           if (want('debate')) {
             await shootDebateScreens(tabPage, prefix).catch(async (error: unknown) => {
               await shoot(tabPage, `${prefix}-failed`);
-              throw error;
+              groupFailed(prefix, error);
             });
             shots += 10;
           }
@@ -2163,14 +2518,14 @@ async function main() {
           if (want('library')) {
             await shootLibraryScreens(tabPage, prefix, problems).catch(async (error: unknown) => {
               await shoot(tabPage, `${prefix}-failed`);
-              throw error;
+              groupFailed(prefix, error);
             });
             shots += 14;
           }
           for (const [name, route] of Object.entries(SIGNED_IN_ROUTES)) {
             if (!want(name)) continue;
             await tabPage.goto(`${ORIGIN}${route}`);
-            await tabPage.getByRole('tablist').first().waitFor();
+            await appShell(tabPage).waitFor();
             if (name === 'you') await tabPage.getByTestId('subscription-tier').waitFor({ timeout: 30_000 });
             await settle(tabPage);
             await shoot(tabPage, `${prefix}-${name}`);
@@ -2192,6 +2547,16 @@ async function main() {
             await shootEmptyDebate(emptyPage, prefix);
             shots += 2;
           }
+          if (want('sidebar') && device.startsWith('ipad')) {
+            shots += await shootSidebar(signedIn, prefix, language, problems).catch(failedIn(signedIn, prefix, 'sidebar'));
+          }
+          // Each run makes one real share link on staging, so English only.
+          if (want('share') && language === 'en') {
+            shots += await shootShareLink(signedIn, prefix, language, problems).catch(failedIn(signedIn, prefix, 'share'));
+          }
+          if (want('first-run')) {
+            shots += await shootFirstRun(browser, { ...options, colorScheme: scheme, locale }, session, prefix, language, problems).catch(failedIn(signedIn, prefix, 'first-run'));
+          }
           if (want('ask')) {
             await shootAskScreens(signedIn, prefix, language, problems).catch(failedIn(signedIn, prefix, 'ask'));
             shots += 6;
@@ -2269,8 +2634,8 @@ async function main() {
   console.log(`${shots} screenshots in ${OUT}`);
   await writeFile(join(OUT, 'clipped.json'), JSON.stringify(clipped, null, 2));
   console.log(`${Object.keys(clipped).length} shots with clipped text (clipped.json)`);
-  if (problems.length > 0) {
-    console.error(problems.join('\n'));
+  if (problems.length > 0 || groupFailures.length > 0) {
+    console.error([...groupFailures, ...problems].join('\n'));
     process.exitCode = 1;
   }
 }
diff --git a/apps/mobile/src/app/(tabs)/(debate)/index.tsx b/apps/mobile/src/app/(tabs)/(debate)/index.tsx
index 9d29cf38a..7db1f34a9 100644
--- a/apps/mobile/src/app/(tabs)/(debate)/index.tsx
+++ b/apps/mobile/src/app/(tabs)/(debate)/index.tsx
@@ -1,20 +1,25 @@
 import { Link, useFocusEffect, useRouter } from 'expo-router';
 import { useCallback, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, Pressable, StyleSheet, View } from 'react-native';
+import { Pressable, StyleSheet, View } from 'react-native';
+import Animated from 'react-native-reanimated';
 
 import { AnnouncementBanner } from '@/components/announcement-banner';
+import { TrialBanner } from '@/components/trial-banner';
 import { MainActionButton, TextButton } from '@/components/buttons';
-import { Card, IconTile } from '@/components/card';
+import { Card, IconTile, ListItemIn, usePressScale } from '@/components/card';
 import { Icon } from '@/components/icon';
 import type { IconName } from '@/components/icon-paths';
 import { OneOffNotice } from '@/components/one-off-notice';
 import { PREPARE_TOOLS, prepareToolHref } from '@/components/prepare-tools';
 import { Screen } from '@/components/screen';
 import { SegmentedControl } from '@/components/segmented-control';
+import { Skeleton, SkeletonRows } from '@/components/skeleton';
 import { SOURCE_ICONS, sourceMeta } from '@/components/source-display';
 import { Text } from '@/components/text';
 import { WorkRow } from '@/components/work-row';
+import { publishCurrentDebate } from '@/lib/debate-widget';
+import { indexForSpotlight } from '@/lib/spotlight';
 import { useAuth } from '@/lib/auth';
 import { useDebates } from '@/lib/debate-context';
 import {
@@ -64,8 +69,8 @@ export default function DebateScreen() {
 
   if (status === 'loading') {
     return (
-      <Screen safeTop>
-        <ActivityIndicator style={styles.loading} accessibilityLabel={t('common.loading')} />
+      <Screen safeTop gap={0}>
+        <DebateSkeleton />
       </Screen>
     );
   }
@@ -88,6 +93,7 @@ export default function DebateScreen() {
     return (
       <Screen safeTop>
         <AnnouncementBanner announcements={announcements} />
+        <TrialBanner />
         <SwitcherPill onPress={openSwitcher} />
         <OneOffNotice />
         {/* Mirrored, so the owl points across at Start debate, as on the website's home. */}
@@ -109,6 +115,7 @@ export default function DebateScreen() {
     return (
       <Screen safeTop gap={0} wide>
         <AnnouncementBanner announcements={announcements} style={styles.banner} />
+        <TrialBanner style={styles.banner} />
         <SwitcherPill onPress={openSwitcher} />
         <OneOffNotice style={styles.notice} />
         <Text accessibilityRole="header" weight="display" style={[styles.motion, styles.motionWide]} testID="current-debate-motion">
@@ -123,6 +130,7 @@ export default function DebateScreen() {
   return (
     <Screen safeTop gap={0}>
       <AnnouncementBanner announcements={announcements} style={styles.banner} />
+      <TrialBanner style={styles.banner} />
       <SwitcherPill onPress={openSwitcher} />
       <OneOffNotice style={styles.notice} />
       <Text accessibilityRole="header" weight="display" style={styles.motion} testID="current-debate-motion">
@@ -206,6 +214,10 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
   const router = useRouter();
   const { session } = useAuth();
   const userId = session?.user.id ?? null;
+  // Read when counts land, for the Home Screen widget; not a reason to load again.
+  const { current } = useDebates();
+  const currentRef = useRef(current);
+  currentRef.current = current;
   const [view, setView] = useState<DebateSide>('pro');
   const [counts, setCounts] = useState<DebateCounts | null>(null);
   const [recent, setRecent] = useState<Record<DebateSide, DebateItem[]> | null>(null);
@@ -228,6 +240,13 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
       ]);
       if (!isCurrent()) return;
       setCounts(nextCounts);
+      const shown = currentRef.current;
+      if (shown?.id === debateId) {
+        publishCurrentDebate({ debateId, motion: shown.motion, counts: nextCounts });
+        // Spotlight finds this debate's cases (development build with expo-core-spotlight; a no-op otherwise).
+        const cases = [...pro, ...con].filter((item, index, all) => item.kind === 'case' && all.findIndex((other) => other.id === item.id) === index);
+        void indexForSpotlight('cases', cases.map((item) => ({ url: `debatelab://case/${item.id}` as const, title: item.title, description: shown.motion })));
+      }
       setRecent({ pro, con });
       setSources(nextSources?.slice(0, DASHBOARD_SOURCES) ?? null);
       setFailed(false);
@@ -252,6 +271,7 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
 
   const results = counts?.results[view];
   const items = recent?.[view] ?? null;
+  const countsLoading = counts === null && !failed;
 
   const sideAndStats = (
     <>
@@ -266,10 +286,16 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
         />
       </View>
 
-      <View style={styles.stats} testID="debate-counts">
-        <Stat value={counts?.sources} label={t('mobile.debate.statSources', { count: counts?.sources ?? 0 })} />
-        <Stat value={results} label={t('mobile.debate.statResults', { count: results ?? 0 })} />
-        <Stat value={counts?.rounds} label={t('mobile.debate.statRounds', { count: counts?.rounds ?? 0 })} />
+      {/* While the counts load (and have not failed) the row is the loading indicator, with shapes for the numbers. */}
+      <View
+        style={styles.stats}
+        testID="debate-counts"
+        accessible={countsLoading || undefined}
+        accessibilityRole={countsLoading ? 'progressbar' : undefined}
+        accessibilityLabel={countsLoading ? t('common.loading') : undefined}>
+        <Stat value={counts?.sources} loading={countsLoading} label={t('mobile.debate.statSources', { count: counts?.sources ?? 0 })} />
+        <Stat value={results} loading={countsLoading} label={t('mobile.debate.statResults', { count: results ?? 0 })} />
+        <Stat value={counts?.rounds} loading={countsLoading} label={t('mobile.debate.statRounds', { count: counts?.rounds ?? 0 })} />
       </View>
 
     </>
@@ -281,13 +307,10 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
         {t('mobile.tabs.prepare')}
       </Text>
       <View style={styles.grid}>
-        {PREPARE_TOOLS.map((tool) => (
-          <ToolTile
-            key={tool.key}
-            icon={tool.icon}
-            label={t(`nav.${tool.key}`)}
-            onPress={() => router.push(prepareToolHref(tool.key, 'debate'))}
-          />
+        {PREPARE_TOOLS.map((tool, index) => (
+          <ListItemIn key={tool.key} index={index} style={styles.tileSlot}>
+            <ToolTile icon={tool.icon} label={t(`nav.${tool.key}`)} onPress={() => router.push(prepareToolHref(tool.key, 'debate'))} />
+          </ListItemIn>
         ))}
       </View>
     </>
@@ -312,7 +335,7 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
           <TextButton label={t('common.retry')} onPress={() => void load(() => true)} />
         </Card>
       ) : items === null ? (
-        <ActivityIndicator style={styles.loading} />
+        <SkeletonRows rows={dashboard ? DASHBOARD_RECENT_LIMIT : RECENT_LIMIT} />
       ) : items.length === 0 ? (
         <Card>
           <Text tone="secondary" style={styles.body}>
@@ -322,7 +345,9 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
       ) : (
         <Card style={styles.list}>
           {items.map((item, index) => (
-            <WorkRow key={`${item.kind}-${item.id}`} item={item} first={index === 0} from="debate" onDeleted={() => void load(() => true)} />
+            <ListItemIn key={`${item.kind}-${item.id}`} index={index} layout>
+              <WorkRow item={item} first={index === 0} from="debate" onDeleted={() => void load(() => true)} />
+            </ListItemIn>
           ))}
         </Card>
       )}
@@ -341,7 +366,7 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
   }
 
   const recentSources = failed ? null : sources === null ? (
-    <ActivityIndicator style={styles.loading} />
+    <SkeletonRows rows={DASHBOARD_SOURCES} />
   ) : sources.length === 0 ? (
     <Card>
       <Text tone="secondary" style={styles.body}>
@@ -351,7 +376,9 @@ function DebateDetails({ debateId, dashboard = false }: { debateId: string; dash
   ) : (
     <Card style={styles.list}>
       {sources.map((source, index) => (
-        <RecentSource key={source.id} source={source} first={index === 0} />
+        <ListItemIn key={source.id} index={index}>
+          <RecentSource source={source} first={index === 0} />
+        </ListItemIn>
       ))}
     </Card>
   );
@@ -403,14 +430,17 @@ function RecentSource({ source, first }: { source: Source; first: boolean }) {
 function RecentSourceRow({ source, first, onPress }: { source: Source; first: boolean; onPress?: () => void }) {
   const { t } = useTranslation();
   const { colors } = useTheme();
+  const press = usePressScale();
   return (
     <Pressable
       accessibilityRole="button"
       onPress={onPress}
+      onPressIn={press.onPressIn}
+      onPressOut={press.onPressOut}
       testID="recent-source"
       style={!first ? { borderTopWidth: 1, borderTopColor: colors.line } : undefined}>
       {({ pressed }) => (
-        <View style={[styles.sourceRow, pressed && styles.pressed]}>
+        <Animated.View style={[styles.sourceRow, pressed && styles.pressed, press.style]}>
           <IconTile name={SOURCE_ICONS[source.type]} size={42} />
           <View style={styles.sourceText}>
             <Text weight="semibold" style={styles.sourceTitle} numberOfLines={2}>
@@ -421,18 +451,22 @@ function RecentSourceRow({ source, first, onPress }: { source: Source; first: bo
             </Text>
           </View>
           <Icon name="chevronRight" color={colors.tabInactive} size={20} />
-        </View>
+        </Animated.View>
       )}
     </Pressable>
   );
 }
 
-function Stat({ value, label }: { value: number | undefined; label: string }) {
+function Stat({ value, label, loading }: { value: number | undefined; label: string; loading: boolean }) {
   return (
     <View>
-      <Text weight="bold" style={styles.statValue}>
-        {value ?? '–'}
-      </Text>
+      {loading ? (
+        <Skeleton width={30} height={20} style={styles.statShape} />
+      ) : (
+        <Text weight="bold" style={styles.statValue}>
+          {value ?? '–'}
+        </Text>
+      )}
       <Text tone="faint" style={styles.statLabel}>
         {label}
       </Text>
@@ -453,9 +487,10 @@ function SparCard({ onPress }: { onPress: () => void }) {
         { backgroundColor: colors.primaryFill, borderBottomColor: colors.primaryLedge },
         pressed && styles.sparPressed,
       ]}>
-      <OwlAvatar pose="arguing" size={52} />
+      {/* Ollie is present here, so he blinks. */}
+      <OwlAvatar pose="arguing" size={52} blink />
       <View style={styles.sparText}>
-        <Text weight="display" style={styles.sparTitle}>
+        <Text accessibilityRole="header" weight="display" style={styles.sparTitle}>
           {t('mobile.debate.spar')}
         </Text>
         <Text style={styles.sparLine}>{t('sparring.format.standard')}</Text>
@@ -472,25 +507,49 @@ function SparCard({ onPress }: { onPress: () => void }) {
 // Long one-word labels (Hungarian "Folyamatábra") shrink to fit on iOS; the web preview cannot shrink text, so it truncates them.
 function ToolTile({ icon, label, onPress }: { icon: IconName; label: string; onPress: () => void }) {
   const { colors } = useTheme();
+  const press = usePressScale();
   return (
-    <Pressable
-      accessibilityRole="button"
-      onPress={onPress}
-      style={({ pressed }) => [
-        styles.tile,
-        { backgroundColor: colors.card, borderColor: colors.border },
-        pressed && styles.pressed,
-      ]}>
-      <IconTile name={icon} size={38} />
-      <Text weight="semibold" style={styles.tileLabel} numberOfLines={1} adjustsFontSizeToFit minimumFontScale={0.75}>
-        {label}
-      </Text>
+    <Pressable accessibilityRole="button" onPress={onPress} onPressIn={press.onPressIn} onPressOut={press.onPressOut}>
+      <Animated.View style={[styles.tile, { backgroundColor: colors.card, borderColor: colors.border }, press.style]}>
+        <IconTile name={icon} size={38} />
+        <Text weight="semibold" style={styles.tileLabel} numberOfLines={1} adjustsFontSizeToFit minimumFontScale={0.75}>
+          {label}
+        </Text>
+      </Animated.View>
     </Pressable>
   );
 }
 
+/**
+ * The Debate tab before the debates arrive, in the shape of the page: the switcher pill, the
+ * motion, its settings, the side toggle, the counts and the recent work. The loading indicator.
+ */
+function DebateSkeleton() {
+  const { t } = useTranslation();
+  return (
+    <View accessible accessibilityRole="progressbar" accessibilityLabel={t('common.loading')}>
+      <Skeleton width={150} height={34} round={radius.pill} style={styles.skeletonPill} />
+      <View style={styles.skeletonMotion}>
+        <Skeleton width="92%" height={26} round={8} />
+        <Skeleton width="64%" height={26} round={8} />
+      </View>
+      <Skeleton width="70%" height={14} style={styles.skeletonSettings} />
+      <Skeleton height={38} round={radius.pill} />
+      <View style={styles.stats}>
+        {[0, 1, 2].map((stat) => (
+          <View key={stat} style={styles.skeletonStat}>
+            <Skeleton width={30} height={20} />
+            <Skeleton width={58} height={12} />
+          </View>
+        ))}
+      </View>
+      <Skeleton height={96} round={radius.card} style={styles.skeletonSpar} />
+      <SkeletonRows rows={RECENT_LIMIT} />
+    </View>
+  );
+}
+
 const styles = StyleSheet.create({
-  loading: { marginTop: 32 },
   body: { fontSize: 16, lineHeight: 22 },
   pressed: { opacity: 0.7 },
   pill: {
@@ -519,6 +578,12 @@ const styles = StyleSheet.create({
   stats: { flexDirection: 'row', gap: 24, marginTop: 13, marginBottom: 15, marginHorizontal: 2 },
   statValue: { fontSize: 21, lineHeight: 26, letterSpacing: -0.2 },
   statLabel: { fontSize: 15 },
+  statShape: { marginVertical: 3 },
+  skeletonPill: { marginTop: 4 },
+  skeletonMotion: { gap: 8, marginTop: 14, marginBottom: 14 },
+  skeletonSettings: { marginBottom: 18 },
+  skeletonStat: { gap: 7 },
+  skeletonSpar: { marginBottom: 20 },
   spar: {
     borderRadius: radius.card,
     borderBottomWidth: 5,
@@ -538,9 +603,9 @@ const styles = StyleSheet.create({
   sectionRow: { flexDirection: 'row', alignItems: 'center', gap: 12, marginTop: 10, marginRight: 2 },
   sectionTitle: { flex: 1, marginTop: 0, marginBottom: 0 },
   grid: { flexDirection: 'row', flexWrap: 'wrap', gap: 10 },
+  // The grid cell is the arriving wrapper; the tile fills it and presses in inside it.
+  tileSlot: { flexGrow: 1, flexBasis: '45%' },
   tile: {
-    flexGrow: 1,
-    flexBasis: '45%',
     flexDirection: 'row',
     alignItems: 'center',
     gap: 10,
diff --git a/apps/mobile/src/app/(tabs)/(library)/library.tsx b/apps/mobile/src/app/(tabs)/(library)/library.tsx
index 59088805b..74e3da213 100644
--- a/apps/mobile/src/app/(tabs)/(library)/library.tsx
+++ b/apps/mobile/src/app/(tabs)/(library)/library.tsx
@@ -2,10 +2,10 @@ import { GENERAL_FOLDER, matchesLibrarySearch, normalizeFolder, sortLibrarySourc
 import { useFocusEffect, useRouter } from 'expo-router';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, ScrollView, StyleSheet, View, useWindowDimensions } from 'react-native';
+import { ScrollView, StyleSheet, View } from 'react-native';
 
 import { TextButton } from '@/components/buttons';
-import { Card } from '@/components/card';
+import { Card, ListItemIn } from '@/components/card';
 import { Chip } from '@/components/chip';
 import { EmptyState } from '@/components/empty-state';
 import { LibraryHeader } from '@/components/library-header';
@@ -15,6 +15,7 @@ import { OfflineNotice } from '@/components/offline-notice';
 import { OneOffNotice } from '@/components/one-off-notice';
 import { Screen } from '@/components/screen';
 import { SearchField } from '@/components/search-field';
+import { SkeletonRows } from '@/components/skeleton';
 import { folderLabel } from '@/components/source-display';
 import { SourceRow } from '@/components/source-row';
 import { SourceView } from '@/components/source-view';
@@ -24,7 +25,8 @@ import { useAuth } from '@/lib/auth';
 import { confirmDestructive, promptText } from '@/lib/confirm';
 import { useDebates } from '@/lib/debate-context';
 import { haptics } from '@/lib/haptics';
-import { LIBRARY_ROOMY_WIDTH, LIST_WIDTH, SIDEBAR_WIDTH, useLayoutClass } from '@/lib/layout';
+import { LIBRARY_ROOMY_WIDTH, LIST_WIDTH, useContentWidth, useLayoutClass } from '@/lib/layout';
+import { clearQueuedDebate, currentSourceId, 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';
@@ -32,6 +34,7 @@ import { holdPickedFile } from '@/lib/source-file';
 import { clearLibrary, createFolder, deleteFolder, fetchSources, renameFolder, subscribeSourcesChanged, type Source } from '@/lib/sources';
 import { useCopyHolder } from '@/lib/use-copy-holder';
 import { useLibraryFolders } from '@/lib/use-library-folders';
+import { useQueuedWrites } from '@/lib/use-offline-queue';
 import { useTheme } from '@/theme/use-theme';
 
 const ALL = '\u0000all';
@@ -55,20 +58,22 @@ function LibraryView({ debateId, layout }: { debateId: string | null; layout: Re
   const router = useRouter();
   const { colors } = useTheme();
   const toast = useToast();
-  const { width } = useWindowDimensions();
+  const width = useContentWidth();
   const { session } = useAuth();
   const { status } = useDebates();
   const userId = session?.user.id ?? null;
   const library = useLibrary(debateId);
   // On iPad the selection belongs to the account it was made in; signing out clears it.
   const [selected, setSelected] = useState<{ userId: string; id: string } | null>(null);
-  const shown = layout !== 'phone' && selected && selected.userId === userId ? selected.id : null;
+  // A waiting note that has synced stays open under its row's id.
+  const shown = layout !== 'phone' && selected && selected.userId === userId ? currentSourceId(library.queued, selected.id) : null;
 
   // A refresh that no longer has the open source closes the detail pane. Searching does not: `sources` is the full list.
+  // A note that has just synced counts until the list is read again.
   useEffect(() => {
     if (!shown || library.sources === null) return;
-    if (openRowId(shown, library.sources) === null) setSelected(null);
-  }, [shown, library.sources]);
+    if (openRowId(shown, [...library.sources, ...library.queued.synced.values()]) === null) setSelected(null);
+  }, [shown, library.sources, library.queued]);
 
   const onAdd = async (kind: AddSourceKind) => {
     if (kind === 'link') return router.push('/add-link');
@@ -98,7 +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 {
-      await clearLibrary(userId, debateId);
+      // Notes and changes still waiting to sync would come back after the clear; they go once it succeeds.
+      await clearQueuedDebate(userId, debateId, () => clearLibrary(userId, debateId));
       setSelected(null);
       library.setSources([]);
       toast({ tone: 'success', title: t('common.deleted'), message: t('libraryPage.clearSuccess') });
@@ -136,7 +142,7 @@ function LibraryView({ debateId, layout }: { debateId: string | null; layout: Re
     </Card>
   ) : null;
   const body = debateId ? (
-    <LibraryBody library={library} selectedId={shown} onSelect={layout === 'phone' || !userId ? undefined : (source) => setSelected({ userId, id: source.id })} />
+    <LibraryBody library={library} selectedId={shown} onSelect={layout === 'phone' || !userId ? undefined : (source) => setSelected({ userId, id: source.id })} onRemoved={(id) => setSelected((current) => (current && currentSourceId(library.queued, current.id) === id ? null : current))} />
   ) : null;
 
   if (layout === 'phone') {
@@ -145,14 +151,14 @@ function LibraryView({ debateId, layout }: { debateId: string | null; layout: Re
         {header}
         {/* New sources still go to the Current Debate in one-off mode, as on the website, so this only says the mode is on. */}
         <OneOffNotice message="debate.oneOffActive" />
-        {status === 'loading' ? <ActivityIndicator style={styles.loading} /> : null}
+        {status === 'loading' && !debateId ? <SkeletonRows rows={4} /> : null}
         {noDebate}
         {body}
       </Screen>
     );
   }
 
-  const available = width - (layout === 'wide' ? SIDEBAR_WIDTH : 0);
+  const available = width;
   // With nothing open the list takes the whole width, as the website's Library does; an open
   // source splits it, and the list keeps 40% (at least its usual width) so titles stay readable.
   const listWidth = Math.max(available >= LIBRARY_ROOMY_WIDTH ? LIST_WIDTH.libraryRoomy : LIST_WIDTH.library, Math.round(available * 0.4));
@@ -161,17 +167,22 @@ function LibraryView({ debateId, layout }: { debateId: string | null; layout: Re
       <ScrollView
         style={shown ? [styles.listPane, { width: listWidth, borderRightColor: colors.line }] : styles.listPaneFull}
         contentInsetAdjustmentBehavior="automatic"
+        automaticallyAdjustKeyboardInsets
+        keyboardShouldPersistTaps="handled"
+        keyboardDismissMode="interactive"
         contentContainerStyle={[styles.listContent, !shown && styles.listContentFull]}>
         <OfflineNotice />
         {header}
         <OneOffNotice message="debate.oneOffActive" />
-        {status === 'loading' ? <ActivityIndicator style={styles.loading} /> : null}
+        {status === 'loading' && !debateId ? <SkeletonRows rows={4} /> : null}
         {noDebate}
         {body}
       </ScrollView>
-      {shown && userId ? (
-        <ScrollView style={styles.detailPane} contentInsetAdjustmentBehavior="automatic" contentContainerStyle={styles.detailContent} testID="source-sheet">
-          <SourceView key={`${userId}:${debateId}:${shown}`} id={shown} onRemoved={() => setSelected(null)} />
+      {shown && selected && userId ? (
+        <ScrollView style={styles.detailPane} contentInsetAdjustmentBehavior="automatic" automaticallyAdjustKeyboardInsets keyboardShouldPersistTaps="handled" keyboardDismissMode="interactive" contentContainerStyle={styles.detailContent} testID="source-sheet">
+          {/* Keyed by the id that was opened: a note that syncs swaps its local id for the row's, and the
+              view follows that itself, so an edit in progress survives the sync. */}
+          <SourceView key={`${userId}:${debateId}:${selected.id}`} id={selected.id} onRemoved={() => setSelected((current) => (current?.id === selected.id ? null : current))} />
         </ScrollView>
       ) : null}
     </View>
@@ -184,8 +195,9 @@ type Library = ReturnType<typeof useLibrary>;
 function useLibrary(debateId: string | null) {
   const { session } = useAuth();
   const userId = session?.user.id ?? null;
-  const [sources, setSources] = useState<Source[] | null>(null);
+  const [fetched, setSources] = useState<Source[] | null>(null);
   const [failed, setFailed] = useState(false);
+  const queued = useQueuedWrites(userId);
   const [query, setQuery] = useState('');
   const [filter, setFilter] = useState<SourceTypeFilter>('all');
   const [sort, setSort] = useState<LibrarySort>('smart');
@@ -219,6 +231,21 @@ function useLibrary(debateId: string | null) {
   );
   useEffect(() => subscribeSourcesChanged(() => void load()), [load]);
 
+  // Changes that wait for the connection show on top of what was read, online or from the saved copy.
+  const sources = useMemo(() => (fetched && debateId ? withQueuedWrites(queued, debateId, fetched) : fetched), [fetched, queued, debateId]);
+  const waiting = useMemo(() => waitingSourceIds(queued), [queued]);
+  // A note that syncs takes its row's place at once, before the list is read again.
+  const synced = useRef(new Set(queued.synced.keys()));
+  useEffect(() => {
+    for (const [tempId, source] of queued.synced) {
+      if (synced.current.has(tempId)) continue;
+      synced.current.add(tempId);
+      if (source.debateId !== debateId) continue;
+      // The list may hold the note under its temporary id (from the saved copy); the row replaces it, once.
+      setSources((previous) => previous && [source, ...previous.filter((item) => item.id !== tempId && item.id !== source.id)]);
+    }
+  }, [queued.synced, debateId]);
+
   // A folder that no longer exists here (renamed or deleted elsewhere, or only another debate's)
   // shows all folders again. Checked only when the folder list reloads: a folder just created or
   // renamed here is chosen before its reload lands, and the reload then lists it.
@@ -242,16 +269,16 @@ function useLibrary(debateId: string | null) {
     setSources((previous) => previous?.map((source) => (ids.includes(source.id) ? { ...source, ...change } : source)) ?? previous);
   }, []);
 
-  return { userId, debateId: debateId!, sources, setSources, failed, load, query, setQuery, filter, setFilter, sort, setSort, folder, setFolder, folders, inFolder, visible, patch };
+  return { userId, debateId: debateId!, sources, setSources, queued, waiting, failed, load, query, setQuery, filter, setFilter, sort, setSort, folder, setFolder, folders, inFolder, visible, patch };
 }
 
-function LibraryBody({ library, selectedId, onSelect }: { library: Library; selectedId: string | null; onSelect?: (source: Source) => void }) {
+function LibraryBody({ library, selectedId, onSelect, onRemoved }: { library: Library; selectedId: string | null; onSelect?: (source: Source) => void; onRemoved?: (id: string) => void }) {
   const { t } = useTranslation();
   const router = useRouter();
   const toast = useToast();
   const actions = useSourceActions();
   const activeWrites = useRef({ seq: 0, latest: new Map<string, number>(), confirmed: new Map<string, boolean>() });
-  const { sources, failed, folders, folder, inFolder, visible, patch, userId, debateId } = library;
+  const { sources, failed, folders, folder, inFolder, visible, patch, userId, debateId, waiting } = library;
 
   if (failed && !sources) {
     return (
@@ -263,7 +290,7 @@ function LibraryBody({ library, selectedId, onSelect }: { library: Library; sele
       </Card>
     );
   }
-  if (!sources) return <ActivityIndicator style={styles.loading} accessibilityRole="progressbar" />;
+  if (!sources) return <SkeletonRows rows={5} />;
 
   const active = sources.filter((source) => source.isActive).length;
   const chipFolders = Array.from(new Set([...folders, ...sources.map((source) => source.folder)])).sort();
@@ -295,6 +322,9 @@ function LibraryBody({ library, selectedId, onSelect }: { library: Library; sele
   const remove = async (source: Source) => {
     const removed = await actions.remove(source);
     if (removed) library.setSources((previous) => previous?.filter((item) => item.id !== source.id) ?? previous);
+    // Deleting the source open beside the list closes it, as its own Delete does. The parent checks
+    // the selection when the delete lands, so a source opened meanwhile stays open.
+    if (removed) onRemoved?.(source.id);
     return removed;
   };
 
@@ -370,29 +400,31 @@ function LibraryBody({ library, selectedId, onSelect }: { library: Library; sele
       ) : (
         <Card style={styles.list}>
           {visible.map((source, index) => (
-            <SourceRow
-              key={source.id}
-              source={source}
-              folders={chipFolders}
-              first={index === 0}
-              selected={selectedId === source.id}
-              selectInstead={Boolean(onSelect)}
-              showFolder={folder === ALL}
-              compact={Boolean(selectedId)}
-              actions={{
-                onOpen: () => (onSelect ? onSelect(source) : router.push({ pathname: '/source/[id]', params: { id: source.id } })),
-                onToggle: (isActive) => void toggle([source], isActive),
-                onDelete: () => remove(source),
-                onCopy: () => void actions.copy(source),
-                onShare: () => actions.share(source),
-                onMove: (target) => {
-                  patch([source.id], { folder: target });
-                  void actions.move(source, target).then((moved) => {
-                    if (!moved) patch([source.id], { folder: source.folder });
-                  });
-                },
-              }}
-            />
+            <ListItemIn key={source.id} index={index} layout>
+              <SourceRow
+                source={source}
+                folders={chipFolders}
+                first={index === 0}
+                selected={selectedId === source.id}
+                selectInstead={Boolean(onSelect)}
+                showFolder={folder === ALL}
+                compact={Boolean(selectedId)}
+                pending={waiting.has(source.id)}
+                actions={{
+                  onOpen: () => (onSelect ? onSelect(source) : router.push({ pathname: '/source/[id]', params: { id: source.id } })),
+                  onToggle: (isActive) => void toggle([source], isActive),
+                  onDelete: () => remove(source),
+                  onCopy: () => void actions.copy(source),
+                  onShare: () => actions.share(source),
+                  onMove: (target) => {
+                    patch([source.id], { folder: target });
+                    void actions.move(source, target).then((moved) => {
+                      if (!moved) patch([source.id], { folder: source.folder });
+                    });
+                  },
+                }}
+              />
+            </ListItemIn>
           ))}
         </Card>
       )}
@@ -401,7 +433,6 @@ function LibraryBody({ library, selectedId, onSelect }: { library: Library; sele
 }
 
 const styles = StyleSheet.create({
-  loading: { marginTop: 32 },
   body: { fontSize: 15, lineHeight: 21 },
   summary: { fontSize: 14.5, marginHorizontal: 2, marginTop: -6 },
   chipRow: { marginHorizontal: -20, flexGrow: 0 },
diff --git a/apps/mobile/src/app/(tabs)/(practice)/practice.tsx b/apps/mobile/src/app/(tabs)/(practice)/practice.tsx
index b5f18de0b..1fb2a71e2 100644
--- a/apps/mobile/src/app/(tabs)/(practice)/practice.tsx
+++ b/apps/mobile/src/app/(tabs)/(practice)/practice.tsx
@@ -1,10 +1,12 @@
 import { useFocusEffect, useRouter, type Href } from 'expo-router';
 import { useCallback, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Pressable, StyleSheet, View } from 'react-native';
+import { StyleSheet, View } from 'react-native';
 
-import { Card, IconTile } from '@/components/card';
+import { Card, IconTile, ListItemIn } from '@/components/card';
+import { EmptyState } from '@/components/empty-state';
 import { Icon } from '@/components/icon';
+import { PressScale } from '@/components/press-scale';
 import { PRACTICE_TOOLS, type PracticeTool } from '@/components/practice-tools';
 import { ScreenTitle } from '@/components/screen-title';
 import { Screen } from '@/components/screen';
@@ -81,23 +83,20 @@ export default function PracticeScreen() {
       <ScreenTitle title={t('mobile.tabs.practice')} />
       <Card style={styles.list}>
         {PRACTICE_TOOLS.map((tool, index) => (
-          <Pressable
-            key={tool.key}
-            accessibilityRole="button"
-            onPress={() => router.push(TOOL_ROUTES[tool.key])}
-            testID={`practice-tool-${tool.key}`}
-            style={({ pressed }) => [styles.row, index > 0 && { borderTopWidth: 1, borderTopColor: colors.line }, pressed && styles.pressed]}>
-            <IconTile name={tool.icon} size={42} />
-            <View style={styles.rowText}>
-              <Text weight="semibold" style={styles.rowTitle}>
-                {t(`nav.${tool.key}`)}
-              </Text>
-              <Text tone="faint" style={styles.rowMeta} numberOfLines={1}>
-                {t(`navDesc.${tool.key}`)}
-              </Text>
-            </View>
-            <Icon name="chevronRight" color={colors.tabInactive} size={20} />
-          </Pressable>
+          <ListItemIn key={tool.key} index={index} style={index > 0 && { borderTopWidth: 1, borderTopColor: colors.line }}>
+            <PressScale accessibilityRole="button" onPress={() => router.push(TOOL_ROUTES[tool.key])} testID={`practice-tool-${tool.key}`} style={styles.row}>
+              <IconTile name={tool.icon} size={42} />
+              <View style={styles.rowText}>
+                <Text weight="semibold" style={styles.rowTitle}>
+                  {t(`nav.${tool.key}`)}
+                </Text>
+                <Text tone="faint" style={styles.rowMeta} numberOfLines={1}>
+                  {t(`navDesc.${tool.key}`)}
+                </Text>
+              </View>
+              <Icon name="chevronRight" color={colors.tabInactive} size={20} />
+            </PressScale>
+          </ListItemIn>
         ))}
       </Card>
 
@@ -114,21 +113,18 @@ export default function PracticeScreen() {
               </Text>
             </Card>
           ) : items.length === 0 ? (
-            <Card>
-              <Text tone="secondary" style={styles.body}>
-                {t('historyPage.emptySparringDesc')}
-              </Text>
-            </Card>
+            <EmptyState pose="arguing" title={t('historyPage.emptySparring')} description={t('historyPage.emptySparringDesc')} />
           ) : (
             <Card style={styles.list}>
               {items.map((round, index) => (
-                <WorkRow
-                  key={round.id}
-                  item={{ id: round.id, kind: 'sparring', title: round.motion, createdAt: round.updatedAt }}
-                  first={index === 0}
-                  from="practice"
-                  onDeleted={() => void load()}
-                />
+                <ListItemIn key={round.id} index={index} layout>
+                  <WorkRow
+                    item={{ id: round.id, kind: 'sparring', title: round.motion, createdAt: round.updatedAt }}
+                    first={index === 0}
+                    from="practice"
+                    onDeleted={() => void load()}
+                  />
+                </ListItemIn>
               ))}
             </Card>
           )}
@@ -144,7 +140,6 @@ const styles = StyleSheet.create({
   rowText: { flex: 1, gap: 2 },
   rowTitle: { fontSize: 16 },
   rowMeta: { fontSize: 14 },
-  pressed: { opacity: 0.7 },
   section: { fontSize: 20, lineHeight: 26, marginTop: 6 },
   body: { fontSize: 15.5, lineHeight: 22 },
 });
diff --git a/apps/mobile/src/app/(tabs)/(prepare)/prepare.tsx b/apps/mobile/src/app/(tabs)/(prepare)/prepare.tsx
index 3ceece427..5a2cde705 100644
--- a/apps/mobile/src/app/(tabs)/(prepare)/prepare.tsx
+++ b/apps/mobile/src/app/(tabs)/(prepare)/prepare.tsx
@@ -1,15 +1,17 @@
 import { useFocusEffect, useRouter } from 'expo-router';
 import { useCallback, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, Pressable, StyleSheet, View } from 'react-native';
+import { StyleSheet, View } from 'react-native';
 
 import { TextButton } from '@/components/buttons';
-import { Card, IconTile } from '@/components/card';
+import { Card, IconTile, ListItemIn } from '@/components/card';
 import { Icon } from '@/components/icon';
 import { OneOffNotice } from '@/components/one-off-notice';
+import { PressScale } from '@/components/press-scale';
 import { PREPARE_TOOLS, prepareToolHref, type PrepareTool } from '@/components/prepare-tools';
 import { Screen } from '@/components/screen';
 import { ScreenTitle } from '@/components/screen-title';
+import { SkeletonRows } from '@/components/skeleton';
 import { Text } from '@/components/text';
 import { WorkRow } from '@/components/work-row';
 import { useAuth } from '@/lib/auth';
@@ -74,23 +76,20 @@ export default function PrepareScreen() {
       <OneOffNotice />
       <Card style={styles.list}>
         {PREPARE_TOOLS.map((tool, index) => (
-          <Pressable
-            key={tool.key}
-            accessibilityRole="button"
-            onPress={() => openTool(tool.key)}
-            testID={`prepare-tool-${tool.key}`}
-            style={({ pressed }) => [styles.row, index > 0 && { borderTopWidth: 1, borderTopColor: colors.line }, pressed && styles.pressed]}>
-            <IconTile name={tool.icon} size={42} />
-            <View style={styles.rowText}>
-              <Text weight="semibold" style={styles.rowTitle}>
-                {t(`nav.${tool.key}`)}
-              </Text>
-              <Text tone="faint" style={styles.rowMeta} numberOfLines={1}>
-                {t(`navDesc.${tool.key}`)}
-              </Text>
-            </View>
-            <Icon name="chevronRight" color={colors.tabInactive} size={20} />
-          </Pressable>
+          <ListItemIn key={tool.key} index={index} style={index > 0 && { borderTopWidth: 1, borderTopColor: colors.line }}>
+            <PressScale accessibilityRole="button" onPress={() => openTool(tool.key)} testID={`prepare-tool-${tool.key}`} style={styles.row}>
+              <IconTile name={tool.icon} size={42} />
+              <View style={styles.rowText}>
+                <Text weight="semibold" style={styles.rowTitle}>
+                  {t(`nav.${tool.key}`)}
+                </Text>
+                <Text tone="faint" style={styles.rowMeta} numberOfLines={1}>
+                  {t(`navDesc.${tool.key}`)}
+                </Text>
+              </View>
+              <Icon name="chevronRight" color={colors.tabInactive} size={20} />
+            </PressScale>
+          </ListItemIn>
         ))}
       </Card>
 
@@ -110,7 +109,7 @@ export default function PrepareScreen() {
           <TextButton label={t('common.retry')} onPress={() => void load()} />
         </Card>
       ) : items === null ? (
-        <ActivityIndicator style={styles.loading} accessibilityRole="progressbar" />
+        <SkeletonRows rows={3} />
       ) : items.length === 0 ? (
         <Card>
           <Text tone="secondary" style={styles.body}>
@@ -120,7 +119,9 @@ export default function PrepareScreen() {
       ) : (
         <Card style={styles.list}>
           {items.map((item, index) => (
-            <WorkRow key={`${item.kind}-${item.id}`} item={item} first={index === 0} from="prepare" onDeleted={() => void load()} />
+            <ListItemIn key={`${item.kind}-${item.id}`} index={index} layout>
+              <WorkRow item={item} first={index === 0} from="prepare" onDeleted={() => void load()} />
+            </ListItemIn>
           ))}
         </Card>
       )}
@@ -134,8 +135,6 @@ const styles = StyleSheet.create({
   rowText: { flex: 1, gap: 2 },
   rowTitle: { fontSize: 16 },
   rowMeta: { fontSize: 14 },
-  pressed: { opacity: 0.7 },
   section: { fontSize: 18.5, lineHeight: 24, letterSpacing: -0.2, marginTop: 8, marginHorizontal: 2 },
   body: { fontSize: 15.5, lineHeight: 21 },
-  loading: { marginTop: 16 },
 });
diff --git a/apps/mobile/src/app/(tabs)/(you)/you.tsx b/apps/mobile/src/app/(tabs)/(you)/you.tsx
index f64d3e61a..1a068ad6a 100644
--- a/apps/mobile/src/app/(tabs)/(you)/you.tsx
+++ b/apps/mobile/src/app/(tabs)/(you)/you.tsx
@@ -5,16 +5,18 @@ import * as WebBrowser from 'expo-web-browser';
 import type { TFunction } from 'i18next';
 import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, AppState, Linking, Pressable, StyleSheet, View } from 'react-native';
+import { ActivityIndicator, AppState, Linking, Pressable, StyleSheet, View, type PressableProps } from 'react-native';
+import Animated from 'react-native-reanimated';
 
 import { TextButton } from '@/components/buttons';
-import { Card, IconTile } from '@/components/card';
+import { Card, IconTile, usePressScale } from '@/components/card';
 import { SwitchRow } from '@/components/form-rows';
 import { Icon } from '@/components/icon';
 import type { IconName } from '@/components/icon-paths';
 import { ScreenTitle } from '@/components/screen-title';
 import { Screen } from '@/components/screen';
 import { SegmentedControl } from '@/components/segmented-control';
+import { Skeleton } from '@/components/skeleton';
 import { Text } from '@/components/text';
 import { exportAccountData } from '@/lib/account';
 import { useAuth } from '@/lib/auth';
@@ -126,11 +128,10 @@ export default function YouScreen() {
       <SubscriptionCard userId={session?.user.id} />
 
       <Card style={styles.list}>
-        <Pressable
+        <PressRow
           accessibilityRole="button"
           onPress={() => router.push({ pathname: '/history', params: { from: 'you' } })}
-          testID="you-history"
-          style={({ pressed }) => [styles.row, pressed && styles.pressed]}>
+          testID="you-history">
           <IconTile name="history" />
           <View style={styles.rowText}>
             <Text weight="semibold" style={styles.rowTitle}>
@@ -141,7 +142,7 @@ export default function YouScreen() {
             </Text>
           </View>
           <Icon name="chevronRight" color={colors.tabInactive} size={20} />
-        </Pressable>
+        </PressRow>
       </Card>
 
       <Text accessibilityRole="header" weight="bold" tone="heading" style={styles.section}>
@@ -204,13 +205,13 @@ export default function YouScreen() {
             ) : null}
           </View>
         </View>
-        <Pressable
+        <PressRow
           accessibilityRole="button"
           accessibilityState={{ busy: exporting }}
           disabled={exporting}
           onPress={() => void download()}
           testID="you-download-data"
-          style={({ pressed }) => [styles.row, { borderTopWidth: 1, borderTopColor: colors.line }, pressed && styles.pressed]}>
+          divider>
           <IconTile name="download" />
           <View style={styles.rowText}>
             <Text weight="semibold" style={styles.rowTitle}>
@@ -220,19 +221,16 @@ export default function YouScreen() {
               {t('settings.yourDataDesc')}
             </Text>
           </View>
+          {/* Busy inside its own row, so it keeps the spinner. */}
           {exporting ? <ActivityIndicator /> : null}
-        </Pressable>
+        </PressRow>
       </Card>
 
       <Text accessibilityRole="header" weight="bold" tone="heading" style={styles.section}>
         {t('settings.dangerZone')}
       </Text>
       <Card style={styles.list}>
-        <Pressable
-          accessibilityRole="button"
-          onPress={() => router.push('/delete-data')}
-          testID="you-delete-data"
-          style={({ pressed }) => [styles.row, pressed && styles.pressed]}>
+        <PressRow accessibilityRole="button" onPress={() => router.push('/delete-data')} testID="you-delete-data">
           <View style={styles.rowText}>
             <Text weight="semibold" style={[styles.rowTitle, { color: colors.destructive }]}>
               {t('settings.deleteAllData')}
@@ -242,11 +240,8 @@ export default function YouScreen() {
             </Text>
           </View>
           <Icon name="chevronRight" color={colors.tabInactive} size={20} />
-        </Pressable>
-        <Pressable
-          accessibilityRole="button"
-          onPress={() => router.push('/delete-account')}
-          style={({ pressed }) => [styles.row, { borderTopWidth: 1, borderTopColor: colors.line }, pressed && styles.pressed]}>
+        </PressRow>
+        <PressRow accessibilityRole="button" onPress={() => router.push('/delete-account')} divider>
           <View style={styles.rowText}>
             <Text weight="semibold" style={[styles.rowTitle, { color: colors.destructive }]}>
               {t('settings.deleteAccount')}
@@ -256,7 +251,7 @@ export default function YouScreen() {
             </Text>
           </View>
           <Icon name="chevronRight" color={colors.tabInactive} size={20} />
-        </Pressable>
+        </PressRow>
       </Card>
 
       <Card style={styles.list}>
@@ -273,15 +268,23 @@ export default function YouScreen() {
 function LinkRow({ icon, label, url, first }: { icon: IconName; label: string; url: string; first?: boolean }) {
   const { colors } = useTheme();
   return (
-    <Pressable
-      accessibilityRole="link"
-      onPress={() => void WebBrowser.openBrowserAsync(url)}
-      style={({ pressed }) => [styles.row, !first && { borderTopWidth: 1, borderTopColor: colors.line }, pressed && styles.pressed]}>
+    <PressRow accessibilityRole="link" onPress={() => void WebBrowser.openBrowserAsync(url)} divider={!first}>
       <IconTile name={icon} />
       <Text weight="semibold" style={[styles.rowTitle, styles.rowText]}>
         {label}
       </Text>
       <Icon name="externalLink" color={colors.tabInactive} size={19} />
+    </PressRow>
+  );
+}
+
+/** A row in a card that presses in under the finger; its divider stays put. */
+function PressRow({ divider = false, children, ...props }: Omit<PressableProps, 'style' | 'children'> & { divider?: boolean; children: ReactNode }) {
+  const { colors } = useTheme();
+  const press = usePressScale();
+  return (
+    <Pressable {...props} onPressIn={press.onPressIn} onPressOut={press.onPressOut} style={divider ? { borderTopWidth: 1, borderTopColor: colors.line } : undefined}>
+      {({ pressed }) => <Animated.View style={[styles.row, pressed && styles.pressed, press.style]}>{children}</Animated.View>}
     </Pressable>
   );
 }
@@ -426,11 +429,10 @@ function SubscriptionCard({ userId }: { userId: string | undefined }) {
           <TextButton label={t('common.retry')} onPress={() => void load(() => true)} />
         </>
       ) : !subscription ? (
-        <View style={styles.loadingRow} accessibilityRole="progressbar">
-          <ActivityIndicator />
-          <Text tone="secondary" style={styles.small}>
-            {t('settings.loading')}
-          </Text>
+        // The plan's lines loading in their own shape; "Loading" is what VoiceOver reads.
+        <View accessible accessibilityRole="progressbar" accessibilityLabel={t('settings.loading')} style={styles.planBody}>
+          <Skeleton width="46%" height={16} style={styles.planShape} />
+          <Skeleton width="88%" height={12} style={styles.planShape} />
         </View>
       ) : (
         <View style={styles.planBody}>
@@ -460,7 +462,7 @@ const styles = StyleSheet.create({
   planTitle: { flex: 1, fontSize: 17 },
   planBody: { gap: 4 },
   usage: { fontSize: 16 },
-  loadingRow: { flexDirection: 'row', alignItems: 'center', gap: 10 },
+  planShape: { marginVertical: 3 },
   badge: { alignSelf: 'flex-start', flexDirection: 'row', alignItems: 'center', gap: 4, borderRadius: 999, borderWidth: 1, paddingHorizontal: 10, paddingVertical: 3 },
   badgeText: { fontSize: 13 },
   setting: { gap: 7 },
diff --git a/apps/mobile/src/app/(tabs)/_layout.tsx b/apps/mobile/src/app/(tabs)/_layout.tsx
index d6c75f96e..380678a2c 100644
--- a/apps/mobile/src/app/(tabs)/_layout.tsx
+++ b/apps/mobile/src/app/(tabs)/_layout.tsx
@@ -1,6 +1,9 @@
 import AppTabs from '@/components/app-tabs';
 import { useInactiveDebateCheck } from '@/lib/use-inactive-debate-check';
 
+// Tabs opened beneath a linked screen (the root layout's anchor) start on the Debate tab.
+export const unstable_settings = { anchor: '(debate)' };
+
 export default function TabsLayout() {
   useInactiveDebateCheck();
   return <AppTabs />;
diff --git a/apps/mobile/src/app/+native-intent.tsx b/apps/mobile/src/app/+native-intent.tsx
new file mode 100644
index 000000000..84d069642
--- /dev/null
+++ b/apps/mobile/src/app/+native-intent.tsx
@@ -0,0 +1,18 @@
+import { appPathForUrl } from '@/lib/deep-links';
+
+/**
+ * Every URL the system hands the app passes here first (Expo Router's native
+ * intent). Website links (universal links, once Associated Domains is set up)
+ * become app routes: https://debateowl.com/share/<code> opens the shared item,
+ * /app/<page> the matching tool. The app's own scheme (debatelab://), Expo Go's
+ * exp:// and a plain launch pass through unchanged. Any other web address opens
+ * the Debate tab, never a route taken from it.
+ */
+export function redirectSystemPath({ path }: { path: string; initial: boolean }): string {
+  try {
+    if (!/^https?:/i.test(path)) return path;
+    return appPathForUrl(path) ?? '/';
+  } catch {
+    return '/';
+  }
+}
diff --git a/apps/mobile/src/app/_layout.tsx b/apps/mobile/src/app/_layout.tsx
index 70454b13a..0e4a3ebbf 100644
--- a/apps/mobile/src/app/_layout.tsx
+++ b/apps/mobile/src/app/_layout.tsx
@@ -1,17 +1,24 @@
 import '@/lib/i18n';
 
 import { useFonts } from 'expo-font';
-import { DarkTheme, DefaultTheme, Stack, ThemeProvider } from 'expo-router';
+import { DarkTheme, DefaultTheme, Stack, ThemeProvider, useRouter } from 'expo-router';
 import type { NativeStackNavigationOptions } from 'expo-router/native-stack';
 import * as SplashScreen from 'expo-splash-screen';
 import { StatusBar } from 'expo-status-bar';
 import { useEffect } from 'react';
-import { StyleSheet } from 'react-native';
+import { StyleSheet, View } from 'react-native';
 import { GestureHandlerRootView } from 'react-native-gesture-handler';
 
+import { AppSidebar } from '@/components/app-sidebar';
+import { KeyboardDoneBar } from '@/components/app-text-input';
 import { ToastHost, ToastProvider } from '@/components/toast';
 import { AuthProvider, useAuth } from '@/lib/auth';
 import { DebateProvider } from '@/lib/debate-context';
+import { useFirstRun } from '@/lib/use-first-run';
+import { useKeyCommand } from '@/lib/key-commands';
+import { useQuickActions } from '@/lib/quick-actions';
+import { useOfflineQueue } from '@/lib/use-offline-queue';
+import { ReservedWidth, useSidebarWidth } from '@/lib/layout';
 import { watchNetwork } from '@/lib/network-status';
 import { refreshPush } from '@/lib/push';
 import { SettingsProvider, useSettings } from '@/lib/settings';
@@ -20,6 +27,10 @@ import { useTheme } from '@/theme/use-theme';
 
 void SplashScreen.preventAutoHideAsync();
 
+// A screen opened straight from a link (a share link, the widget, a quick action) has the tabs
+// beneath it, so Back and the iPad sidebar always have the tabs to return to.
+export const unstable_settings = { anchor: '(tabs)' };
+
 export default function RootLayout() {
   return (
     <AuthProvider>
@@ -39,6 +50,8 @@ function Root() {
   const { session, loading, settled } = useAuth();
   const { ready: settingsReady, language } = useSettings();
   const { scheme, colors } = useTheme();
+  // A full-screen iPad window lists every tool in a sidebar beside the stack, so it stays while a tool is open.
+  const sidebarWidth = useSidebarWidth();
   // Settings come from the device here, so the app opens in the account's language and theme.
   const ready = (fontsLoaded || fontError !== null) && !loading && settingsReady;
 
@@ -48,9 +61,18 @@ function Root() {
 
   // Offline, reads answer from saved copies and the screens say so.
   useEffect(() => watchNetwork(), []);
+  // Notes, source edits and Active switches made offline sync when the connection returns.
+  useOfflineQueue();
 
   // A phone that opted in registers again on launch and when the language changes (see refreshPush).
   const userId = session?.user.id;
+  useFirstRun(ready ? userId ?? null : null);
+  // Home Screen quick actions (development build with expo-quick-actions; nothing in Expo Go).
+  useQuickActions(ready);
+  // iPad hardware keyboard: ⌘N starts a debate, ⌘K opens the switcher (key-commands.ts).
+  const router = useRouter();
+  useKeyCommand('cmd+n', () => router.push('/new-debate'), ready && Boolean(userId));
+  useKeyCommand('cmd+k', () => router.push('/debates'), ready && Boolean(userId));
   useEffect(() => {
     if (!userId || !settingsReady) return;
     refreshPush(userId, language).catch((cause: unknown) => {
@@ -87,6 +109,9 @@ function Root() {
       <StatusBar style={scheme === 'dark' ? 'light' : 'dark'} />
       {/* The screenshot script waits for auth-settled before it checks an offline cold start. Swipeable rows need the gesture root. */}
       <GestureHandlerRootView style={styles.root} testID={settled ? 'auth-settled' : 'auth-pending'}>
+        <View style={styles.row}>
+        {session !== null && sidebarWidth > 0 ? <AppSidebar width={sidebarWidth} /> : null}
+        <ReservedWidth.Provider value={session !== null ? sidebarWidth : 0}>
         <Stack screenOptions={{ headerShown: false, contentStyle: { backgroundColor: colors.background } }}>
           <Stack.Protected guard={session !== null}>
             <Stack.Screen name="(tabs)" />
@@ -104,6 +129,8 @@ function Root() {
             <Stack.Screen name="limit" options={{ ...sheet, sheetAllowedDetents: [0.56, 0.86] }} />
             <Stack.Screen name="save-case" options={{ ...sheet, sheetAllowedDetents: [0.56, 0.86] }} />
             <Stack.Screen name="context-review" options={sheet} />
+            {/* Ollie's welcome and the first-run tour, at full height so the owl and the buttons both fit. */}
+            <Stack.Screen name="welcome" options={{ ...sheet, sheetAllowedDetents: [1] }} />
             {/* Full screen above the tabs, as in mock 07. */}
             <Stack.Screen name="ask" />
             {/* History, full screen above the tabs like the documents it opens. */}
@@ -131,8 +158,13 @@ function Root() {
           <Stack.Protected guard={session === null}>
             <Stack.Screen name="sign-in" />
           </Stack.Protected>
+          {/* A shared link opens signed in or out; after the sign-in group, so a signed-out launch still starts on sign-in. */}
+          <Stack.Screen name="share/[code]" />
         </Stack>
+        </ReservedWidth.Provider>
+        </View>
         <ToastHost />
+        <KeyboardDoneBar />
       </GestureHandlerRootView>
     </ThemeProvider>
   );
@@ -140,4 +172,5 @@ function Root() {
 
 const styles = StyleSheet.create({
   root: { flex: 1 },
+  row: { flex: 1, flexDirection: 'row' },
 });
diff --git a/apps/mobile/src/app/ask.tsx b/apps/mobile/src/app/ask.tsx
index e9d67e5ed..e667f0b24 100644
--- a/apps/mobile/src/app/ask.tsx
+++ b/apps/mobile/src/app/ask.tsx
@@ -3,9 +3,10 @@ import type { AskOutput } from '@debatelab/core/ai/schemas/ask';
 import { useLocalSearchParams, useRouter } from 'expo-router';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, KeyboardAvoidingView, Platform, Pressable, ScrollView, StyleSheet, TextInput, View } from 'react-native';
+import { ActivityIndicator, KeyboardAvoidingView, Platform, Pressable, ScrollView, StyleSheet, View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
+import { AppTextInput } from '@/components/app-text-input';
 import { AskAnswer } from '@/components/ask-answer';
 import { AskChatPane } from '@/components/ask-chat-list';
 import { AskHistory } from '@/components/ask-history';
@@ -19,6 +20,8 @@ import { OneOffNotice } from '@/components/one-off-notice';
 import { ContextLine } from '@/components/context-line';
 import { DailyUsageLine } from '@/components/tool-form';
 import { Text } from '@/components/text';
+import { useKeyCommand } from '@/lib/key-commands';
+import { announceAnswer } from '@/lib/a11y';
 import { AIError, isAbortError, type AIErrorKind, type ResponseExtras } from '@/lib/ai-request';
 import { askOnce, canStream, isFinalAskError, isMessageWithinBudget, streamAsk, type AskMode, type AskOptions } from '@/lib/ask';
 import { pickAskFiles, readAskFiles, type AskAttachment } from '@/lib/ask-attachments';
@@ -196,6 +199,11 @@ export default function AskScreen() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [loading, lastRole, messages, userId]);
 
+  // ⌘↩ sends, as the send button does.
+  useKeyCommand('cmd+enter', () => {
+    if (!busy && input.trim()) void send(input, messages, attachments);
+  });
+
   const send = async (text: string, history: ChatMessage[], files: AskAttachment[] = []) => {
     const question = text.trim();
     if (!question || !userId) return;
@@ -320,6 +328,7 @@ export default function AskScreen() {
       setStreaming(null);
       partial.current = '';
       setMessages((previous) => [...previous, { id: nextId(), role: 'assistant', content: result.response, timestamp: Date.now(), output }]);
+      announceAnswer(result.response);
     } catch (cause) {
       if (!isCurrent() || isAbortError(cause)) return;
       setStreaming(null);
@@ -509,7 +518,7 @@ export default function AskScreen() {
         {messages.length === 0 && streaming === null && !busy ? (
           <View style={styles.empty}>
             <Owl pose="point" size={112} />
-            <Text weight="display" style={styles.emptyTitle}>
+            <Text accessibilityRole="header" weight="display" style={styles.emptyTitle}>
               {t('askChat.startConversation')}
             </Text>
             <Text tone="secondary" style={styles.emptyBody}>
@@ -598,7 +607,7 @@ export default function AskScreen() {
               testID="ask-attach">
               <Icon name="paperclip" color={colors.secondary} size={20} />
             </Pressable>
-            <TextInput
+            <AppTextInput
               value={input}
               onChangeText={setInput}
               placeholder={t('mobile.ask.placeholder')}
@@ -687,7 +696,7 @@ function Thinking() {
   }, []);
   return (
     <View style={styles.thinking} accessibilityRole="progressbar" accessibilityLiveRegion="polite">
-      <OwlAvatar pose="coach" size={32} />
+      <OwlAvatar pose="coach" size={32} blink />
       <Text tone="secondary" style={styles.thinkingText}>
         {t(THINKING[index])}
       </Text>
diff --git a/apps/mobile/src/app/attack/[id].tsx b/apps/mobile/src/app/attack/[id].tsx
index dac6b51bc..ef69876e9 100644
--- a/apps/mobile/src/app/attack/[id].tsx
+++ b/apps/mobile/src/app/attack/[id].tsx
@@ -11,11 +11,13 @@ import { DocumentStatus } from '@/components/document-status';
 import { backLabel } from '@/lib/back-label';
 import { formatWhen } from '@/lib/dates';
 import { copyText, sharePdf, shareText } from '@/lib/export';
+import { shareAttackDocx } from '@/lib/export-docx';
 import { attackExportFileName, attackExportHtml } from '@/lib/export-html';
 import { crossfireFromAttack } from '@/lib/result-links';
 import { attackToText, discussAttackMessage } from '@/lib/result-text';
 import { isCompleteAttack } from '@/lib/results';
 import { arrivalNoticeText, useResultDocument } from '@/lib/use-result-document';
+import { useShareLink } from '@/lib/use-share-link';
 
 /**
  * An attack analysis in the same document style as a case. Its pinned next
@@ -28,6 +30,7 @@ export default function AttackResultScreen() {
   const doc = useResultDocument('attack', id);
   const [exportOpen, setExportOpen] = useState(false);
   const { setNotice } = doc;
+  const shareLink = useShareLink(setNotice);
 
   useEffect(() => {
     const text = arrivalNoticeText(t, arrival, failed);
@@ -65,11 +68,13 @@ export default function AttackResultScreen() {
     router.push({ pathname: '/crossfire', params: { from: 'attack' } });
   };
 
+  const savedId = result.savedId;
   const actions: HeaderAction[] = [
     { key: 'crossfire', label: t('crossfire.openFromResult'), symbol: 'person.2.wave.2', icon: 'swords', onPress: openCrossfire },
     ...(doc.autoSaved.length > 0
       ? [{ key: 'undo-sources', label: t('autoSavedSources.undo'), symbol: 'arrow.uturn.backward' as const, icon: 'history' as const, onPress: () => void doc.undoAutoSaved() }]
       : []),
+    ...(savedId ? [{ key: 'share-link', label: t('mobile.share.shareLink'), symbol: 'link' as const, icon: 'link' as const, onPress: () => void shareLink('attack', savedId, result.title || title, output) }] : []),
     ...(result.savedId ? [{ key: 'delete', label: t('common.delete'), symbol: 'trash' as const, icon: 'trash' as const, destructive: true, onPress: () => void doc.remove() }] : []),
   ];
 
@@ -78,6 +83,7 @@ export default function AttackResultScreen() {
       testID="attack-document"
       outline
       notice={doc.notice}
+      noticeTone={doc.noticeTone}
       header={<DocumentHeader backLabel={back} onShare={() => run(() => shareText(title, text()))} actions={actions} />}
       actions={
         <>
@@ -94,11 +100,14 @@ export default function AttackResultScreen() {
         items={[
           { key: 'pdf', label: t('common.pdf'), icon: 'file' },
           { key: 'copy', label: t('mobile.results.copyText'), icon: 'copy' },
+          // The website's Word export, built by the same code (packages/core/src/export/docx.ts).
+          { key: 'docx', label: t('common.docx'), icon: 'file' },
         ]}
         cancelLabel={t('common.cancel')}
         onClose={() => setExportOpen(false)}
         onSelect={(choice) => {
           if (choice === 'pdf') run(() => sharePdf(attackExportHtml(output, t), attackExportFileName(output), title));
+          if (choice === 'docx') run(() => shareAttackDocx(output, t, title));
           if (choice === 'copy') run(async () => {
             await copyText(text());
             setNotice(t('generateResults.copiedToClipboard'));
diff --git a/apps/mobile/src/app/brainstorm/[id].tsx b/apps/mobile/src/app/brainstorm/[id].tsx
index aba4e01f9..2402109f3 100644
--- a/apps/mobile/src/app/brainstorm/[id].tsx
+++ b/apps/mobile/src/app/brainstorm/[id].tsx
@@ -12,10 +12,12 @@ import { DocumentStatus } from '@/components/document-status';
 import { backLabel } from '@/lib/back-label';
 import { formatWhen } from '@/lib/dates';
 import { copyText, sharePdf, shareText } from '@/lib/export';
+import { shareBrainstormDocx } from '@/lib/export-docx';
 import { BRAINSTORM_EXPORT_FILE_NAME, brainstormExportHtml } from '@/lib/export-html';
 import { brainstormToText, discussBrainstormMessage } from '@/lib/result-text';
 import { readBrainstorm } from '@/lib/results';
 import { arrivalNoticeText, useResultDocument } from '@/lib/use-result-document';
+import { useShareLink } from '@/lib/use-share-link';
 
 /**
  * A brainstorm read as a document. Its pinned next steps are the website's:
@@ -28,6 +30,7 @@ export default function BrainstormResultScreen() {
   const doc = useResultDocument('brainstorm', params.id);
   const [exportOpen, setExportOpen] = useState(false);
   const { setNotice } = doc;
+  const shareLink = useShareLink(setNotice);
   const { notice: arrival, failed } = params;
 
   // Problems from saving a fresh result are told once, on arrival.
@@ -62,10 +65,13 @@ export default function BrainstormResultScreen() {
     });
   };
 
+  const savedId = result.savedId;
   const actions: HeaderAction[] = [
     ...(doc.autoSaved.length > 0
       ? [{ key: 'undo-sources', label: t('autoSavedSources.undo'), symbol: 'arrow.uturn.backward' as const, icon: 'history' as const, onPress: () => void doc.undoAutoSaved() }]
       : []),
+    // As Export, not for a brainstorm that only asks questions.
+    ...(savedId && !questionsOnly ? [{ key: 'share-link', label: t('mobile.share.shareLink'), symbol: 'link' as const, icon: 'link' as const, onPress: () => void shareLink('brainstorm', savedId, title, output) }] : []),
     ...(result.savedId ? [{ key: 'delete', label: t('common.delete'), symbol: 'trash' as const, icon: 'trash' as const, destructive: true, onPress: () => void doc.remove() }] : []),
   ];
 
@@ -74,6 +80,7 @@ export default function BrainstormResultScreen() {
       testID="brainstorm-document"
       outline
       notice={doc.notice}
+      noticeTone={doc.noticeTone}
       header={<DocumentHeader backLabel={back} onShare={questionsOnly ? undefined : () => run(() => shareText(title, brainstormToText(output, t)))} actions={actions} />}
       // The website shows only the questions when the model needs more, with no export or discussion.
       actions={questionsOnly ? undefined : (
@@ -97,11 +104,14 @@ export default function BrainstormResultScreen() {
         items={[
           { key: 'pdf', label: t('common.pdf'), icon: 'file' },
           { key: 'copy', label: t('mobile.results.copyText'), icon: 'copy' },
+          // The website's Word export, built by the same code (packages/core/src/export/docx.ts).
+          { key: 'docx', label: t('common.docx'), icon: 'file' },
         ]}
         cancelLabel={t('common.cancel')}
         onClose={() => setExportOpen(false)}
         onSelect={(choice) => {
           if (choice === 'pdf') run(() => sharePdf(brainstormExportHtml(output, t), BRAINSTORM_EXPORT_FILE_NAME, title));
+          if (choice === 'docx') run(() => shareBrainstormDocx(output, t, title));
           if (choice === 'copy') run(async () => {
             await copyText(brainstormToText(output, t));
             setNotice(t('generateResults.copiedToClipboard'));
diff --git a/apps/mobile/src/app/case/[id].tsx b/apps/mobile/src/app/case/[id].tsx
index 52f3d5131..df92284a2 100644
--- a/apps/mobile/src/app/case/[id].tsx
+++ b/apps/mobile/src/app/case/[id].tsx
@@ -1,11 +1,14 @@
+import { readCase } from '@debatelab/core/ai/case-view';
 import type { CaseSection } from '@debatelab/core/ai/generate-output';
 import { useLocalSearchParams, useRouter } from 'expo-router';
 import { useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
+import { StyleSheet, View } from 'react-native';
 
 import { ActionMenu } from '@/components/action-menu';
 import { PrimaryButton, SecondaryButton } from '@/components/buttons';
 import { CaseDocument } from '@/components/case-document';
+import { Celebration, clearCelebration, hasCelebration } from '@/components/celebration';
 import { openCitation } from '@/components/citation-target';
 import { DocumentScreen, DocumentTitle } from '@/components/document';
 import { DocumentHeader, type HeaderAction } from '@/components/document-header';
@@ -16,11 +19,13 @@ import { useCaseEdits } from '@/lib/case-edits';
 import { useDebates } from '@/lib/debate-context';
 import { formatWhen } from '@/lib/dates';
 import { copyText, sharePdf, shareText } from '@/lib/export';
+import { shareCaseDocx } from '@/lib/export-docx';
 import { caseExportFileName, caseExportHtml } from '@/lib/export-html';
 import { caseToText, discussCaseMessage } from '@/lib/result-text';
 import { buildFlowchartFromCase, crossfireFromCase } from '@/lib/result-links';
 import { isCompleteCase } from '@/lib/results';
 import { arrivalNoticeText, useResultDocument } from '@/lib/use-result-document';
+import { useShareLink } from '@/lib/use-share-link';
 
 /** A generated case read as a document, as in mock 03. */
 export default function CaseScreen() {
@@ -33,6 +38,10 @@ export default function CaseScreen() {
   const [regenerateOpen, setRegenerateOpen] = useState(false);
   const { setNotice } = doc;
   const edits = useCaseEdits(doc.state.status === 'ready' ? doc.state.key : null, setNotice);
+  const shareLink = useShareLink(setNotice);
+  // Only the case Generate just made celebrates, once; a saved case reopened, or this one after Back, does not.
+  const [celebrate, setCelebrate] = useState(() => hasCelebration(id));
+  useEffect(() => clearCelebration(id), [id]);
 
   // Problems from saving a fresh result are told once, on arrival.
   useEffect(() => {
@@ -77,15 +86,18 @@ export default function CaseScreen() {
     else setNotice(`${t('generate.flowchartImportFailed')}. ${t(outcome === 'noData' ? 'generate.flowchartNoData' : 'generate.flowchartOtherDebate')}`);
   };
 
-  // The website's section cards, in their order; the opening shows only when the case has one.
+  // The website's section cards that can be regenerated, in their order, each only when the case shows it.
+  const view = readCase(output);
   const sections: { key: CaseSection; title: string }[] = [
-    ...(output.exordio && (output.exordio.hook || output.exordio.transition) ? [{ key: 'exordio' as const, title: t('generateResults.exordio') }] : []),
-    { key: 'contentions', title: t('generateResults.arguments') },
-    { key: 'structure', title: t('generateResults.caseStructure') },
-    { key: 'opponent', title: t('generateResults.predictedOpponent') },
-    { key: 'counters', title: t('generateResults.preparedCounters') },
-  ];
+    { key: 'opening' as const, title: t('generateResults.opening'), shown: Boolean(view.opening.hook || view.opening.definition || view.opening.roadmap || view.legacy.framework || view.legacy.burdenOfProof || view.legacy.definitions.length) },
+    { key: 'contentions' as const, title: t('generateResults.arguments'), shown: view.arguments.length > 0 },
+    { key: 'reinforce' as const, title: t('generateResults.reinforce'), shown: view.reinforce.length > 0 },
+    { key: 'whyWeWin' as const, title: t('generateResults.whyWeWin'), shown: view.whyWeWin.length > 0 },
+    { key: 'counters' as const, title: t('generateResults.ifTheySay'), shown: view.ifTheySay.length > 0 || view.legacy.likelyArguments.length > 0 || view.legacy.weaknesses.length > 0 || view.legacy.clashes.length > 0 },
+    { key: 'closing' as const, title: t('generateResults.closingLine'), shown: Boolean(view.closingLine) },
+  ].filter((section) => section.shown).map(({ key, title }) => ({ key, title }));
   const regeneratingTitle = sections.find((section) => section.key === edits.regenerating)?.title;
+  const savedId = result.savedId;
 
   const actions: HeaderAction[] = [
     ...(edits.regenerating
@@ -101,60 +113,87 @@ export default function CaseScreen() {
     ...(doc.autoSaved.length > 0
       ? [{ key: 'undo-sources', label: t('autoSavedSources.undo'), symbol: 'arrow.uturn.backward' as const, icon: 'history' as const, onPress: () => void doc.undoAutoSaved() }]
       : []),
+    // Only a saved case can be shared: the link is made from its row.
+    ...(savedId ? [{ key: 'share-link', label: t('mobile.share.shareLink'), symbol: 'link' as const, icon: 'link' as const, onPress: () => void shareLink('case', savedId, title, output) }] : []),
     ...(result.savedId ? [{ key: 'delete', label: t('common.delete'), symbol: 'trash' as const, icon: 'trash' as const, destructive: true, onPress: () => void doc.remove() }] : []),
   ];
 
+  const argumentCount = view.arguments.length;
+  const sourceCount = view.sources.length;
+
   return (
-    <DocumentScreen
-      testID="case-document"
-      outline
-      notice={doc.notice}
-      noticeTone={doc.noticeTone}
-      header={<DocumentHeader backLabel={back} onShare={() => run(() => shareText(title, caseToText(output)))} actions={actions} />}
-      // "Attack this case" is the longer label, so it gets the wider button.
-      actionWidths={[1.3, 1]}
-      actions={
-        <>
-          <SecondaryButton
-            floating
-            icon="shield"
-            label={t('mobile.results.attackThisCase')}
-            onPress={() => router.push({ pathname: '/attack', params: { caseKey: key } })}
-            testID="attack-this-case"
-          />
-          <PrimaryButton floating icon="download" label={t('common.export')} onPress={() => setExportOpen(true)} disabled={doc.busy} testID="export-button" />
-        </>
-      }>
-      <DocumentTitle title={title} meta={t('mobile.results.generatedMeta', { side, when: formatWhen(generatedAt) })} />
-      {regeneratingTitle ? <RegeneratingStrip title={regeneratingTitle} /> : null}
-      <CaseDocument output={output} library={doc.library} sources={result.sources} onCite={(target) => openCitation(router, target)} />
-      <ActionMenu
-        visible={regenerateOpen}
-        title={t('mobile.results.regenerateSection')}
-        testID="regenerate-menu"
-        items={sections.map((section) => ({ key: section.key, label: t('common.regenerate', { title: section.title }), icon: 'reset' as const }))}
-        cancelLabel={t('common.cancel')}
-        onClose={() => setRegenerateOpen(false)}
-        onSelect={(choice) => void edits.regenerate(choice as CaseSection)}
-      />
-      <ActionMenu
-        visible={exportOpen}
-        title={t('common.export')}
-        testID="export-menu"
-        items={[
-          { key: 'pdf', label: t('common.pdf'), icon: 'file' },
-          { key: 'copy', label: t('mobile.results.copyText'), icon: 'copy' },
-        ]}
-        cancelLabel={t('common.cancel')}
-        onClose={() => setExportOpen(false)}
-        onSelect={(choice) => {
-          if (choice === 'pdf') run(() => sharePdf(caseExportHtml(output, t), caseExportFileName(output), title));
-          if (choice === 'copy') run(async () => {
-            await copyText(caseToText(output));
-            setNotice(t('generateResults.copiedToClipboard'));
-          });
-        }}
-      />
-    </DocumentScreen>
+    <View style={styles.root}>
+      <DocumentScreen
+        testID="case-document"
+        outline
+        notice={doc.notice}
+        noticeTone={doc.noticeTone}
+        header={<DocumentHeader backLabel={back} onShare={() => run(() => shareText(title, caseToText(output)))} actions={actions} />}
+        // "Attack this case" is the longer label, so it gets the wider button.
+        actionWidths={[1.3, 1]}
+        actions={
+          <>
+            <SecondaryButton
+              floating
+              icon="shield"
+              label={t('mobile.results.attackThisCase')}
+              onPress={() => router.push({ pathname: '/attack', params: { caseKey: key } })}
+              testID="attack-this-case"
+            />
+            <PrimaryButton floating icon="download" label={t('common.export')} onPress={() => setExportOpen(true)} disabled={doc.busy} testID="export-button" />
+          </>
+        }>
+        <DocumentTitle title={title} meta={t('mobile.results.generatedMeta', { side, when: formatWhen(generatedAt) })} />
+        {regeneratingTitle ? <RegeneratingStrip title={regeneratingTitle} /> : null}
+        <CaseDocument output={output} library={doc.library} sources={result.sources} onCite={(target) => openCitation(router, target)} />
+        <ActionMenu
+          visible={regenerateOpen}
+          title={t('mobile.results.regenerateSection')}
+          testID="regenerate-menu"
+          items={sections.map((section) => ({ key: section.key, label: t('common.regenerate', { title: section.title }), icon: 'reset' as const }))}
+          cancelLabel={t('common.cancel')}
+          onClose={() => setRegenerateOpen(false)}
+          onSelect={(choice) => void edits.regenerate(choice as CaseSection)}
+        />
+        <ActionMenu
+          visible={exportOpen}
+          title={t('common.export')}
+          testID="export-menu"
+          items={[
+            { key: 'pdf', label: t('common.pdf'), icon: 'file' },
+            { key: 'copy', label: t('mobile.results.copyText'), icon: 'copy' },
+            // The website's Word export, built by the same code (packages/core/src/export/docx.ts).
+            { key: 'docx', label: t('common.docx'), icon: 'file' },
+          ]}
+          cancelLabel={t('common.cancel')}
+          onClose={() => setExportOpen(false)}
+          onSelect={(choice) => {
+            if (choice === 'pdf') run(() => sharePdf(caseExportHtml(output, t), caseExportFileName(output), title));
+            if (choice === 'docx') run(() => shareCaseDocx(output, t, title));
+            if (choice === 'copy') run(async () => {
+              await copyText(caseToText(output));
+              setNotice(t('generateResults.copiedToClipboard'));
+            });
+          }}
+        />
+      </DocumentScreen>
+      {celebrate ? (
+        <Celebration
+          eyebrow={t('export.debateCase')}
+          title={title}
+          stats={[
+            { key: 'arguments', label: t('generateResults.arguments'), value: argumentCount },
+            ...(sourceCount > 0 ? [{ key: 'sources', label: t('generateResults.sources'), value: sourceCount }] : []),
+          ]}
+          // keepOpenResult already tapped success when the case arrived.
+          haptic={false}
+          onDone={() => setCelebrate(false)}
+        />
+      ) : null}
+    </View>
   );
 }
+
+const styles = StyleSheet.create({
+  root: { flex: 1 },
+});
diff --git a/apps/mobile/src/app/context-review.tsx b/apps/mobile/src/app/context-review.tsx
index b95134113..ad52e97e0 100644
--- a/apps/mobile/src/app/context-review.tsx
+++ b/apps/mobile/src/app/context-review.tsx
@@ -7,12 +7,14 @@ import { useTranslation } from 'react-i18next';
 import { ActivityIndicator, Pressable, StyleSheet, View } from 'react-native';
 
 import { SecondaryButton, TextButton } from '@/components/buttons';
+import { ListItemIn, SkeletonTextRows } from '@/components/card';
 import { Icon } from '@/components/icon';
 import { SheetScrollView } from '@/components/sheet';
 import { Text } from '@/components/text';
 import { useAuth } from '@/lib/auth';
 import { hasContextChoices, PinLimitError, resetContextChoices, setOutputChoice, setSourceChoice, togglePin, useContextPlan } from '@/lib/context-plan';
 import { useDebates } from '@/lib/debate-context';
+import { haptics } from '@/lib/haptics';
 import { radius } from '@/theme/colors';
 import { useTheme } from '@/theme/use-theme';
 
@@ -76,7 +78,7 @@ export default function ContextReviewSheet() {
       </Text>
 
       {!plan ? (
-        <ActivityIndicator accessibilityRole="progressbar" style={styles.loading} />
+        <SkeletonTextRows rows={4} />
       ) : (
         <>
           <View style={styles.section}>
@@ -104,7 +106,9 @@ export default function ContextReviewSheet() {
             ) : (
               <View style={[styles.group, { borderColor: colors.border, backgroundColor: colors.card }]}>
                 {plan.sources.map((source, index) => (
-                  <SourceRow key={source.id} source={source} first={index === 0} onChange={(include) => setSourceChoice(plan.feature, plan.debateId, source.id, include)} />
+                  <ListItemIn key={source.id} index={index}>
+                    <SourceRow source={source} first={index === 0} onChange={(include) => setSourceChoice(plan.feature, plan.debateId, source.id, include)} />
+                  </ListItemIn>
                 ))}
               </View>
             )}
@@ -125,14 +129,15 @@ export default function ContextReviewSheet() {
             ) : (
               <View style={[styles.group, { borderColor: colors.border, backgroundColor: colors.card }]}>
                 {plan.outputs.map((output, index) => (
-                  <OutputRow
-                    key={`${output.ref.kind}:${output.ref.id}`}
-                    output={output}
-                    first={index === 0}
-                    pinning={pinning === `${output.ref.kind}:${output.ref.id}`}
-                    onChange={(include) => setOutputChoice(plan.feature, plan.debateId, output.ref, include)}
-                    onPin={() => void pin(output)}
-                  />
+                  <ListItemIn key={`${output.ref.kind}:${output.ref.id}`} index={index}>
+                    <OutputRow
+                      output={output}
+                      first={index === 0}
+                      pinning={pinning === `${output.ref.kind}:${output.ref.id}`}
+                      onChange={(include) => setOutputChoice(plan.feature, plan.debateId, output.ref, include)}
+                      onPin={() => void pin(output)}
+                    />
+                  </ListItemIn>
                 ))}
               </View>
             )}
@@ -169,7 +174,10 @@ function CheckRow({ checked, label, meta, note, first, onChange, trailing }: {
         accessibilityRole="checkbox"
         accessibilityState={{ checked }}
         accessibilityLabel={label}
-        onPress={() => onChange(!checked)}
+        onPress={() => {
+          haptics.tap();
+          onChange(!checked);
+        }}
         style={({ pressed }) => [styles.rowMain, pressed && styles.pressed]}>
         <View style={[styles.box, checked ? { backgroundColor: colors.primaryFill, borderColor: colors.primaryFill } : { borderColor: colors.inputBorder }]}>
           {checked ? <Icon name="check" color={colors.onPrimary} size={14} /> : null}
@@ -226,7 +234,10 @@ function OutputRow({ output, first, pinning, onChange, onPin }: {
           accessibilityLabel={output.pinned ? t('debateContext.unpinAria', { title }) : t('debateContext.pinAria', { title })}
           disabled={pinning}
           hitSlop={6}
-          onPress={onPin}
+          onPress={() => {
+            haptics.tap();
+            onPin();
+          }}
           style={({ pressed }) => [styles.pin, output.pinned && { backgroundColor: colors.tile }, pressed && styles.pressed]}
           testID="debate-context-pin">
           {pinning ? <ActivityIndicator size="small" color={colors.primary} /> : <Icon name="pin" color={output.pinned ? colors.primary : colors.secondary} size={18} />}
@@ -240,7 +251,6 @@ const styles = StyleSheet.create({
   header: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', gap: 12 },
   title: { fontSize: 21, lineHeight: 26, letterSpacing: -0.3, flexShrink: 1 },
   body: { fontSize: 15, lineHeight: 21 },
-  loading: { marginTop: 24 },
   section: { gap: 8 },
   heading: { fontSize: 16 },
   note: { fontSize: 14.5, lineHeight: 20 },
diff --git a/apps/mobile/src/app/crossfire.tsx b/apps/mobile/src/app/crossfire.tsx
index e4728e22d..cb9d23f0f 100644
--- a/apps/mobile/src/app/crossfire.tsx
+++ b/apps/mobile/src/app/crossfire.tsx
@@ -8,13 +8,16 @@ import {
   type CrossfireState,
   type CrossfireTurn,
 } from '@debatelab/core/crossfire/schemas';
+import { formatRoundTime } from '@debatelab/core/sparring/formats';
 import { Stack, useFocusEffect, useLocalSearchParams, useRouter } from 'expo-router';
 import { useCallback, useEffect, useReducer, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, AppState, KeyboardAvoidingView, Platform, Pressable, ScrollView, StyleSheet, TextInput, View } from 'react-native';
+import { ActivityIndicator, AppState, KeyboardAvoidingView, Platform, Pressable, ScrollView, StyleSheet, View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
+import { AppTextInput } from '@/components/app-text-input';
 import { MainActionButton, TextButton } from '@/components/buttons';
+import { Celebration } from '@/components/celebration';
 import { ChoiceCards, CrossfireDebriefDocument, CrossfireTranscript } from '@/components/crossfire-views';
 import { DocumentScreen, DocumentTitle, SectionHeading } from '@/components/document';
 import { DocumentHeader } from '@/components/document-header';
@@ -28,6 +31,8 @@ import { SegmentedControl } from '@/components/segmented-control';
 import { Text } from '@/components/text';
 import { TimerRing } from '@/components/timer-ring';
 import { ToolTitle, WorkingIn } from '@/components/tool-form';
+import { useKeyCommand } from '@/lib/key-commands';
+import { announceAnswer } from '@/lib/a11y';
 import { abortError, AIError, isAbortError, type ResponseExtras, untilAborted } from '@/lib/ai-request';
 import { useAuth } from '@/lib/auth';
 import { haptics } from '@/lib/haptics';
@@ -123,6 +128,8 @@ export default function CrossfireScreen() {
   const roundQuota = useSessionQuota('crossfire');
   // Start waits for the round's cost; a second tap meanwhile does nothing.
   const [checkingQuota, setCheckingQuota] = useState(false);
+  // The round whose debrief arrived while this screen watched celebrates once; a kept or restarted one does not.
+  const [celebrating, setCelebrating] = useState<string | null>(null);
   // The debate chosen when the round started; null for one-off rounds.
   const debateTarget = useRef<string | null>(crossfireDraft.get()?.debateId ?? null);
   const [draftTurn, setDraftTurn] = useState('');
@@ -244,8 +251,9 @@ export default function CrossfireScreen() {
       });
       if (controller.signal.aborted) return;
       dispatch({ type: 'ai-turn-received', turn: nextTurn(snapshot.turns.length + 1, 'ai', reply.type, reply.text) });
-      // The turn is back with the student.
+      // The turn is back with the student; VoiceOver reads the finished reply.
       haptics.turn();
+      announceAnswer(reply.text);
       afterResponse(forUser, debateId, extras);
       if (reply.signalToken) {
         const signalController = new AbortController();
@@ -288,6 +296,8 @@ export default function CrossfireScreen() {
       // The effect below saves the finished round from the state it reaches, with any signal that came in meanwhile.
       if (debateId) pendingRecord.current = { sessionId: snapshot.sessionId, forUser, debateId };
       dispatch({ type: 'debrief-received', debrief });
+      // Shown only if the reducer took the debrief: the screen checks the round reached complete.
+      setCelebrating(snapshot.sessionId);
       // Review choices cover the round; its last request clears them, as on the website.
       resetContextChoices('crossfire');
       afterResponse(forUser, debateId, extras);
@@ -390,6 +400,9 @@ export default function CrossfireScreen() {
     if (live.current) beginSession(debateId, forUser);
   };
 
+  // ⌘↩ submits the turn on an iPad keyboard.
+  useKeyCommand('cmd+enter', () => submitTurn());
+
   const submitTurn = () => {
     if (state.phase !== 'active' || !userId) return;
     const kind = expectedUserTurnKind(state);
@@ -424,6 +437,7 @@ export default function CrossfireScreen() {
     abortSignals();
     debateTarget.current = null;
     dispatch({ type: 'session-reset' });
+    setCelebrating(null);
     setDraftTurn('');
     setFormError('');
     setNotice('');
@@ -546,20 +560,34 @@ export default function CrossfireScreen() {
   }
 
   if (state.phase === 'complete') {
+    const celebrate = celebrating === state.sessionId;
     return (
-      <DocumentScreen
-        testID="crossfire-complete"
-        header={<DocumentHeader backLabel={backLabel(t, from, 'practice')} actions={[]} />}
-        notice={notice}
-        actions={<MainActionButton label={t('crossfire.restart')} onPress={restart} />}>
-        <DocumentTitle title={t('crossfire.debriefTitle')} meta={state.config.resolution} />
-        <Text tone="secondary" style={styles.subtitle}>
-          {t('crossfire.debriefSubtitle')}
-        </Text>
-        <CrossfireDebriefDocument debrief={state.debrief} />
-        <SectionHeading title={t('crossfire.transcript')} />
-        <CrossfireTranscript turns={state.turns} />
-      </DocumentScreen>
+      <View style={styles.flex}>
+        <DocumentScreen
+          testID="crossfire-complete"
+          header={<DocumentHeader backLabel={backLabel(t, from, 'practice')} actions={[]} />}
+          notice={notice}
+          actions={<MainActionButton label={t('crossfire.restart')} onPress={restart} />}>
+          <DocumentTitle title={t('crossfire.debriefTitle')} meta={state.config.resolution} />
+          <Text tone="secondary" style={styles.subtitle}>
+            {t('crossfire.debriefSubtitle')}
+          </Text>
+          <CrossfireDebriefDocument debrief={state.debrief} holdEntrance={celebrate} />
+          <SectionHeading title={t('crossfire.transcript')} />
+          <CrossfireTranscript turns={state.turns} />
+        </DocumentScreen>
+        {celebrate ? (
+          <Celebration
+            eyebrow={t('crossfire.title')}
+            title={t('sparring.round.complete')}
+            stats={[
+              { key: 'concessions', label: t('crossfire.concessionsSecured'), value: state.debrief.concessionsSecured.length },
+              { key: 'time', label: t('export.sparringTimeUsed'), value: Math.max(0, Math.round((state.endedAt - state.startedAt) / 1000)), format: formatRoundTime },
+            ]}
+            onDone={() => setCelebrating(null)}
+          />
+        ) : null}
+      </View>
     );
   }
 
@@ -689,7 +717,7 @@ export default function CrossfireScreen() {
               </Text>
             </View>
             <View style={[styles.inputRow, { borderColor: colors.border, backgroundColor: colors.input }]}>
-              <TextInput
+              <AppTextInput
                 value={draftTurn}
                 onChangeText={setDraftTurn}
                 maxLength={MAX_CROSSFIRE_TURN_CHARS}
diff --git a/apps/mobile/src/app/debates.tsx b/apps/mobile/src/app/debates.tsx
index c1b357ad3..5630bd95a 100644
--- a/apps/mobile/src/app/debates.tsx
+++ b/apps/mobile/src/app/debates.tsx
@@ -1,11 +1,13 @@
 import { useRouter } from 'expo-router';
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useState, type ReactNode } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, Pressable, StyleSheet, Switch, TextInput, View } from 'react-native';
+import { ActivityIndicator, Pressable, StyleSheet, Switch, View, type PressableProps } from 'react-native';
 import ReanimatedSwipeable from 'react-native-gesture-handler/ReanimatedSwipeable';
+import Animated from 'react-native-reanimated';
 
+import { AppTextInput } from '@/components/app-text-input';
 import { PrimaryButton, TextButton } from '@/components/buttons';
-import { Card } from '@/components/card';
+import { Card, ListItemIn, SkeletonTextRows, usePressScale } from '@/components/card';
 import { WEB_SWITCH_THUMB } from '@/components/form-rows';
 import { Icon } from '@/components/icon';
 import { SheetScrollView } from '@/components/sheet';
@@ -69,6 +71,7 @@ export default function DebatesSheet() {
       router.back();
       return;
     }
+    haptics.select();
     setSwitching(debate.id);
     setError('');
     try {
@@ -115,7 +118,7 @@ export default function DebatesSheet() {
 
       <View style={[styles.search, { backgroundColor: colors.segmentTrack }]}>
         <Icon name="search" color={colors.faint} size={19} />
-        <TextInput
+        <AppTextInput
           value={query}
           onChangeText={setQuery}
           placeholder={t('mobile.debates.search')}
@@ -128,7 +131,8 @@ export default function DebatesSheet() {
         />
       </View>
 
-      {status === 'loading' ? <ActivityIndicator style={styles.loading} /> : null}
+      {/* Only before any debate is known: a refresh keeps showing the list it has. */}
+      {status === 'loading' && debates.length === 0 ? <SkeletonTextRows rows={3} /> : null}
       {status === 'error' ? (
         <Card>
           <Text tone="secondary" style={styles.body}>
@@ -156,7 +160,7 @@ export default function DebatesSheet() {
               ? t('mobile.debates.activeToday')
               : formatRelativeDate(debate.lastActivityAt);
             const row = (
-              <Pressable
+              <DebateRowPress
                 accessibilityRole="button"
                 accessibilityLabel={t('debate.switchToAria', { motion: debate.motion })}
                 accessibilityState={{ selected: isCurrent, busy: switching === debate.id || deleting === debate.id }}
@@ -165,8 +169,7 @@ export default function DebatesSheet() {
                   if (event.nativeEvent.actionName === 'delete') void removeDebate(debate);
                 }}
                 disabled={switching !== null}
-                onPress={() => void pick(debate)}
-                style={({ pressed }) => [styles.row, { backgroundColor: colors.card }, pressed && styles.pressed]}>
+                onPress={() => void pick(debate)}>
                 <View style={styles.rowText}>
                   <Text weight="semibold" style={styles.motion}>
                     {debate.motion}
@@ -182,32 +185,39 @@ export default function DebatesSheet() {
                 ) : isCurrent ? (
                   <Icon name="check" color={colors.primary} size={22} />
                 ) : null}
-              </Pressable>
+              </DebateRowPress>
             );
             const divider = index > 0 && { borderTopWidth: 1, borderTopColor: colors.line };
             // The current debate cannot be deleted, as on the website.
-            if (isCurrent) return <View key={debate.id} style={divider}>{row}</View>;
+            if (isCurrent) {
+              return (
+                <ListItemIn key={debate.id} index={index} layout style={divider}>
+                  {row}
+                </ListItemIn>
+              );
+            }
             return (
-              <ReanimatedSwipeable
-                key={debate.id}
-                friction={2}
-                rightThreshold={40}
-                overshootRight={false}
-                containerStyle={divider}
-                renderRightActions={() => (
-                  <Pressable
-                    accessibilityRole="button"
-                    accessibilityLabel={t('debate.deleteAria', { motion: debate.motion })}
-                    onPress={() => void removeDebate(debate)}
-                    style={[styles.deleteAction, { backgroundColor: colors.destructive }]}>
-                    <Icon name="trash" color="#ffffff" size={20} />
-                    <Text weight="semibold" style={styles.deleteLabel}>
-                      {t('common.delete')}
-                    </Text>
-                  </Pressable>
-                )}>
-                {row}
-              </ReanimatedSwipeable>
+              <ListItemIn key={debate.id} index={index} layout>
+                <ReanimatedSwipeable
+                  friction={2}
+                  rightThreshold={40}
+                  overshootRight={false}
+                  containerStyle={divider}
+                  renderRightActions={() => (
+                    <Pressable
+                      accessibilityRole="button"
+                      accessibilityLabel={t('debate.deleteAria', { motion: debate.motion })}
+                      onPress={() => void removeDebate(debate)}
+                      style={[styles.deleteAction, { backgroundColor: colors.destructive }]}>
+                      <Icon name="trash" color="#ffffff" size={20} />
+                      <Text weight="semibold" style={styles.deleteLabel}>
+                        {t('common.delete')}
+                      </Text>
+                    </Pressable>
+                  )}>
+                  {row}
+                </ReanimatedSwipeable>
+              </ListItemIn>
             );
           })}
         </Card>
@@ -252,6 +262,19 @@ export default function DebatesSheet() {
   );
 }
 
+/**
+ * A debate's row: its face stays put (it covers the swipe's Delete), and its content presses in.
+ */
+function DebateRowPress({ children, ...props }: Omit<PressableProps, 'style' | 'children'> & { children: ReactNode }) {
+  const { colors } = useTheme();
+  const press = usePressScale();
+  return (
+    <Pressable {...props} onPressIn={press.onPressIn} onPressOut={press.onPressOut} style={{ backgroundColor: colors.card }}>
+      {({ pressed }) => <Animated.View style={[styles.row, pressed && styles.pressed, press.style]}>{children}</Animated.View>}
+    </Pressable>
+  );
+}
+
 const styles = StyleSheet.create({
   content: { gap: 14 },
   header: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', gap: 12 },
@@ -265,7 +288,6 @@ const styles = StyleSheet.create({
     minHeight: 46,
   },
   searchInput: { flex: 1, fontSize: 16.5, fontFamily: fontFamily.regular, paddingVertical: 10 },
-  loading: { marginVertical: 24 },
   body: { fontSize: 15, lineHeight: 21 },
   list: { padding: 0, gap: 0, overflow: 'hidden' },
   deleteAction: { width: 92, alignItems: 'center', justifyContent: 'center', gap: 3 },
diff --git a/apps/mobile/src/app/factoids/[id].tsx b/apps/mobile/src/app/factoids/[id].tsx
index 1559b80be..47b8d85e7 100644
--- a/apps/mobile/src/app/factoids/[id].tsx
+++ b/apps/mobile/src/app/factoids/[id].tsx
@@ -16,11 +16,13 @@ import { backLabel } from '@/lib/back-label';
 import { formatWhen } from '@/lib/dates';
 import { useDebates } from '@/lib/debate-context';
 import { copyText, sharePdf, shareText } from '@/lib/export';
+import { shareFactoidsDocx } from '@/lib/export-docx';
 import { FACTOIDS_EXPORT_FILE_NAME, factoidsExportHtml } from '@/lib/export-html';
 import { discussFactoidsMessage, factoidsToText } from '@/lib/result-text';
 import { readFactoids } from '@/lib/results';
 import { addSource } from '@/lib/sources';
 import { arrivalNoticeText, useResultDocument } from '@/lib/use-result-document';
+import { useShareLink } from '@/lib/use-share-link';
 
 /**
  * Factoids read as a document. Each factoid's source opens from its
@@ -41,6 +43,7 @@ export default function FactoidsResultScreen() {
   const live = useRef(true);
   const owner = useRef(userId);
   const { setNotice } = doc;
+  const shareLink = useShareLink(setNotice);
   const { notice: arrival, failed } = params;
 
   useEffect(() => {
@@ -109,10 +112,12 @@ export default function FactoidsResultScreen() {
     }
   };
 
+  const savedId = result.savedId;
   const actions: HeaderAction[] = [
     ...(doc.autoSaved.length > 0
       ? [{ key: 'undo-sources', label: t('autoSavedSources.undo'), symbol: 'arrow.uturn.backward' as const, icon: 'history' as const, onPress: () => void doc.undoAutoSaved() }]
       : []),
+    ...(savedId ? [{ key: 'share-link', label: t('mobile.share.shareLink'), symbol: 'link' as const, icon: 'link' as const, onPress: () => void shareLink('factoids', savedId, title, output) }] : []),
     ...(result.savedId ? [{ key: 'delete', label: t('common.delete'), symbol: 'trash' as const, icon: 'trash' as const, destructive: true, onPress: () => void doc.remove() }] : []),
   ];
 
@@ -121,6 +126,7 @@ export default function FactoidsResultScreen() {
       testID="factoids-document"
       outline
       notice={doc.notice}
+      noticeTone={doc.noticeTone}
       header={<DocumentHeader backLabel={back} onShare={() => run(() => shareText(title, factoidsToText(output, t)))} actions={actions} />}
       actions={
         <>
@@ -152,11 +158,14 @@ export default function FactoidsResultScreen() {
         items={[
           { key: 'pdf', label: t('common.pdf'), icon: 'file' },
           { key: 'copy', label: t('mobile.results.copyText'), icon: 'copy' },
+          // The website's Word export, built by the same code (packages/core/src/export/docx.ts).
+          { key: 'docx', label: t('common.docx'), icon: 'file' },
         ]}
         cancelLabel={t('common.cancel')}
         onClose={() => setExportOpen(false)}
         onSelect={(choice) => {
           if (choice === 'pdf') run(() => sharePdf(factoidsExportHtml(output, t), FACTOIDS_EXPORT_FILE_NAME, title));
+          if (choice === 'docx') run(() => shareFactoidsDocx(output, t, title));
           if (choice === 'copy') run(async () => {
             await copyText(factoidsToText(output, t));
             setNotice(t('generateResults.copiedToClipboard'));
diff --git a/apps/mobile/src/app/flowchart/index.tsx b/apps/mobile/src/app/flowchart/index.tsx
index 5903c5b22..1840e532f 100644
--- a/apps/mobile/src/app/flowchart/index.tsx
+++ b/apps/mobile/src/app/flowchart/index.tsx
@@ -297,7 +297,7 @@ export default function FlowchartScreen() {
     />
   );
   const page = (
-    <ScrollView contentInsetAdjustmentBehavior="automatic" contentContainerStyle={[styles.content, { paddingBottom: insets.bottom + 32 }]}>
+    <ScrollView contentInsetAdjustmentBehavior="automatic" automaticallyAdjustKeyboardInsets keyboardShouldPersistTaps="handled" keyboardDismissMode="interactive" contentContainerStyle={[styles.content, { paddingBottom: insets.bottom + 32 }]}>
       <View style={styles.head}>
         <Text accessibilityRole="header" weight="display" style={styles.title}>
           {t('nav.flowchart')}
diff --git a/apps/mobile/src/app/flowchart/maps.tsx b/apps/mobile/src/app/flowchart/maps.tsx
index 7ebe8e90a..d53ca2bed 100644
--- a/apps/mobile/src/app/flowchart/maps.tsx
+++ b/apps/mobile/src/app/flowchart/maps.tsx
@@ -2,15 +2,18 @@ import { starterFlowchart } from '@debatelab/core/flowchart';
 import { useLocalSearchParams, useRouter } from 'expo-router';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, Pressable, StyleSheet, View } from 'react-native';
+import { ActivityIndicator, StyleSheet, View } from 'react-native';
 
 import { PrimaryButton, TextButton } from '@/components/buttons';
+import { ListItemIn, SkeletonTextRows } from '@/components/card';
 import { Icon } from '@/components/icon';
+import { PressScale } from '@/components/press-scale';
 import { SheetScrollView } from '@/components/sheet';
 import { Text } from '@/components/text';
 import { useAuth } from '@/lib/auth';
 import { confirmDestructive } from '@/lib/confirm';
 import { formatRelativeDate } from '@/lib/dates';
+import { haptics } from '@/lib/haptics';
 import { getDraft, NEW_MAP, newDraft, openDraft, savedDraft, scopeDebateId, showDraft, useFlowchartDrafts } from '@/lib/flowchart-drafts';
 import { fetchFlowchart, fetchFlowchartList, flowchartScreenCopies, type FlowchartSummary } from '@/lib/flowcharts';
 import { useCopyHolder } from '@/lib/use-copy-holder';
@@ -119,25 +122,30 @@ export default function SavedMapsSheet() {
   };
 
   const row = (key: string, title: string, meta: string, selected: boolean, onPress: () => void, index: number, busy = false) => (
-    <Pressable
-      key={key}
-      accessibilityRole="button"
-      // While a map opens, the rows wait for it.
-      accessibilityState={{ selected, disabled: opening !== null }}
-      disabled={opening !== null}
-      onPress={onPress}
-      style={({ pressed }) => [styles.row, index > 0 && { borderTopWidth: StyleSheet.hairlineWidth, borderTopColor: colors.line }, pressed && styles.pressed]}
-      testID="saved-map">
-      <View style={styles.rowText}>
-        <Text weight="semibold" style={styles.rowTitle} numberOfLines={1}>
-          {title}
-        </Text>
-        <Text tone="faint" style={styles.rowMeta} numberOfLines={1}>
-          {meta}
-        </Text>
-      </View>
-      {busy ? <ActivityIndicator color={colors.primary} /> : selected ? <Icon name="check" color={colors.primary} size={20} /> : null}
-    </Pressable>
+    <ListItemIn key={key} index={index} style={index > 0 && { borderTopWidth: StyleSheet.hairlineWidth, borderTopColor: colors.line }}>
+      <PressScale
+        accessibilityRole="button"
+        // While a map opens, the rows wait for it.
+        accessibilityState={{ selected, disabled: opening !== null }}
+        disabled={opening !== null}
+        onPress={() => {
+          if (!selected) haptics.select();
+          onPress();
+        }}
+        style={styles.row}
+        testID="saved-map">
+        <View style={styles.rowText}>
+          <Text weight="semibold" style={styles.rowTitle} numberOfLines={1}>
+            {title}
+          </Text>
+          <Text tone="faint" style={styles.rowMeta} numberOfLines={1}>
+            {meta}
+          </Text>
+        </View>
+        {/* Opening one map is an inline busy state, so it keeps its spinner. */}
+        {busy ? <ActivityIndicator color={colors.primary} /> : selected ? <Icon name="check" color={colors.primary} size={20} /> : null}
+      </PressScale>
+    </ListItemIn>
   );
 
   const items = shown?.items ?? [];
@@ -169,7 +177,7 @@ export default function SavedMapsSheet() {
         </View>
       ) : null}
       {!shown ? (
-        <ActivityIndicator color={colors.primary} accessibilityLabel={t('common.loading')} />
+        <SkeletonTextRows rows={3} />
       ) : shown.failed ? (
         <View style={styles.failed}>
           <Text tone="secondary" style={styles.body}>
@@ -200,6 +208,5 @@ const styles = StyleSheet.create({
   rowText: { flex: 1, gap: 2 },
   rowTitle: { fontSize: 16 },
   rowMeta: { fontSize: 13.5 },
-  pressed: { opacity: 0.7 },
   failed: { gap: 6, alignItems: 'flex-start' },
 });
diff --git a/apps/mobile/src/app/generate.tsx b/apps/mobile/src/app/generate.tsx
index e84aad068..3c08e81a5 100644
--- a/apps/mobile/src/app/generate.tsx
+++ b/apps/mobile/src/app/generate.tsx
@@ -6,6 +6,7 @@ import { useTranslation } from 'react-i18next';
 import { StyleSheet, View } from 'react-native';
 
 import { MainActionButton } from '@/components/buttons';
+import { markCelebration } from '@/components/celebration';
 import { DocumentScreen } from '@/components/document';
 import { DocumentHeader } from '@/components/document-header';
 import { Field } from '@/components/field';
@@ -140,6 +141,8 @@ export default function GenerateScreen() {
         sources: discoveredSources,
       });
       const notice = arrivalNotices({ recordFailed, sourcesFailed: sources.failed, assessed, truncated });
+      // The case just made celebrates when its document opens; reopening it later does not.
+      markCelebration(key);
       router.replace({
         pathname: '/case/[id]',
         params: { id: key, from: from ?? 'prepare', ...(notice ? { notice } : {}), ...(sources.failed > 0 ? { failed: String(sources.failed) } : {}) },
diff --git a/apps/mobile/src/app/history.tsx b/apps/mobile/src/app/history.tsx
index 49da13873..c26665ea7 100644
--- a/apps/mobile/src/app/history.tsx
+++ b/apps/mobile/src/app/history.tsx
@@ -1,22 +1,25 @@
 import { Link, useFocusEffect, useLocalSearchParams, useRouter, type Href } from 'expo-router';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, Pressable, ScrollView, StyleSheet, View } from 'react-native';
+import { Pressable, ScrollView, StyleSheet, View } from 'react-native';
+import Animated from 'react-native-reanimated';
 import ReanimatedSwipeable, { type SwipeableMethods } from 'react-native-gesture-handler/ReanimatedSwipeable';
 
 import { ActionMenu } from '@/components/action-menu';
 import { PrimaryButton, TextButton } from '@/components/buttons';
-import { Card, IconTile } from '@/components/card';
+import { Card, IconTile, ListItemIn, usePressScale } from '@/components/card';
 import { Chip } from '@/components/chip';
 import { DocumentHeader } from '@/components/document-header';
 import { Icon } from '@/components/icon';
 import { Screen } from '@/components/screen';
+import { SkeletonRows } from '@/components/skeleton';
 import { Text } from '@/components/text';
 import { KIND_ICONS, workHref } from '@/components/work-row';
 import { useAuth } from '@/lib/auth';
 import { backLabel } from '@/lib/back-label';
 import { confirmDestructive, showNotice } from '@/lib/confirm';
 import { formatWhen } from '@/lib/dates';
+import { haptics } from '@/lib/haptics';
 import { useDebates } from '@/lib/debate-context';
 import type { Debate } from '@/lib/debates';
 import {
@@ -224,7 +227,10 @@ export default function HistoryScreen() {
           ]}
           cancelLabel={t('common.cancel')}
           onClose={() => setScopeOpen(false)}
-          onSelect={setScopeChoice}
+          onSelect={(key) => {
+            if (key !== scope) haptics.select();
+            setScopeChoice(key);
+          }}
           testID="history-scope-menu"
         />
 
@@ -252,7 +258,7 @@ export default function HistoryScreen() {
             <TextButton label={t('common.retry')} onPress={() => void load(scope)} />
           </Card>
         ) : !shown ? (
-          <ActivityIndicator style={styles.loading} accessibilityRole="progressbar" />
+          <SkeletonRows rows={4} />
         ) : shown.kind === 'unsorted' ? (
           <UnsortedList entries={shown.entries} debates={debates} userId={userId} onAttached={attached} />
         ) : (
@@ -302,13 +308,14 @@ function TabList({ tab, items, onDelete }: { tab: HistoryTab; items: HistoryItem
       {items.map((item, index) => {
         const href = historyHref(item);
         return (
-          <HistoryRow
-            key={`${item.kind}-${item.id}`}
-            item={item}
-            first={index === 0}
-            onPress={href ? () => router.push(href) : undefined}
-            onDelete={item.kind === 'case' || item.kind === 'sparring' ? () => onDelete(item) : undefined}
-          />
+          <ListItemIn key={`${item.kind}-${item.id}`} index={index} layout>
+            <HistoryRow
+              item={item}
+              first={index === 0}
+              onPress={href ? () => router.push(href) : undefined}
+              onDelete={item.kind === 'case' || item.kind === 'sparring' ? () => onDelete(item) : undefined}
+            />
+          </ListItemIn>
         );
       })}
     </Card>
@@ -336,6 +343,7 @@ function HistoryRow({ item, first, onPress, onDelete }: { item: HistoryItem; fir
   const { colors } = useTheme();
   const swipeable = useRef<SwipeableMethods>(null);
   const work = useWorkActions();
+  const press = usePressScale();
   const href = historyHref(item);
   const title = item.title || t(`debate.kinds.${item.kind}`);
 
@@ -354,10 +362,12 @@ function HistoryRow({ item, first, onPress, onDelete }: { item: HistoryItem; fir
       }}
       disabled={!onPress}
       onPress={onPress}
+      onPressIn={press.onPressIn}
+      onPressOut={press.onPressOut}
       testID="history-row"
       style={{ backgroundColor: colors.card }}>
       {({ pressed }) => (
-        <View style={[styles.row, pressed && styles.pressed]}>
+        <Animated.View style={[styles.row, pressed && styles.pressed, press.style]}>
           <IconTile name={KIND_ICONS[item.kind]} size={42} />
           <View style={styles.rowText}>
             <Text weight="semibold" style={styles.rowTitle} numberOfLines={2}>
@@ -368,7 +378,7 @@ function HistoryRow({ item, first, onPress, onDelete }: { item: HistoryItem; fir
             </Text>
           </View>
           {onPress ? <Icon name="chevronRight" color={colors.tabInactive} size={20} /> : null}
-        </View>
+        </Animated.View>
       )}
     </Pressable>
   );
@@ -470,17 +480,18 @@ function UnsortedList({
           {notice}
         </Text>
       ) : null}
-      {entries.map((entry) => (
-        <UnsortedRow
-          key={`${entry.kind}-${entry.id}`}
-          entry={entry}
-          debates={debates}
-          userId={userId}
-          onAttached={() => {
-            setNotice(t('debate.attached'));
-            onAttached(entry);
-          }}
-        />
+      {entries.map((entry, index) => (
+        <ListItemIn key={`${entry.kind}-${entry.id}`} index={index} layout>
+          <UnsortedRow
+            entry={entry}
+            debates={debates}
+            userId={userId}
+            onAttached={() => {
+              setNotice(t('debate.attached'));
+              onAttached(entry);
+            }}
+          />
+        </ListItemIn>
       ))}
     </>
   );
@@ -560,7 +571,10 @@ function UnsortedRow({ entry, debates, userId, onAttached }: { entry: UnsortedEn
             items={debates.map((debate) => ({ key: debate.id, label: debate.motion }))}
             cancelLabel={t('common.cancel')}
             onClose={() => setPicking(false)}
-            onSelect={setTarget}
+            onSelect={(key) => {
+              if (key !== target) haptics.select();
+              setTarget(key);
+            }}
           />
           <PrimaryButton label={t('debate.attachConfirm')} busy={busy} disabled={!chosen} onPress={() => void attach()} />
         </>
@@ -573,7 +587,6 @@ const styles = StyleSheet.create({
   root: { flex: 1 },
   title: { fontSize: 32, lineHeight: 38, letterSpacing: -0.8 },
   body: { fontSize: 15, lineHeight: 21 },
-  loading: { marginTop: 32 },
   pressed: { opacity: 0.7 },
   scope: { flexDirection: 'row', alignItems: 'center', gap: 12, borderWidth: 2, borderRadius: 14, paddingVertical: 11, paddingHorizontal: 14 },
   tabRow: { marginHorizontal: -20, flexGrow: 0 },
diff --git a/apps/mobile/src/app/new-note.tsx b/apps/mobile/src/app/new-note.tsx
index fa110d123..212a886dc 100644
--- a/apps/mobile/src/app/new-note.tsx
+++ b/apps/mobile/src/app/new-note.tsx
@@ -12,11 +12,14 @@ import { useToast } from '@/components/toast';
 import { useAuth } from '@/lib/auth';
 import { useDebates } from '@/lib/debate-context';
 import { haptics } from '@/lib/haptics';
-import { addSource } from '@/lib/sources';
+import { queueAddSource } from '@/lib/offline-queue';
 import { useLibraryFolders } from '@/lib/use-library-folders';
 import { useTheme } from '@/theme/use-theme';
 
-/** Write a note: a text source in the Current Debate, like the website's manual entry. */
+/**
+ * Write a note: a text source in the Current Debate, like the website's manual
+ * entry. Offline it is kept on the phone and added once the connection is back.
+ */
 export default function NewNoteSheet() {
   const { t } = useTranslation();
   const router = useRouter();
@@ -39,8 +42,10 @@ export default function NewNoteSheet() {
     setSaving(true);
     setError('');
     try {
-      await addSource(userId, { title: title.trim(), content: content.trim(), type: 'text', folder, debateId: current.id });
-      toast({ tone: 'success', title: t('libraryPage.sourceSaved', { title: title.trim() }) });
+      const { status } = await queueAddSource(userId, { title: title.trim(), content: content.trim(), type: 'text', folder, debateId: current.id });
+      toast(status === 'saved'
+        ? { tone: 'success', title: t('libraryPage.sourceSaved', { title: title.trim() }) }
+        : { tone: 'info', title: t('mobile.offlineQueue.noteQueuedTitle'), message: t('mobile.offlineQueue.noteQueuedDesc') });
       router.back();
     } catch (cause) {
       console.warn('Could not save the note:', cause instanceof Error ? cause.message : cause);
diff --git a/apps/mobile/src/app/share/[code].tsx b/apps/mobile/src/app/share/[code].tsx
new file mode 100644
index 000000000..4b87d43a5
--- /dev/null
+++ b/apps/mobile/src/app/share/[code].tsx
@@ -0,0 +1,167 @@
+import type { AttackOutput } from '@debatelab/core/ai/schemas/attack';
+import { AttackOutputSchema } from '@debatelab/core/ai/schemas/attack';
+import type { BrainstormOutput } from '@debatelab/core/ai/schemas/brainstorm';
+import type { FactoidsOutput } from '@debatelab/core/ai/schemas/factoids';
+import type { GenerateOutput } from '@debatelab/core/ai/schemas/generate';
+import { GenerateOutputSchema } from '@debatelab/core/ai/schemas/generate';
+import { useLocalSearchParams, useRouter } from 'expo-router';
+import * as WebBrowser from 'expo-web-browser';
+import { useEffect, useState, type ReactNode } from 'react';
+import { useTranslation } from 'react-i18next';
+import { StyleSheet, View } from 'react-native';
+
+import { AttackDocument } from '@/components/attack-document';
+import { BrainstormDocument } from '@/components/brainstorm-document';
+import { PrimaryButton } from '@/components/buttons';
+import { CaseDocument } from '@/components/case-document';
+import type { CitationTarget } from '@/components/citation-target';
+import { DocumentScreen, DocumentTitle } from '@/components/document';
+import { DocumentHeader, type HeaderAction, type HeaderButton } from '@/components/document-header';
+import { DocumentStatus } from '@/components/document-status';
+import { EmptyState } from '@/components/empty-state';
+import { FactoidsDocument } from '@/components/factoids-document';
+import { useAuth } from '@/lib/auth';
+import { formatDate } from '@/lib/dates';
+import { isShareCode } from '@/lib/deep-links';
+import { isCompleteAttack, isCompleteCase, readBrainstorm, readFactoids } from '@/lib/results';
+import { readSharedItem, type SharedItem } from '@/lib/share-links';
+import { websiteShareUrl } from '@/lib/website';
+
+type Shown =
+  | { kind: 'case'; output: GenerateOutput }
+  | { kind: 'attack'; output: AttackOutput }
+  | { kind: 'brainstorm'; output: BrainstormOutput }
+  | { kind: 'factoids'; output: FactoidsOutput };
+
+type State =
+  | { status: 'loading' }
+  | { status: 'missing' }
+  | { status: 'failed' }
+  | { status: 'ready'; item: SharedItem; shown: Shown | null };
+
+/**
+ * Shared data is public input, so, as on the website's SharedPage, it is checked
+ * against the tool's schema before a document renders it. Anything else opens
+ * on the website.
+ */
+function readShared(item: SharedItem): Shown | null {
+  // A reader that normalises before its schema check can throw on hostile data (a `toString` that is not a
+  // function); that is unreadable data, shown with the website fallback, never a screen stuck loading.
+  try {
+    return readSharedUnchecked(item);
+  } catch {
+    return null;
+  }
+}
+
+function readSharedUnchecked(item: SharedItem): Shown | null {
+  switch (item.itemType) {
+    case 'case':
+    case 'generate': {
+      const parsed = GenerateOutputSchema.safeParse(item.itemData);
+      return parsed.success && isCompleteCase(parsed.data) ? { kind: 'case', output: parsed.data } : null;
+    }
+    case 'attack': {
+      const parsed = AttackOutputSchema.safeParse(item.itemData);
+      return parsed.success && isCompleteAttack(parsed.data) ? { kind: 'attack', output: parsed.data } : null;
+    }
+    case 'brainstorm': {
+      const output = readBrainstorm(item.itemData);
+      return output ? { kind: 'brainstorm', output } : null;
+    }
+    case 'factoids': {
+      const output = readFactoids(item.itemData);
+      return output ? { kind: 'factoids', output } : null;
+    }
+    default:
+      return null;
+  }
+}
+
+/** A citation on a shared copy opens only a web address: the reader has no Library of the sharer's. */
+function openSharedCitation(target: CitationTarget | undefined) {
+  if (target?.url && /^https?:\/\//i.test(target.url)) void WebBrowser.openBrowserAsync(target.url);
+}
+
+/**
+ * A shared result, opened from a debateowl.com/share link or the app's own
+ * scheme: read-only, signed in or not, with the website as the fallback.
+ */
+export default function SharedItemScreen() {
+  const { t } = useTranslation();
+  const router = useRouter();
+  const { session } = useAuth();
+  const { code: raw } = useLocalSearchParams<{ code: string }>();
+  // debatelab://share/<anything> reaches this screen without the native intent's check.
+  const code = isShareCode(raw) ? raw : null;
+  const [held, setHeld] = useState<{ code: string | null; state: State }>({ code, state: { status: 'loading' } });
+  const state: State = !code ? { status: 'missing' } : held.code === code ? held.state : { status: 'loading' };
+
+  useEffect(() => {
+    if (!code) return;
+    let active = true;
+    void readSharedItem(code)
+      .then((read) => {
+        if (!active) return;
+        setHeld({ code, state: read.status === 'found' ? { status: 'ready', item: read.item, shown: readShared(read.item) } : read });
+      })
+      .catch(() => {
+        if (active) setHeld({ code, state: { status: 'failed' } });
+      });
+    return () => {
+      active = false;
+    };
+  }, [code]);
+
+  const openWebsite = () => {
+    if (code) void WebBrowser.openBrowserAsync(websiteShareUrl(code));
+  };
+  // Opened from a link, the screen may be the only one: Done leaves for the app's start, or sign-in when signed out.
+  const buttons: HeaderButton[] = router.canGoBack()
+    ? []
+    : [{ key: 'done', label: t('mobile.common.done'), symbol: 'xmark', icon: 'x', onPress: () => router.replace(session ? '/' : '/sign-in') }];
+  const actions: HeaderAction[] = code
+    ? [{ key: 'website', label: t('mobile.share.openWebsite'), symbol: 'safari', icon: 'globe', onPress: openWebsite }]
+    : [];
+  const header = <DocumentHeader backLabel={t('common.back')} actions={actions} buttons={buttons} />;
+
+  if (state.status === 'loading') {
+    return (
+      <DocumentScreen header={header}>
+        <DocumentStatus status="loading" />
+      </DocumentScreen>
+    );
+  }
+
+  const fallback = (title: string, description: string): ReactNode => (
+    <DocumentScreen header={header} testID="shared-fallback">
+      <View style={styles.fallback}>
+        <EmptyState pose="surprised" title={title} description={description}>
+          {code ? <PrimaryButton icon="globe" label={t('mobile.share.openWebsite')} onPress={openWebsite} testID="shared-open-website" /> : null}
+        </EmptyState>
+      </View>
+    </DocumentScreen>
+  );
+
+  if (state.status === 'missing') return fallback(t('sharedPage.notFoundTitle'), code ? t('sharedPage.contentNotFound') : t('sharedPage.noCode'));
+  if (state.status === 'failed') return fallback(t('sharedPage.notFoundTitle'), t('sharedPage.loadFailed'));
+
+  const { item, shown } = state;
+  const title = item.title || t('sharedPage.title');
+  if (!shown) return fallback(title, t('mobile.share.unknownKind'));
+
+  const date = formatDate(item.createdAt);
+  return (
+    <DocumentScreen header={header} outline testID="shared-document">
+      <DocumentTitle title={title} meta={date ? `${t('sharedPage.sharedOn')} ${date}` : undefined} />
+      {shown.kind === 'case' ? <CaseDocument output={shown.output} library={[]} sources={[]} onCite={openSharedCitation} /> : null}
+      {shown.kind === 'attack' ? <AttackDocument output={shown.output} sources={[]} /> : null}
+      {shown.kind === 'brainstorm' ? <BrainstormDocument output={shown.output} input={{}} sources={[]} /> : null}
+      {shown.kind === 'factoids' ? <FactoidsDocument output={shown.output} input={{}} library={[]} sources={[]} onCite={openSharedCitation} /> : null}
+    </DocumentScreen>
+  );
+}
+
+const styles = StyleSheet.create({
+  fallback: { marginTop: 24 },
+});
diff --git a/apps/mobile/src/app/sign-in.tsx b/apps/mobile/src/app/sign-in.tsx
index 14965dc35..230575a64 100644
--- a/apps/mobile/src/app/sign-in.tsx
+++ b/apps/mobile/src/app/sign-in.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { KeyboardAvoidingView, Platform, ScrollView, StyleSheet, View, useWindowDimensions, type TextInput } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
+import { SuccessCheck } from '@/components/success-check';
 import { MainActionButton, TextButton } from '@/components/buttons';
 import { Field } from '@/components/field';
 import { SegmentedControl } from '@/components/segmented-control';
@@ -31,7 +32,7 @@ export default function SignInScreen() {
   const insets = useSafeAreaInsets();
   // On iPad the form sits in the middle of the screen instead of under the status bar.
   const centred = useWindowDimensions().width >= 700;
-  const { signInWithEmailOtp, verifyEmailOtp, signInWithDemoCode } = useAuth();
+  const { signInWithEmailOtp, verifyEmailOtp, signInWithDemoCode, sessionExpired } = useAuth();
   const [mode, setMode] = useState<Mode>('email');
   const [status, setStatus] = useState<Status>('idle');
   const [codeSent, setCodeSent] = useState(false);
@@ -217,11 +218,20 @@ export default function SignInScreen() {
           </View>
         ) : null}
 
+        {sessionExpired && status !== 'code-sent' ? (
+          // The website's login notice after the server ended the session; it goes once a sign-in succeeds.
+          <View style={[styles.notice, { backgroundColor: colors.tile, borderColor: colors.tileBorder }]} accessibilityRole="alert" testID="session-expired">
+            <Icon name="alert" color={colors.primary} size={18} />
+            <Text weight="medium" style={[styles.message, styles.noticeText, { color: colors.tileText }]}>
+              {t('login.sessionExpired')}
+            </Text>
+          </View>
+        ) : null}
         {status === 'code-sent' ? (
           // Success is mint and always comes with a check mark, as on the website.
           <View style={styles.success} accessibilityRole="alert">
-            <View style={[styles.successMark, { backgroundColor: colors.successFill }]}>
-              <Icon name="check" color="#FFFFFF" size={14} />
+            <View style={styles.successMark}>
+              <SuccessCheck size={22} />
             </View>
             <Text weight="medium" style={[styles.message, styles.successText, { color: colors.success }]}>
               {t('login.codeSent')}
@@ -242,6 +252,8 @@ const styles = StyleSheet.create({
   success: { flexDirection: 'row', alignItems: 'flex-start', gap: 8 },
   successMark: { width: 22, height: 22, borderRadius: 11, alignItems: 'center', justifyContent: 'center', marginTop: 1 },
   successText: { flex: 1 },
+  notice: { flexDirection: 'row', alignItems: 'flex-start', gap: 10, borderWidth: 2, borderRadius: 14, padding: 12 },
+  noticeText: { flex: 1 },
   root: { flex: 1 },
   // Phone-width on iPad, centred.
   content: { paddingHorizontal: 24, gap: 24, width: '100%', maxWidth: 460, alignSelf: 'center' },
diff --git a/apps/mobile/src/app/sparring/index.tsx b/apps/mobile/src/app/sparring/index.tsx
index 3f938b745..dfea691ce 100644
--- a/apps/mobile/src/app/sparring/index.tsx
+++ b/apps/mobile/src/app/sparring/index.tsx
@@ -17,11 +17,13 @@ import {
 import { Stack, useLocalSearchParams, useRouter } from 'expo-router';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { AppState, Keyboard, KeyboardAvoidingView, Platform, Pressable, ScrollView, StyleSheet, TextInput, useWindowDimensions, View } from 'react-native';
+import { AppState, Keyboard, KeyboardAvoidingView, Platform, Pressable, ScrollView, StyleSheet, useWindowDimensions, View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
+import { AppTextInput } from '@/components/app-text-input';
 import { ActionMenu } from '@/components/action-menu';
 import { MainActionButton, TextButton } from '@/components/buttons';
+import { Celebration } from '@/components/celebration';
 import { DocumentScreen } from '@/components/document';
 import { DocumentHeader } from '@/components/document-header';
 import { Field } from '@/components/field';
@@ -31,20 +33,24 @@ import { LiveTopBar, MainRoundControl, RoundIconButton, SideControl } from '@/co
 import { SegmentedControl } from '@/components/segmented-control';
 import { ContextLine } from '@/components/context-line';
 import { SessionCostNote } from '@/components/session-cost-note';
-import { SparringScorecardScreen } from '@/components/sparring-views';
+import { SparringScorecardScreen, winnerText } from '@/components/sparring-views';
+import { SuccessCheck } from '@/components/success-check';
 import { Text } from '@/components/text';
 import { TimerRing } from '@/components/timer-ring';
 import { ToolTitle, WorkingIn } from '@/components/tool-form';
+import { useKeyCommand } from '@/lib/key-commands';
 import { AIError, isAbortError, untilAborted } from '@/lib/ai-request';
 import { useAuth } from '@/lib/auth';
 import { backLabel } from '@/lib/back-label';
 import { useDebates } from '@/lib/debate-context';
 import { fetchFeatureConfig } from '@/lib/feature-config';
+import { useContentWidth } from '@/lib/layout';
 import { openRefusal } from '@/lib/refusal';
 import { sessionQuotaRefusal, useSessionQuota } from '@/lib/session-quota';
 import { decideMotionTarget, shouldPrefillMotion } from '@/lib/motion';
 import { chooseMotionTarget } from '@/lib/motion-gate';
 import { useSettings } from '@/lib/settings';
+import { announceAnswer } from '@/lib/a11y';
 import { attachSparring, judgeSparring, newSparringId, noteJudgedRound, SparringResponseError, sparringDraft, sparringTurn } from '@/lib/sparring';
 import { formatClock } from '@/lib/timer';
 import { tapTurnStart, useKeepAwakeWhile } from '@/lib/timer-signals';
@@ -117,6 +123,8 @@ export default function SparringScreen() {
   const roundQuota = useSessionQuota('sparring');
   // Start waits for the round's cost; a second tap meanwhile does nothing.
   const [checkingQuota, setCheckingQuota] = useState(false);
+  // The round judged while this screen watched celebrates once; a round reopened or kept from earlier does not.
+  const [celebrating, setCelebrating] = useState<string | null>(null);
 
   // Another account starts with no round: the session slot was already cleared, and this screen's copy goes too.
   useEffect(() => {
@@ -170,6 +178,7 @@ export default function SparringScreen() {
       setRequest({ status: 'idle' });
       if (!completed) return;
       commit(completed);
+      setCelebrating(completed.id);
       // The server saved the judged round before it answered; file it in its debate.
       if (completed.debateId) {
         attachSparring(forUser, completed.id, completed.debateId, completed.userSide).catch((cause: unknown) => {
@@ -218,6 +227,8 @@ export default function SparringScreen() {
       setRequest({ status: 'idle' });
       if (!next) return;
       commit(next);
+      // VoiceOver reads the opponent's finished speech, never as it streams in.
+      announceAnswer(generated.content);
       if (next.phase === 'judging') void runJudge(next, forUser);
       else if (currentSparringTurn(next)?.speaker === 'user') tapTurnStart();
     } catch (cause) {
@@ -313,6 +324,9 @@ export default function SparringScreen() {
     if (live.current && owner.current === forUser && startAttempt.current === attempt) begin(side, debateId, forUser);
   };
 
+  // ⌘↩ submits the speech on an iPad keyboard.
+  useKeyCommand('cmd+enter', () => submit());
+
   const submit = () => {
     const latest = sessionRef.current;
     // A second tap after the speech went in lands on the opponent's turn; it is not a rejected speech.
@@ -341,6 +355,7 @@ export default function SparringScreen() {
     setRequest({ status: 'idle' });
     setNotice('');
     setSubmissionError('');
+    setCelebrating(null);
     commit(null);
   };
 
@@ -441,16 +456,37 @@ export default function SparringScreen() {
   }
 
   if (session.phase === 'complete' && session.scorecard) {
+    const celebrate = celebrating === session.id;
     return (
-      <SparringScorecardScreen
-        session={{ ...session, scorecard: session.scorecard }}
-        from={from}
-        notice={notice}
-        onRestart={restart}
-        onDeleted={() => {
-          if (sessionRef.current?.id === session.id) restart();
-        }}
-      />
+      <View style={styles.flex}>
+        <SparringScorecardScreen
+          session={{ ...session, scorecard: session.scorecard }}
+          from={from}
+          notice={notice}
+          onRestart={restart}
+          onDeleted={() => {
+            if (sessionRef.current?.id === session.id) restart();
+          }}
+          holdEntrance={celebrate}
+        />
+        {celebrate ? (
+          <Celebration
+            eyebrow={t('sparring.round.complete')}
+            title={winnerText(t, session.scorecard.winner)}
+            stats={[
+              { key: 'score', label: t('sparring.scorecard.yourScore'), value: session.scorecard.userScore },
+              { key: 'speeches', label: t('export.sparringSpeeches'), value: session.speeches.length },
+              {
+                key: 'time',
+                label: t('export.sparringTimeUsed'),
+                value: Math.round(session.speeches.reduce((total, speech) => total + speech.timeUsedSeconds, 0)),
+                format: formatRoundTime,
+              },
+            ]}
+            onDone={() => setCelebrating(null)}
+          />
+        ) : null}
+      </View>
     );
   }
 
@@ -513,7 +549,8 @@ function LiveRound({
   const { t } = useTranslation();
   const router = useRouter();
   const insets = useSafeAreaInsets();
-  const { width, height } = useWindowDimensions();
+  const { height } = useWindowDimensions();
+  const width = useContentWidth();
   const { colors } = useTheme();
   const [keyboard, setKeyboard] = useState(false);
   const [expanded, setExpanded] = useState(false);
@@ -581,7 +618,7 @@ function LiveRound({
                 {status}
               </Text>
               {judging ? (
-                <Icon name="check" color={colors.primary} size={Math.round(ringSize * 0.22)} />
+                <SuccessCheck size={Math.round(ringSize * 0.26)} haptic={false} />
               ) : (
                 <Text
                   weight="bold"
@@ -652,7 +689,7 @@ function LiveRound({
             <Text tone="faint" style={styles.guidance}>
               {guidance}
             </Text>
-            <TextInput
+            <AppTextInput
               value={session.draft}
               onChangeText={onDraft}
               maxLength={MAX_SPARRING_SPEECH_CHARS}
diff --git a/apps/mobile/src/app/welcome.tsx b/apps/mobile/src/app/welcome.tsx
new file mode 100644
index 000000000..3e85d1ae1
--- /dev/null
+++ b/apps/mobile/src/app/welcome.tsx
@@ -0,0 +1,251 @@
+import { useLocalSearchParams, useRouter } from 'expo-router';
+import { useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { AccessibilityInfo, Animated, Easing, StyleSheet, View } from 'react-native';
+
+import { MainActionButton, PrimaryButton, SecondaryButton, TextButton } from '@/components/buttons';
+import { Icon } from '@/components/icon';
+import type { IconName } from '@/components/icon-paths';
+import { Owl, useReduceMotion, type OwlPose } from '@/components/owl';
+import { SheetScrollView } from '@/components/sheet';
+import { Text } from '@/components/text';
+import { useAuth } from '@/lib/auth';
+import { useDebates } from '@/lib/debate-context';
+import { markIntroSeen, markTourDone } from '@/lib/first-run';
+import { haptics } from '@/lib/haptics';
+import { radius } from '@/theme/colors';
+import { useTheme } from '@/theme/use-theme';
+
+/** The owl's personal name, as on the website (src/lib/debateowl-intro.ts). */
+const OWL_NAME = 'Ollie';
+
+// The website's beats (DebateOwlIntro.tsx): beat n shows lines 1..n and sets the owl's pose.
+const BEATS: { at: number; pose: OwlPose }[] = [
+  { at: 0, pose: 'surprised' },
+  { at: 700, pose: 'celebrating' },
+  { at: 2300, pose: 'idea' },
+  { at: 3900, pose: 'thinking' },
+  { at: 5600, pose: 'coach' },
+];
+const LAST_BEAT = BEATS.length - 1;
+
+/** The website's four tour steps, as pages instead of pointers at a desktop layout. */
+const STEPS: { key: string; pose: OwlPose; icon: IconName }[] = [
+  { key: 'debate', pose: 'point', icon: 'target' },
+  { key: 'library', pose: 'reading', icon: 'library' },
+  { key: 'generate', pose: 'idea', icon: 'sparkles' },
+  { key: 'ready', pose: 'celebrating', icon: 'check' },
+];
+
+/**
+ * The first run, as one sheet: Ollie's welcome (the website's DebateOwlIntro,
+ * line by line) and then the website's four-step tour. Got it continues into
+ * the tour unless this account finished it; Skip tour, Get started and
+ * closing the sheet all finish it, as on the website.
+ */
+export default function WelcomeScreen() {
+  const { intro } = useLocalSearchParams<{ intro?: string }>();
+  const [phase, setPhase] = useState<'intro' | number>(intro === '1' ? 'intro' : 0);
+  const { session } = useAuth();
+  const userId = session?.user.id;
+  const router = useRouter();
+
+  // Closing the sheet by swiping it away counts as Got it and Skip tour.
+  const finished = useRef(false);
+  useEffect(
+    () => () => {
+      if (finished.current || !userId) return;
+      if (intro === '1') void markIntroSeen();
+      void markTourDone(userId);
+    },
+    [intro, userId],
+  );
+
+  const finishTour = () => {
+    finished.current = true;
+    if (intro === '1') void markIntroSeen();
+    if (userId) void markTourDone(userId);
+    if (router.canDismiss()) router.dismiss();
+    else router.back();
+  };
+
+  if (phase === 'intro') {
+    return (
+      <Intro
+        onDone={(tourDone) => {
+          void markIntroSeen();
+          if (tourDone) finishTour();
+          else setPhase(0);
+        }}
+      />
+    );
+  }
+  return <Tour step={phase} onStep={setPhase} onFinish={finishTour} />;
+}
+
+function Intro({ onDone }: { onDone: (tourDone: boolean) => void }) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  const { tour } = useLocalSearchParams<{ tour?: string }>();
+  const reduceMotion = useReduceMotion();
+  const [beat, setBeat] = useState(0);
+  const [settled, setSettled] = useState(false);
+  const lines = useRef(BEATS.slice(1).map(() => new Animated.Value(0))).current;
+
+  useEffect(() => {
+    if (reduceMotion || settled) {
+      setBeat(LAST_BEAT);
+      setSettled(true);
+      lines.forEach((line) => line.setValue(1));
+      return;
+    }
+    const timers = BEATS.slice(1).map(({ at }, index) =>
+      setTimeout(() => {
+        setBeat(index + 1);
+        Animated.timing(lines[index], { toValue: 1, duration: 320, easing: Easing.out(Easing.cubic), useNativeDriver: true }).start();
+      }, at),
+    );
+    const done = setTimeout(() => setSettled(true), 6600);
+    return () => {
+      timers.forEach(clearTimeout);
+      clearTimeout(done);
+    };
+  }, [reduceMotion, settled, lines]);
+
+  const texts: { text: string; icon?: IconName; heading?: boolean }[] = [
+    { text: t('debateOwlIntro.greetingNamed', { name: OWL_NAME }), heading: true },
+    { text: t('debateOwlIntro.newLook'), icon: 'pencil' },
+    { text: t('debateOwlIntro.company'), icon: 'more' },
+    // Success is mint and always comes with a check mark.
+    { text: t('debateOwlIntro.sameTools'), icon: 'check' },
+  ];
+
+  return (
+    <SheetScrollView contentContainerStyle={styles.content} testID="debateowl-intro">
+      <View style={styles.introTop}>
+        <View style={[styles.owlCircle, { backgroundColor: colors.tile }]}>
+          <Owl pose={BEATS[beat].pose} size={124} style={styles.owl} />
+        </View>
+        {/* VoiceOver reads the whole bubble at once; the lines only fade in on screen. */}
+        <View style={[styles.bubble, { backgroundColor: colors.card, borderColor: colors.border }]} accessible accessibilityLabel={texts.map((line) => line.text).join(' ')}>
+          {texts.map((line, index) => (
+            <Animated.View
+              key={index}
+              style={[styles.line, { opacity: lines[index], transform: [{ translateY: lines[index].interpolate({ inputRange: [0, 1], outputRange: [6, 0] }) }] }]}>
+              {line.icon ? (
+                <Icon name={line.icon} color={line.icon === 'check' ? colors.successFill : colors.primary} size={17} />
+              ) : null}
+              <Text weight={line.heading ? 'display' : 'regular'} style={line.heading ? styles.greeting : styles.lineText}>
+                {line.text}
+              </Text>
+            </Animated.View>
+          ))}
+        </View>
+      </View>
+      <View style={styles.notice}>
+        <Text accessibilityRole="header" weight="display" style={styles.noticeTitle}>
+          {t('debateOwlIntro.noticeTitle')}
+        </Text>
+        <Text style={styles.noticeBody}>{t('debateOwlIntro.noticeBody')}</Text>
+      </View>
+      <View style={styles.footer}>
+        {settled ? null : <TextButton label={t('debateOwlIntro.skipAnimation')} onPress={() => setSettled(true)} />}
+        <View style={styles.flex}>
+          <PrimaryButton label={t('debateOwlIntro.done')} onPress={() => onDone(tour === 'done')} testID="intro-done" />
+        </View>
+      </View>
+    </SheetScrollView>
+  );
+}
+
+function Tour({ step, onStep, onFinish }: { step: number; onStep: (step: number) => void; onFinish: () => void }) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  const router = useRouter();
+  const { current } = useDebates();
+  const { key, pose, icon } = STEPS[step];
+  const last = step === STEPS.length - 1;
+  const title = t(key === 'debate' ? 'onboarding.welcome' : `onboarding.${key}`);
+  const description =
+    key === 'debate' ? t(current ? 'onboarding.debateCurrentDesc' : 'onboarding.debateFirstDesc') : t(`onboarding.${key}Desc`);
+
+  useEffect(() => {
+    AccessibilityInfo.announceForAccessibility(`${title}. ${t('mobile.tour.progress', { step: step + 1, steps: STEPS.length })}`);
+  }, [title, step, t]);
+
+  const go = (next: number) => {
+    haptics.select();
+    onStep(next);
+  };
+
+  return (
+    <SheetScrollView contentContainerStyle={styles.content} testID={`tour-step-${key}`}>
+      <View style={styles.tourTop}>
+        <View style={[styles.owlCircle, { backgroundColor: colors.tile }]}>
+          <Owl pose={pose} size={124} style={styles.owl} />
+        </View>
+        <View style={[styles.stepIcon, { backgroundColor: colors.primaryFill }]}>
+          <Icon name={icon} color={colors.onPrimary} size={18} />
+        </View>
+      </View>
+      <View style={styles.dots} accessibilityLabel={t('mobile.tour.progress', { step: step + 1, steps: STEPS.length })} accessible>
+        {STEPS.map((item, index) => (
+          <View key={item.key} style={[styles.dot, { backgroundColor: index === step ? colors.primary : colors.borderStrong }, index === step && styles.dotCurrent]} />
+        ))}
+      </View>
+      <View style={styles.notice}>
+        <Text accessibilityRole="header" weight="display" style={styles.stepTitle}>
+          {title}
+        </Text>
+        <Text style={[styles.noticeBody, styles.centred]}>{description}</Text>
+      </View>
+      {key === 'debate' && !current ? (
+        // One primary action per step: before a debate exists, that is Start debate.
+        <MainActionButton label={t('debate.startDebate')} onPress={() => router.push('/new-debate')} />
+      ) : null}
+      <View style={styles.footer}>
+        {step > 0 ? (
+          <View style={styles.flex}>
+            <SecondaryButton label={t('onboarding.back')} onPress={() => go(step - 1)} />
+          </View>
+        ) : null}
+        <View style={styles.flex}>
+          <PrimaryButton
+            label={last ? t('onboarding.getStarted') : t('onboarding.next')}
+            onPress={last ? onFinish : () => go(step + 1)}
+            testID="tour-next"
+          />
+        </View>
+      </View>
+      {last ? null : (
+        <View style={styles.skip}>
+          <TextButton label={t('onboarding.skip')} onPress={onFinish} />
+        </View>
+      )}
+    </SheetScrollView>
+  );
+}
+
+const styles = StyleSheet.create({
+  content: { gap: 22, paddingTop: 30 },
+  flex: { flex: 1 },
+  introTop: { alignItems: 'center', gap: 18 },
+  tourTop: { alignItems: 'center' },
+  owlCircle: { width: 136, height: 136, borderRadius: 68, alignItems: 'center', justifyContent: 'flex-end', overflow: 'hidden' },
+  owl: { marginBottom: -8 },
+  stepIcon: { position: 'absolute', bottom: 0, right: '36%', width: 36, height: 36, borderRadius: 18, alignItems: 'center', justifyContent: 'center' },
+  bubble: { alignSelf: 'stretch', borderWidth: 2, borderRadius: radius.card, paddingHorizontal: 18, paddingVertical: 14, gap: 8 },
+  line: { flexDirection: 'row', alignItems: 'flex-start', gap: 10 },
+  greeting: { flex: 1, fontSize: 21, lineHeight: 27 },
+  lineText: { flex: 1, fontSize: 16, lineHeight: 23 },
+  notice: { gap: 8 },
+  noticeTitle: { fontSize: 22, lineHeight: 28 },
+  stepTitle: { fontSize: 26, lineHeight: 32, textAlign: 'center' },
+  noticeBody: { fontSize: 16.5, lineHeight: 24 },
+  centred: { textAlign: 'center' },
+  dots: { flexDirection: 'row', justifyContent: 'center', gap: 8 },
+  dot: { width: 8, height: 8, borderRadius: 4 },
+  dotCurrent: { width: 22 },
+  footer: { flexDirection: 'row', alignItems: 'center', gap: 12 },
+  skip: { alignItems: 'center' },
+});
diff --git a/apps/mobile/src/components/action-menu.web.tsx b/apps/mobile/src/components/action-menu.web.tsx
index 40f33cecd..e10a2618d 100644
--- a/apps/mobile/src/components/action-menu.web.tsx
+++ b/apps/mobile/src/components/action-menu.web.tsx
@@ -15,7 +15,7 @@ export function ActionMenu({ visible, title, items, cancelLabel, onSelect, onClo
       <Pressable accessibilityLabel={cancelLabel} onPress={onClose} style={[styles.backdrop, placement === 'top' ? styles.top : styles.bottom]}>
         <View accessibilityRole="menu" testID={testID} style={[styles.menu, placement === 'top' ? styles.menuTop : styles.menuBottom, { backgroundColor: colors.card, borderColor: colors.line }]}>
           {title ? (
-            <Text tone="faint" style={styles.title}>
+            <Text tone="faint" style={styles.title} maxFontSizeMultiplier={1.6}>
               {title}
             </Text>
           ) : null}
@@ -30,7 +30,7 @@ export function ActionMenu({ visible, title, items, cancelLabel, onSelect, onClo
                 onSelect(item.key);
               }}
               style={({ pressed }) => [styles.item, (index > 0 || title) && { borderTopWidth: 1, borderTopColor: colors.line }, pressed && { backgroundColor: colors.line }]}>
-              <Text style={[styles.label, item.destructive && { color: colors.destructive }, item.disabled && { color: colors.tabInactive }]}>{item.label}</Text>
+              <Text style={[styles.label, item.destructive && { color: colors.destructive }, item.disabled && { color: colors.tabInactive }]} maxFontSizeMultiplier={1.6}>{item.label}</Text>
               {item.icon ? <Icon name={item.icon} color={item.destructive ? colors.destructive : colors.foreground} size={21} /> : null}
             </Pressable>
           ))}
diff --git a/apps/mobile/src/components/app-sidebar.tsx b/apps/mobile/src/components/app-sidebar.tsx
new file mode 100644
index 000000000..9c4856a62
--- /dev/null
+++ b/apps/mobile/src/components/app-sidebar.tsx
@@ -0,0 +1,315 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useNavigationContainerRef, usePathname, useRouter } from 'expo-router';
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Pressable, ScrollView, StyleSheet, View } from 'react-native';
+import Animated, { FadeInUp, FadeOutUp, LinearTransition, useAnimatedStyle, useSharedValue, withSpring } from 'react-native-reanimated';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+
+import { Icon } from './icon';
+import { OwlMark, useReduceMotion } from './owl';
+import { PressScale } from './press-scale';
+import { SIDEBAR_SECTIONS, activeSidebarItem, type SidebarItem, type SidebarSection } from './sidebar-items';
+import { Text } from './text';
+
+import { useDebates } from '@/lib/debate-context';
+import { haptics } from '@/lib/haptics';
+import { SIDEBAR_MAX_FONT_SCALE } from '@/lib/layout';
+import { DURATION, motionSetting, SPRING } from '@/theme/motion';
+import { pickSourceFile } from '@/lib/pick-source-file';
+import { holdPickedFile } from '@/lib/source-file';
+import { useTheme } from '@/theme/use-theme';
+
+const COLLAPSED_KEY = 'debateowl.sidebar.collapsed';
+
+/** The part of a navigator's state the sidebar reads. */
+type AnyState = { key?: string; index?: number; routes: { name: string; state?: unknown }[] };
+
+// Screens the root layout declares; the stack holding any of them is the root stack.
+const ROOT_SCREENS = new Set(['(tabs)', 'ask', 'history', 'generate', 'case/[id]', 'attack/index', 'attack/[id]', 'brainstorm/index', 'brainstorm/[id]', 'factoids/index', 'factoids/[id]', 'flowchart/index', 'crossfire', 'sparring/index', 'sparring/[id]', 'share/[code]']);
+
+/** The root stack: the navigator that holds the tabs and every screen pushed above them. */
+function rootStack(state: AnyState | undefined): AnyState | undefined {
+  let current = state;
+  while (current) {
+    if (current.routes.some((route) => ROOT_SCREENS.has(route.name))) return current;
+    const focused = current.routes[current.index ?? current.routes.length - 1];
+    current = focused?.state as AnyState | undefined;
+  }
+  return undefined;
+}
+
+/** The tab under the pushed screens, as the `from` the tools' back buttons read ("prepare", "you"…). */
+function tabUnder(stack: AnyState | undefined): string | undefined {
+  const tabs = stack?.routes.find((route) => route.name === '(tabs)')?.state as AnyState | undefined;
+  const name = tabs?.routes[tabs.index ?? 0]?.name;
+  return name?.replace(/^\((.*)\)$/, '$1');
+}
+
+/** Which sections the student closed; kept on the device, as iPadOS keeps a sidebar's sections. */
+// The closed sections as last read or set, so a sidebar drawn again (a rotation) starts from them.
+let knownCollapsed: ReadonlySet<string> | null = null;
+
+/**
+ * Which sections the student closed; kept on the device, as iPadOS keeps a sidebar's sections.
+ * `loaded` stays false until the stored choice is read, so a closed section never flashes open.
+ */
+function useCollapsedSections() {
+  const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(() => knownCollapsed ?? new Set());
+  const [loaded, setLoaded] = useState(knownCollapsed !== null);
+  useEffect(() => {
+    if (knownCollapsed !== null) return;
+    let live = true;
+    AsyncStorage.getItem(COLLAPSED_KEY)
+      .then((value) => {
+        const keys: unknown = value ? JSON.parse(value) : [];
+        knownCollapsed = new Set(Array.isArray(keys) ? keys.filter((key): key is string => typeof key === 'string') : []);
+        if (live) setCollapsed(knownCollapsed);
+      })
+      .catch(() => {
+        knownCollapsed = new Set();
+      })
+      .finally(() => {
+        if (live) setLoaded(true);
+      });
+    return () => {
+      live = false;
+    };
+  }, []);
+  const toggle = (key: string) =>
+    setCollapsed((previous) => {
+      const next = new Set(previous);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      knownCollapsed = next;
+      AsyncStorage.setItem(COLLAPSED_KEY, JSON.stringify([...next])).catch(() => undefined);
+      return next;
+    });
+  return { collapsed, loaded, toggle };
+}
+
+/**
+ * The iPad sidebar: the Current Debate switcher on top, then every tool under
+ * collapsible Debate, Prepare, Practice, Library and You sections. It sits
+ * beside the root stack (see the root _layout.tsx), so it stays while a tool
+ * is open; picking a row closes the screens above the tabs first, so the
+ * sidebar always leads to one screen, never a pile of them.
+ */
+export function AppSidebar({ width }: { width: number }) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  const insets = useSafeAreaInsets();
+  const router = useRouter();
+  const navigation = useNavigationContainerRef();
+  const pathname = usePathname();
+  const { current, oneOff } = useDebates();
+  const { collapsed, loaded, toggle } = useCollapsedSections();
+  const active = activeSidebarItem(pathname);
+
+  const open = async (item: SidebarItem) => {
+    haptics.tap();
+    const stack = rootStack(navigation.getRootState() as AnyState | undefined);
+    const from = tabUnder(stack);
+    const { target } = item;
+    if (target.kind === 'screen' && pathname === target.pathname) return;
+    let file: string | null = null;
+    if (target.kind === 'pickFile') {
+      const asset = await pickSourceFile().catch((cause: unknown) => {
+        console.warn('Could not open the file picker:', cause instanceof Error ? cause.message : cause);
+        return null;
+      });
+      if (!asset) return;
+      file = holdPickedFile(asset);
+    }
+    // Close the screens above the tabs. With no tabs in the stack (a cold link before the anchor
+    // could add them), start the stack again from the tabs, so tools never pile up.
+    if (stack?.key && !stack.routes.some((route) => route.name === '(tabs)')) {
+      navigation.dispatch({ type: 'RESET', payload: { index: 0, routes: [{ name: '(tabs)' }] }, target: stack.key });
+    } else if (stack?.key && stack.routes.length > 1) navigation.dispatch({ type: 'POP_TO_TOP', target: stack.key });
+    if (target.kind === 'tab') router.navigate(target.href);
+    else if (target.kind === 'pickFile') router.push({ pathname: '/add-file', params: { file: file! } });
+    else router.push({ pathname: target.pathname as never, params: { ...(from ? { from } : {}), ...target.params } });
+  };
+
+  const toggleSection = (key: string) => {
+    haptics.select();
+    toggle(key);
+  };
+
+  const motion = oneOff ? t('debate.oneOffActive') : current?.motion ?? t('mobile.sidebar.noDebate');
+
+  return (
+    <View
+      style={[styles.root, { width, backgroundColor: colors.card, borderRightColor: colors.line }]}
+      accessibilityLabel={t('nav.mainNavigation')}
+      testID="app-sidebar">
+      <ScrollView
+        contentContainerStyle={[styles.content, { paddingTop: insets.top + 14, paddingBottom: insets.bottom + 18 }]}
+        showsVerticalScrollIndicator={false}>
+        <View style={styles.brand}>
+          <OwlMark size={30} />
+          <Text accessibilityRole="header" weight="display" style={styles.brandTitle} maxFontSizeMultiplier={SIDEBAR_MAX_FONT_SCALE}>
+            DebateOwl
+          </Text>
+        </View>
+
+        <View style={styles.switcherRow}>
+          <Pressable
+            accessibilityRole="button"
+            accessibilityLabel={t('debate.menuAria', { motion })}
+            accessibilityHint={t('debate.switchDesc')}
+            onPress={() => {
+              haptics.tap();
+              router.push('/debates');
+            }}
+            style={({ pressed }) => [styles.switcher, { backgroundColor: colors.tile, borderColor: colors.tileBorder }, pressed && styles.pressed]}
+            testID="sidebar-debate-switcher">
+            <View style={styles.switcherText}>
+              <Text weight="semibold" style={[styles.switcherLabel, { color: colors.chipSelectedForeground }]}>
+                {t('debate.current')}
+              </Text>
+              <Text weight="display" style={[styles.switcherMotion, { color: colors.tileText }]} numberOfLines={3}>
+                {motion}
+              </Text>
+            </View>
+            <Icon name="chevronDown" color={colors.chipSelectedForeground} size={18} />
+          </Pressable>
+          <Pressable
+            accessibilityRole="button"
+            accessibilityLabel={t('debate.startNew')}
+            onPress={() => {
+              haptics.tap();
+              router.push('/new-debate');
+            }}
+            hitSlop={6}
+            style={({ pressed }) => [styles.newDebate, { backgroundColor: colors.primaryFill }, pressed && styles.pressed]}
+            testID="sidebar-new-debate">
+            <Icon name="plus" color={colors.onPrimary} size={20} />
+          </Pressable>
+        </View>
+
+        {SIDEBAR_SECTIONS.map((section) => (
+          <SidebarGroup
+            key={section.key}
+            section={section}
+            expanded={!collapsed.has(section.key)}
+            loaded={loaded}
+            active={active}
+            onToggle={() => toggleSection(section.key)}
+            onOpen={(item) => void open(item)}
+          />
+        ))}
+      </ScrollView>
+    </View>
+  );
+}
+
+function SidebarGroup({
+  section,
+  expanded,
+  active,
+  onToggle,
+  onOpen,
+  loaded,
+}: {
+  section: SidebarSection;
+  /** False until the closed sections are read: rows wait, so a closed section never flashes open. */
+  loaded: boolean;
+  expanded: boolean;
+  active: string | null;
+  onToggle: () => void;
+  onOpen: (item: SidebarItem) => void;
+}) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  const reduce = useReduceMotion();
+  const title = t(section.label);
+  // A closed section still shows which of its rows is open, as the dot after its title.
+  const holdsActive = section.items.some((item) => item.key === active);
+  // The chevron turns with a spring as the section opens or closes; the rows slide in and out
+  // and the sections below glide into place (Reanimated layout animations, still under Reduce Motion).
+  const turn = useSharedValue(expanded ? 1 : 0);
+  useEffect(() => {
+    turn.set(reduce ? (expanded ? 1 : 0) : withSpring(expanded ? 1 : 0, SPRING.pop));
+  }, [expanded, reduce, turn]);
+  const chevron = useAnimatedStyle(() => ({ transform: [{ rotate: `${turn.value * 90}deg` }] }));
+  // Rows shown when the sidebar first appears are simply there; rows a tap opens slide in.
+  const [opened, setOpened] = useState(false);
+  useEffect(() => {
+    if (loaded) setOpened(true);
+  }, [loaded]);
+  return (
+    <Animated.View layout={LinearTransition.duration(DURATION.fast).reduceMotion(motionSetting(reduce))} style={styles.group} testID={`sidebar-section-${section.key}`}>
+      {/* A heading for VoiceOver's rotor that also opens and closes the section, as iPadOS sidebar headers do. */}
+      <Pressable
+        accessibilityRole="header"
+        accessibilityLabel={title}
+        aria-expanded={expanded}
+        accessibilityHint={t(expanded ? 'mobile.sidebar.collapseHint' : 'mobile.sidebar.expandHint')}
+        accessibilityActions={[{ name: 'activate' }]}
+        onAccessibilityAction={onToggle}
+        onPress={onToggle}
+        style={({ pressed }) => [styles.groupHeader, pressed && styles.pressed]}
+        testID={`sidebar-toggle-${section.key}`}>
+        <Text weight="bold" style={[styles.groupTitle, { color: colors.heading }]} maxFontSizeMultiplier={SIDEBAR_MAX_FONT_SCALE}>
+          {title}
+        </Text>
+        {!expanded && holdsActive ? <View style={[styles.activeDot, { backgroundColor: colors.primary }]} /> : null}
+        <View style={styles.flex} />
+        <Animated.View style={chevron}>
+          <Icon name="chevronRight" color={colors.primary} size={18} />
+        </Animated.View>
+      </Pressable>
+      {expanded && loaded
+        ? section.items.map((item, index) => {
+            const selected = item.key === active;
+            return (
+              <Animated.View
+                key={item.key}
+                entering={opened ? FadeInUp.delay(index * 25).duration(DURATION.fast).reduceMotion(motionSetting(reduce)) : undefined}
+                exiting={FadeOutUp.duration(DURATION.quick).reduceMotion(motionSetting(reduce))}
+                layout={LinearTransition.duration(DURATION.fast).reduceMotion(motionSetting(reduce))}>
+              <PressScale
+                accessibilityRole="button"
+                aria-selected={selected}
+                onPress={() => onOpen(item)}
+                scaleTo={0.98}
+                style={[styles.row, selected && { backgroundColor: colors.primaryFill }]}
+                testID={`sidebar-item-${item.key}`}>
+                <Icon name={item.icon} color={selected ? colors.onPrimary : colors.primary} size={21} />
+                <Text
+                  weight={selected ? 'semibold' : 'medium'}
+                  style={[styles.rowLabel, { color: selected ? colors.onPrimary : colors.foreground }]}
+                  numberOfLines={2}
+                  maxFontSizeMultiplier={SIDEBAR_MAX_FONT_SCALE}>
+                  {t(item.label)}
+                </Text>
+              </PressScale>
+              </Animated.View>
+            );
+          })
+        : null}
+    </Animated.View>
+  );
+}
+
+const styles = StyleSheet.create({
+  root: { borderRightWidth: StyleSheet.hairlineWidth },
+  content: { paddingHorizontal: 12, gap: 6 },
+  flex: { flex: 1 },
+  brand: { flexDirection: 'row', alignItems: 'center', gap: 10, paddingHorizontal: 6, marginBottom: 6 },
+  brandTitle: { fontSize: 23, letterSpacing: -0.4 },
+  switcherRow: { flexDirection: 'row', alignItems: 'stretch', gap: 8, marginBottom: 8 },
+  switcher: { flex: 1, flexDirection: 'row', alignItems: 'center', gap: 8, borderWidth: 2, borderRadius: 14, paddingHorizontal: 12, paddingVertical: 10 },
+  switcherText: { flex: 1, gap: 2 },
+  switcherLabel: { fontSize: 12.5 },
+  switcherMotion: { fontSize: 15.5, lineHeight: 20 },
+  newDebate: { width: 44, borderRadius: 14, alignItems: 'center', justifyContent: 'center' },
+  group: { gap: 2, marginTop: 4 },
+  groupHeader: { flexDirection: 'row', alignItems: 'center', gap: 8, minHeight: 40, paddingHorizontal: 10 },
+  groupTitle: { fontSize: 15, letterSpacing: 0.1 },
+  activeDot: { width: 7, height: 7, borderRadius: 4 },
+  row: { flexDirection: 'row', alignItems: 'center', gap: 12, borderRadius: 11, paddingHorizontal: 12, paddingVertical: 9, minHeight: 44 },
+  rowLabel: { flex: 1, fontSize: 16, lineHeight: 21 },
+  pressed: { opacity: 0.7 },
+});
diff --git a/apps/mobile/src/components/app-tabs.tsx b/apps/mobile/src/components/app-tabs.tsx
index ce5a32e43..3b4a0098b 100644
--- a/apps/mobile/src/components/app-tabs.tsx
+++ b/apps/mobile/src/components/app-tabs.tsx
@@ -3,16 +3,20 @@ import { useTranslation } from 'react-i18next';
 
 import { TABS } from './tabs';
 
+import { useSidebarWidth } from '@/lib/layout';
+
 import { fontFamily } from '@/theme/fonts';
 import { useTheme } from '@/theme/use-theme';
 
 export default function AppTabs() {
   const { t } = useTranslation();
   const { colors } = useTheme();
+  // A full-screen iPad window shows the app's own sidebar (app-sidebar.tsx), which lists every
+  // tool, so the tab bar hides. Split View and narrower windows keep the tab bar.
+  const sidebar = useSidebarWidth() > 0;
   return (
-    // On iPad (iPadOS 18+) the tabs become the system sidebar; iPhone keeps the tab bar.
     <NativeTabs
-      sidebarAdaptable
+      hidden={sidebar}
       tintColor={colors.primary}
       iconColor={{ default: colors.tabInactive, selected: colors.primary }}
       labelStyle={{
diff --git a/apps/mobile/src/components/app-tabs.web.tsx b/apps/mobile/src/components/app-tabs.web.tsx
index a54738e28..9ab534e7d 100644
--- a/apps/mobile/src/components/app-tabs.web.tsx
+++ b/apps/mobile/src/components/app-tabs.web.tsx
@@ -9,67 +9,32 @@ import type { IconName } from './icon-paths';
 import { TABS } from './tabs';
 import { Text } from './text';
 
-import { SIDEBAR_WIDTH, useLayoutClass } from '@/lib/layout';
+import { useSidebarWidth } from '@/lib/layout';
 import { useTheme } from '@/theme/use-theme';
 
 /**
  * Native tabs are UIKit, which the web preview cannot draw, so this draws the
- * mock's tab bar instead. It exists for VPS screenshots only. On iPad widths it
- * draws what iPadOS shows for NativeTabs' sidebarAdaptable: the five tabs in a
- * sidebar when wide, and in a bar at the top in between (iPad mock A).
+ * mock's tab bar instead. It exists for VPS screenshots only. From the iPad
+ * widths the app's own sidebar (app-sidebar.tsx, beside the root stack) lists
+ * every tool, so the tab bar is hidden there, as app-tabs.tsx hides the native one.
  */
 export default function AppTabs() {
   const { t } = useTranslation();
   const { colors } = useTheme();
   const insets = useSafeAreaInsets();
-  const layout = useLayoutClass();
-
-  if (layout === 'wide') {
-    return (
-      <Tabs style={[styles.root, styles.row]}>
-        <TabList
-          accessibilityRole="tablist"
-          style={[styles.sidebar, { backgroundColor: colors.card, borderRightColor: colors.line, paddingTop: insets.top + 18 }]}>
-          <Text accessibilityRole="header" weight="display" style={styles.sidebarTitle}>
-            DebateOwl
-          </Text>
-          {TABS.map((tab) => (
-            <TabTrigger key={tab.name} name={tab.name} href={tab.href} asChild>
-              <SidebarButton icon={tab.icon} label={t(tab.label)} />
-            </TabTrigger>
-          ))}
-        </TabList>
-        <TabSlot style={styles.slot} />
-      </Tabs>
-    );
-  }
-
-  if (layout === 'regular') {
-    return (
-      <Tabs style={styles.root}>
-        {/* Tabs reads its triggers from a TabList that is its own child, so the bar is the TabList itself. */}
-        <TabList
-          accessibilityRole="tablist"
-          style={[styles.topTabs, { marginTop: insets.top + 10, backgroundColor: colors.card, borderColor: colors.line }]}>
-          {TABS.map((tab) => (
-            <TabTrigger key={tab.name} name={tab.name} href={tab.href} asChild>
-              <TopTabButton label={t(tab.label)} />
-            </TabTrigger>
-          ))}
-        </TabList>
-        <TabSlot style={styles.slot} />
-      </Tabs>
-    );
-  }
+  const sidebar = useSidebarWidth() > 0;
 
   return (
     <Tabs style={styles.root}>
       <TabSlot style={styles.slot} />
+      {/* Tabs reads its triggers from a TabList that is its own child, so a hidden bar is still the TabList. */}
       <TabList
         accessibilityRole="tablist"
+        testID="app-tab-bar"
         style={[
           styles.bar,
           { backgroundColor: colors.tabBar, borderTopColor: colors.line, paddingBottom: Math.max(insets.bottom, 12) },
+          sidebar && styles.hidden,
         ]}>
         {TABS.map((tab) => (
           <TabTrigger key={tab.name} name={tab.name} href={tab.href} asChild>
@@ -90,44 +55,8 @@ const TabButton = forwardRef<View, TabTriggerSlotProps & { icon: IconName; label
   return (
     <Pressable ref={ref} {...props} accessibilityRole="tab" accessibilityState={{ selected: isFocused }} style={styles.tab}>
       <Icon name={icon} color={color} size={25} />
-      <Text weight="medium" style={[styles.label, { color }]} numberOfLines={1}>
-        {label}
-      </Text>
-    </Pressable>
-  );
-});
-
-const SidebarButton = forwardRef<View, TabTriggerSlotProps & { icon: IconName; label: string }>(function SidebarButton(
-  { icon, label, isFocused, ...props },
-  ref,
-) {
-  const { colors } = useTheme();
-  const color = isFocused ? colors.onPrimary : colors.foreground;
-  return (
-    <Pressable
-      ref={ref}
-      {...props}
-      accessibilityRole="tab"
-      accessibilityState={{ selected: isFocused }}
-      style={[styles.sidebarRow, isFocused && { backgroundColor: colors.primaryFill }]}>
-      <Icon name={icon} color={isFocused ? colors.onPrimary : colors.primary} size={22} />
-      <Text weight={isFocused ? 'semibold' : 'regular'} style={[styles.sidebarLabel, { color }]} numberOfLines={1}>
-        {label}
-      </Text>
-    </Pressable>
-  );
-});
-
-const TopTabButton = forwardRef<View, TabTriggerSlotProps & { label: string }>(function TopTabButton({ label, isFocused, ...props }, ref) {
-  const { colors } = useTheme();
-  return (
-    <Pressable
-      ref={ref}
-      {...props}
-      accessibilityRole="tab"
-      accessibilityState={{ selected: isFocused }}
-      style={[styles.topTab, isFocused && { backgroundColor: colors.input }]}>
-      <Text weight={isFocused ? 'semibold' : 'medium'} style={[styles.topLabel, { color: isFocused ? colors.primary : colors.secondary }]} numberOfLines={1}>
+      {/* Tab labels are fixed chrome, so they stop growing at a modest Dynamic Type size. */}
+      <Text weight="medium" style={[styles.label, { color }]} numberOfLines={1} maxFontSizeMultiplier={1.3}>
         {label}
       </Text>
     </Pressable>
@@ -136,16 +65,9 @@ const TopTabButton = forwardRef<View, TabTriggerSlotProps & { label: string }>(f
 
 const styles = StyleSheet.create({
   root: { flex: 1 },
-  row: { flexDirection: 'row' },
   slot: { flex: 1 },
+  hidden: { display: 'none' },
   bar: { flexDirection: 'row', justifyContent: 'space-around', paddingTop: 8, borderTopWidth: StyleSheet.hairlineWidth },
   tab: { flex: 1, alignItems: 'center', gap: 3, minHeight: 44 },
   label: { fontSize: 10.5 },
-  sidebar: { width: SIDEBAR_WIDTH, flexDirection: 'column', justifyContent: 'flex-start', gap: 4, paddingHorizontal: 12, borderRightWidth: StyleSheet.hairlineWidth },
-  sidebarTitle: { fontSize: 22, letterSpacing: -0.4, marginLeft: 8, marginBottom: 14 },
-  sidebarRow: { flexDirection: 'row', alignItems: 'center', gap: 12, borderRadius: 10, paddingHorizontal: 12, minHeight: 40 },
-  sidebarLabel: { fontSize: 16.5 },
-  topTabs: { alignSelf: 'center', marginBottom: 6, flexDirection: 'row', justifyContent: 'center', gap: 2, borderWidth: StyleSheet.hairlineWidth, borderRadius: 999, padding: 4 },
-  topTab: { borderRadius: 999, paddingHorizontal: 16, minHeight: 36, justifyContent: 'center' },
-  topLabel: { fontSize: 15 },
 });
diff --git a/apps/mobile/src/components/app-text-input.tsx b/apps/mobile/src/components/app-text-input.tsx
new file mode 100644
index 000000000..124c156bc
--- /dev/null
+++ b/apps/mobile/src/components/app-text-input.tsx
@@ -0,0 +1,50 @@
+import { forwardRef } from 'react';
+import { InputAccessoryView, Keyboard, Platform, Pressable, StyleSheet, TextInput, View, type TextInputProps } from 'react-native';
+import { useTranslation } from 'react-i18next';
+
+import { scaledForPreview, Text } from './text';
+
+import { useTheme } from '@/theme/use-theme';
+
+/** The one Done bar every field shows above the keyboard; KeyboardDoneBar draws it. */
+export const DONE_BAR_ID = 'debateowl-keyboard-done';
+
+/**
+ * Every text field in the app: a Done bar above the keyboard on iOS, so a
+ * multi-line answer or a number pad can always be put away, and the web
+ * preview's text size (font-scale.web.ts).
+ */
+export const AppTextInput = forwardRef<TextInput, TextInputProps>(function AppTextInput({ style, ...props }, ref) {
+  return (
+    <TextInput
+      ref={ref}
+      inputAccessoryViewID={Platform.OS === 'ios' ? DONE_BAR_ID : undefined}
+      {...props}
+      style={scaledForPreview(style, props.maxFontSizeMultiplier)}
+    />
+  );
+});
+
+/** The Done bar above the keyboard, drawn once in the root layout. iOS only. */
+export function KeyboardDoneBar() {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  if (Platform.OS !== 'ios') return null;
+  return (
+    <InputAccessoryView nativeID={DONE_BAR_ID} backgroundColor={colors.card}>
+      <View style={[styles.bar, { borderTopColor: colors.line }]}>
+        <Pressable accessibilityRole="button" onPress={() => Keyboard.dismiss()} hitSlop={8} style={styles.done}>
+          <Text weight="semibold" style={[styles.doneText, { color: colors.primary }]} maxFontSizeMultiplier={1.5}>
+            {t('mobile.common.done')}
+          </Text>
+        </Pressable>
+      </View>
+    </InputAccessoryView>
+  );
+}
+
+const styles = StyleSheet.create({
+  bar: { flexDirection: 'row', justifyContent: 'flex-end', borderTopWidth: StyleSheet.hairlineWidth, paddingHorizontal: 16 },
+  done: { minHeight: 44, justifyContent: 'center', paddingHorizontal: 4 },
+  doneText: { fontSize: 17 },
+});
diff --git a/apps/mobile/src/components/ask-answer.tsx b/apps/mobile/src/components/ask-answer.tsx
index b791679e7..b1fd54a68 100644
--- a/apps/mobile/src/components/ask-answer.tsx
+++ b/apps/mobile/src/components/ask-answer.tsx
@@ -5,6 +5,7 @@ import { useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { ActivityIndicator, Pressable, StyleSheet, View } from 'react-native';
 
+import { SuccessCheck } from './success-check';
 import { Chip, CiteBadge } from './chip';
 import { FadingScrollRow } from './edge-fade';
 import { firstUrl, hostOf, openCitation, shorten, type CitationTarget } from './citation-target';
@@ -88,7 +89,7 @@ export function AskAnswer({
 
       {output?.argumentMap ? (
         <View style={styles.section}>
-          <Text weight="semibold" tone="secondary" style={styles.sectionTitle}>
+          <Text accessibilityRole="header" weight="semibold" tone="secondary" style={styles.sectionTitle}>
             {t('askChat.argumentMap')}
           </Text>
           <Section title={t('askChat.mainClaim')} items={[output.argumentMap.mainClaim]} />
@@ -113,9 +114,7 @@ function SaveToLibrary({ onSave }: { onSave: () => Promise<boolean> }) {
   if (state === 'saved') {
     return (
       <View style={styles.saved} accessibilityRole="text" testID="ask-saved">
-        <View style={[styles.savedCheck, { backgroundColor: colors.successFill }]}>
-          <Icon name="check" color={colors.successTint} size={13} />
-        </View>
+        <SuccessCheck size={20} haptic={false} />
         <Text weight="semibold" style={[styles.saveText, { color: colors.success }]}>
           {t('ask.saved')}
         </Text>
@@ -146,7 +145,7 @@ function Section({ title, items, marker = '•' }: { title: string; items: strin
   if (items.length === 0) return null;
   return (
     <View style={styles.sectionBody}>
-      <Text weight="semibold" tone="secondary" style={styles.sectionTitle}>
+      <Text accessibilityRole="header" weight="semibold" tone="secondary" style={styles.sectionTitle}>
         {title}
       </Text>
       {items.map((item, index) => (
diff --git a/apps/mobile/src/components/ask-chat-list.tsx b/apps/mobile/src/components/ask-chat-list.tsx
index 94b1139ce..f46301347 100644
--- a/apps/mobile/src/components/ask-chat-list.tsx
+++ b/apps/mobile/src/components/ask-chat-list.tsx
@@ -1,16 +1,18 @@
 import { useFocusEffect } from 'expo-router';
 import { useCallback, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, Pressable, ScrollView, StyleSheet, View } from 'react-native';
+import { Pressable, ScrollView, StyleSheet, View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
-import { Card } from './card';
+import { Card, ListItemIn, SkeletonTextRows } from './card';
 import { Icon } from './icon';
+import { PressScale } from './press-scale';
 import { Text } from './text';
 
 import { useAuth } from '@/lib/auth';
 import { fetchChats, type ChatSummary } from '@/lib/chats';
 import { formatDate } from '@/lib/dates';
+import { haptics } from '@/lib/haptics';
 import { useCopyHolder } from '@/lib/use-copy-holder';
 import { useTheme } from '@/theme/use-theme';
 
@@ -38,7 +40,7 @@ export function ChatRows({
       </Text>
     );
   }
-  if (chats === null) return <ActivityIndicator style={styles.loading} accessibilityRole="progressbar" />;
+  if (chats === null) return <SkeletonTextRows rows={4} />;
   if (chats.length === 0) {
     return (
       <Card>
@@ -56,28 +58,27 @@ export function ChatRows({
       {chats.map((chat, index) => {
         const open = chat.id === openChatId;
         return (
-          <Pressable
-            key={chat.id}
-            accessibilityRole="button"
-            accessibilityState={{ selected: open }}
-            onPress={() => onPick(chat.id)}
-            testID="ask-chat-row"
-            style={({ pressed }) => [
-              styles.row,
-              index > 0 && { borderTopWidth: 1, borderTopColor: colors.line },
-              highlightOpen && open && { backgroundColor: colors.tile },
-              pressed && styles.pressed,
-            ]}>
-            <View style={styles.rowText}>
-              <Text weight="semibold" style={[styles.rowTitle, highlightOpen && open && { color: colors.chipSelectedForeground }]} numberOfLines={2}>
-                {chat.title}
-              </Text>
-              <Text tone="faint" style={styles.meta}>
-                {`${formatDate(new Date(chat.createdAt).toISOString())} · ${t('askChat.messageCount', { count: chat.messageCount })}`}
-              </Text>
-            </View>
-            {open && !highlightOpen ? <Icon name="check" color={colors.primary} size={21} /> : null}
-          </Pressable>
+          <ListItemIn key={chat.id} index={index} style={index > 0 && { borderTopWidth: 1, borderTopColor: colors.line }}>
+            <PressScale
+              accessibilityRole="button"
+              accessibilityState={{ selected: open }}
+              onPress={() => {
+                if (!open) haptics.select();
+                onPick(chat.id);
+              }}
+              testID="ask-chat-row"
+              style={[styles.row, highlightOpen && open && { backgroundColor: colors.tile }]}>
+              <View style={styles.rowText}>
+                <Text weight="semibold" style={[styles.rowTitle, highlightOpen && open && { color: colors.chipSelectedForeground }]} numberOfLines={2}>
+                  {chat.title}
+                </Text>
+                <Text tone="faint" style={styles.meta}>
+                  {`${formatDate(new Date(chat.createdAt).toISOString())} · ${t('askChat.messageCount', { count: chat.messageCount })}`}
+                </Text>
+              </View>
+              {open && !highlightOpen ? <Icon name="check" color={colors.primary} size={21} /> : null}
+            </PressScale>
+          </ListItemIn>
         );
       })}
     </Card>
@@ -163,13 +164,11 @@ export function AskChatPane({
 
 const styles = StyleSheet.create({
   body: { fontSize: 15, lineHeight: 21 },
-  loading: { marginTop: 24 },
   list: { padding: 0, gap: 0 },
   row: { flexDirection: 'row', alignItems: 'center', gap: 12, paddingVertical: 13, paddingHorizontal: 16 },
   rowText: { flex: 1, gap: 3 },
   rowTitle: { fontSize: 16, lineHeight: 21 },
   meta: { fontSize: 14 },
-  pressed: { opacity: 0.6 },
   pane: { borderRightWidth: StyleSheet.hairlineWidth },
   paneTop: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', paddingHorizontal: 12, paddingBottom: 4 },
   iconButton: { width: 44, height: 44, alignItems: 'center', justifyContent: 'center' },
diff --git a/apps/mobile/src/components/buttons.tsx b/apps/mobile/src/components/buttons.tsx
index c6e6fb1d2..a91b7f6a8 100644
--- a/apps/mobile/src/components/buttons.tsx
+++ b/apps/mobile/src/components/buttons.tsx
@@ -1,11 +1,14 @@
 import type { ReactNode } from 'react';
-import { ActivityIndicator, Pressable, StyleSheet, View } from 'react-native';
+import { ActivityIndicator, Pressable, StyleSheet } from 'react-native';
+import Animated, { useAnimatedStyle, useSharedValue, withSpring, withTiming } from 'react-native-reanimated';
 
 import { Icon } from './icon';
 import type { IconName } from './icon-paths';
 import { Text } from './text';
 
+import { haptics } from '@/lib/haptics';
 import { LEDGE, radius } from '@/theme/colors';
+import { SPRING, useReduceMotion } from '@/theme/motion';
 import { useTheme } from '@/theme/use-theme';
 
 type Look = { face: string; ledge: string; foreground: string; edge?: string; ledgeSize?: number };
@@ -14,7 +17,9 @@ type Look = { face: string; ledge: string; foreground: string; edge?: string; le
  * The website's tactile button (`.btn` in src/index.css): a face on a solid
  * ledge, which sinks onto the ledge while pressed. Disabled buttons go flat and
  * grey; a busy one keeps its face. The ledge sits inside the button's height,
- * so nothing moves around it.
+ * so nothing moves around it. The face springs down onto its ledge as a finger
+ * lands and bounces back on release (on the UI thread); `tap` adds a light
+ * haptic for a screen's main actions. Under Reduce Motion it moves at once.
  */
 function Tactile({
   look,
@@ -24,6 +29,7 @@ function Tactile({
   floating,
   testID,
   accessibilityLabel,
+  tap,
   children,
 }: {
   look: Look;
@@ -33,13 +39,21 @@ function Tactile({
   floating?: boolean;
   testID?: string;
   accessibilityLabel?: string;
+  /** A light haptic as the button goes down: a screen's main actions. */
+  tap?: boolean;
   children: (foreground: string) => ReactNode;
 }) {
   const { colors, scheme } = useTheme();
+  const reduce = useReduceMotion();
   const flat = disabled && !busy;
   const ledge = flat ? 0 : (look.ledgeSize ?? LEDGE);
   const face = flat ? colors.disabledFace : look.face;
   const foreground = flat ? colors.disabledText : look.foreground;
+  const down = useSharedValue(0);
+  const press = (to: 0 | 1) => {
+    down.set(reduce ? withTiming(to, { duration: 0 }) : withSpring(to, to === 1 ? SPRING.press : SPRING.pop));
+  };
+  const faceStyle = useAnimatedStyle(() => ({ transform: [{ translateY: down.value * ledge }] }));
   return (
     <Pressable
       accessibilityRole="button"
@@ -47,18 +61,22 @@ function Tactile({
       accessibilityState={{ disabled: disabled || busy, busy }}
       disabled={disabled || busy}
       onPress={onPress}
+      onPressIn={() => {
+        press(1);
+        if (tap) haptics.tap();
+      }}
+      onPressOut={() => press(0)}
       testID={testID}
       style={[styles.tactile, { backgroundColor: flat ? 'transparent' : look.ledge }, floating && scheme === 'light' && !flat && styles.floating]}>
-      {({ pressed }) => (
-        <View
-          style={[
-            styles.face,
-            { backgroundColor: face, marginTop: pressed ? ledge : 0, marginBottom: pressed ? 0 : ledge },
-            look.edge && !flat ? { borderWidth: 2, borderColor: look.edge } : null,
-          ]}>
-          {children(foreground)}
-        </View>
-      )}
+      <Animated.View
+        style={[
+          styles.face,
+          { backgroundColor: face, marginBottom: ledge },
+          look.edge && !flat ? { borderWidth: 2, borderColor: look.edge } : null,
+          faceStyle,
+        ]}>
+        {children(foreground)}
+      </Animated.View>
     </Pressable>
   );
 }
@@ -77,7 +95,7 @@ export function MainActionButton({
 }) {
   const { colors } = useTheme();
   return (
-    <Tactile look={{ face: colors.primaryFill, ledge: colors.primaryLedge, foreground: colors.onPrimary, ledgeSize: 5 }} onPress={onPress} busy={busy} disabled={disabled}>
+    <Tactile look={{ face: colors.primaryFill, ledge: colors.primaryLedge, foreground: colors.onPrimary, ledgeSize: 5 }} onPress={onPress} busy={busy} disabled={disabled} tap>
       {(foreground) => (
         <>
           {busy ? <ActivityIndicator color={foreground} /> : null}
@@ -116,11 +134,12 @@ export function PrimaryButton({
     ? { face: colors.destructive, ledge: colors.destructiveLedge, foreground: scheme === 'dark' ? colors.background : '#FFFFFF' }
     : { face: colors.primaryFill, ledge: colors.primaryLedge, foreground: colors.onPrimary };
   return (
-    <Tactile look={look} onPress={onPress} busy={busy} disabled={disabled} floating={floating} testID={testID}>
+    <Tactile look={look} onPress={onPress} busy={busy} disabled={disabled} floating={floating} testID={testID} tap>
       {(foreground) => (
         <>
           {busy ? <ActivityIndicator color={foreground} /> : icon ? <Icon name={icon} color={foreground} size={20} /> : null}
-          <Text weight="display" style={[styles.label, { color: foreground }]} numberOfLines={2}>
+          {/* A floating button sits in the pinned bar, fixed chrome: it grows with Dynamic Type to a cap. */}
+          <Text weight="display" style={[styles.label, { color: foreground }]} numberOfLines={2} maxFontSizeMultiplier={floating ? 1.6 : undefined}>
             {label}
           </Text>
         </>
@@ -158,7 +177,7 @@ export function SecondaryButton({
       {(foreground) => (
         <>
           {icon ? <Icon name={icon} color={foreground} size={20} /> : null}
-          <Text weight="display" style={[styles.label, { color: foreground }]} numberOfLines={2}>
+          <Text weight="display" style={[styles.label, { color: foreground }]} numberOfLines={2} maxFontSizeMultiplier={floating ? 1.6 : undefined}>
             {label}
           </Text>
         </>
diff --git a/apps/mobile/src/components/card.tsx b/apps/mobile/src/components/card.tsx
index df47d0949..3ae84c7cf 100644
--- a/apps/mobile/src/components/card.tsx
+++ b/apps/mobile/src/components/card.tsx
@@ -1,10 +1,14 @@
 import type { ReactNode } from 'react';
-import { StyleSheet, View, type ViewStyle } from 'react-native';
+import { useTranslation } from 'react-i18next';
+import { StyleSheet, View, type StyleProp, type ViewStyle } from 'react-native';
+import Animated, { FadeInDown, LinearTransition, useAnimatedStyle, useSharedValue, withSpring, withTiming } from 'react-native-reanimated';
 
 import { Icon } from './icon';
 import type { IconName } from './icon-paths';
+import { Skeleton } from './skeleton';
 
 import { radius } from '@/theme/colors';
+import { motionSetting, SPRING, staggerDelay, useReduceMotion } from '@/theme/motion';
 import { useTheme } from '@/theme/use-theme';
 
 export function Card({ children, style }: { children: ReactNode; style?: ViewStyle }) {
@@ -22,7 +26,71 @@ export function IconTile({ name, size = 40 }: { name: IconName; size?: number })
   );
 }
 
+/**
+ * A list row arriving: it fades up into place, 40 ms after the row above it, the first time it
+ * mounts. With `layout`, rows slide into a gap a removed row leaves. Both are Reanimated layout
+ * animations on the UI thread and follow the system's Reduce Motion (ReduceMotion.System), so
+ * under it the row is simply there. Keep press feedback on a view inside it, never on this one.
+ */
+export function ListItemIn({ index, layout = false, style, children }: { index: number; layout?: boolean; style?: StyleProp<ViewStyle>; children: ReactNode }) {
+  const reduce = useReduceMotion();
+  return (
+    <Animated.View
+      entering={FadeInDown.delay(staggerDelay(index)).duration(220).reduceMotion(motionSetting(reduce))}
+      layout={layout ? LinearTransition.duration(200).reduceMotion(motionSetting(reduce)) : undefined}
+      style={style}>
+      {children}
+    </Animated.View>
+  );
+}
+
+/**
+ * PressScale's give for a row that must stay its own Pressable (a Link's trigger, a row in a
+ * swipeable, a tile whose layout lives on the Pressable): spread the handlers on the Pressable and
+ * put `style` on an Animated.View inside it. Under Reduce Motion it does not move.
+ */
+export function usePressScale(scaleTo = 0.97) {
+  const reduce = useReduceMotion();
+  const scale = useSharedValue(1);
+  const style = useAnimatedStyle(() => ({ transform: [{ scale: scale.value }] }));
+  return {
+    style,
+    onPressIn: () => {
+      if (!reduce) scale.set(withTiming(scaleTo, { duration: 90 }));
+    },
+    onPressOut: () => {
+      if (!reduce) scale.set(withSpring(1, SPRING.pop));
+    },
+  };
+}
+
+/**
+ * A list of text-only rows loading (a title and a meta line each), for lists without icon tiles.
+ * Like SkeletonRows it is the loading indicator (progressbar, "Loading").
+ */
+export function SkeletonTextRows({ rows = 3, card = true, label, testID }: { rows?: number; card?: boolean; label?: string; testID?: string }) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  return (
+    <View
+      accessible
+      accessibilityRole="progressbar"
+      accessibilityLabel={label ?? t('common.loading')}
+      testID={testID}
+      style={[card && [styles.skeletonCard, { backgroundColor: colors.card, borderColor: colors.border }]]}>
+      {Array.from({ length: rows }, (_, index) => (
+        <View key={index} style={[styles.skeletonRow, index > 0 && { borderTopWidth: 1, borderTopColor: colors.line }]}>
+          <Skeleton width={`${82 - (index % 3) * 15}%`} height={15} />
+          <Skeleton width="38%" height={12} />
+        </View>
+      ))}
+    </View>
+  );
+}
+
 const styles = StyleSheet.create({
   card: { borderWidth: 2, borderRadius: radius.card, padding: 16, gap: 12 },
   tile: { borderRadius: radius.tile, alignItems: 'center', justifyContent: 'center' },
+  skeletonCard: { borderWidth: 2, borderRadius: radius.card, overflow: 'hidden' },
+  skeletonRow: { gap: 8, paddingHorizontal: 16, paddingVertical: 15 },
 });
diff --git a/apps/mobile/src/components/case-document.tsx b/apps/mobile/src/components/case-document.tsx
index beed4e20e..aad4afd0f 100644
--- a/apps/mobile/src/components/case-document.tsx
+++ b/apps/mobile/src/components/case-document.tsx
@@ -1,24 +1,13 @@
+import { readCase, sourceLabel, type CaseArgument } from '@debatelab/core/ai/case-view';
 import type { DiscoveredSource } from '@debatelab/core/ai/discovered-sources';
-import type { Contention, GenerateOutput } from '@debatelab/core/ai/schemas/generate';
+import type { GenerateOutput } from '@debatelab/core/ai/schemas/generate';
 import * as WebBrowser from 'expo-web-browser';
 import { useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Pressable, StyleSheet, View } from 'react-native';
 
 import { hostOf, shorten, type CitationTarget } from './citation-target';
-import {
-  Bullets,
-  Callout,
-  Divider,
-  DocSection,
-  FramingCard,
-  Labeled,
-  NumberedItems,
-  Paragraph,
-  Quote,
-  SubHeading,
-  Tag,
-} from './document';
+import { Bullets, Callout, Divider, DocSection, Labeled, NumberedItems, Quote, SubHeading, Tag } from './document';
 import { Icon } from './icon';
 import { Text } from './text';
 
@@ -35,8 +24,8 @@ const MIN_TITLE_MATCH = 4;
  * each one whose title or site it mentions, then for Library sources it names,
  * as Ask's answers match them. Numbers stay the same across arguments.
  */
-function argumentChips(contention: Contention, usage: SourceUsage[], library: Source[]): CitationTarget[] {
-  const text = `${contention.claim} ${contention.reasoning} ${contention.evidence} ${contention.impact}`.toLocaleLowerCase();
+function argumentChips(argument: CaseArgument, usage: SourceUsage[], library: Source[]): CitationTarget[] {
+  const text = [argument.title, argument.point, argument.explanation, argument.evidence, argument.whyItMatters].filter(Boolean).join(' ').toLocaleLowerCase();
   const mentions = (title: string) => {
     const needle = title.trim().toLocaleLowerCase();
     return needle.length >= MIN_TITLE_MATCH && text.includes(needle);
@@ -62,7 +51,13 @@ function argumentChips(contention: Contention, usage: SourceUsage[], library: So
   return chips;
 }
 
-/** Every part of the website's GenerateResults, in mock 03's document style. */
+/**
+ * Every part of the website's GenerateResults, in mock 03's document style:
+ * the opening, the arguments (or R2's backed-up arguments, or a Conclusor's
+ * reasons why we win), "If they say… we answer…", the closing line and the
+ * sources. Older cases' sections come through `readCase`'s legacy part and
+ * show only when they have content, under the website's plain names.
+ */
 export function CaseDocument({
   output,
   library,
@@ -77,27 +72,41 @@ export function CaseDocument({
 }) {
   const { t } = useTranslation();
   const { colors } = useTheme();
+  const view = useMemo(() => readCase(output), [output]);
+  const { opening, legacy } = view;
   const chipsByArgument = useMemo(
-    () => output.contentions.map((contention) => argumentChips(contention, output.metadata?.sourceUsage ?? [], library)),
-    [output, library],
+    () => view.arguments.map((argument) => argumentChips(argument, output.metadata?.sourceUsage ?? [], library)),
+    [view, output, library],
   );
+  // Without web research, evidence is the model's own claim and is labelled that way, as on the website.
+  const researched = sources.length > 0;
 
-  const items = output.contentions.map((contention, index) => {
+  const items = view.arguments.map((argument, index) => {
     const chips = chipsByArgument[index];
-    const pieces = chips.length || (contention.evidence.trim() ? 1 : 0);
+    const pieces = chips.length || (argument.evidence ? 1 : 0);
     return {
+      // By position: a model can repeat an id, and two arguments must never open and close together.
       key: `${index}`,
-      title: contention.claim,
+      title: argument.title ?? argument.point,
       summary: pieces > 0
         ? t('mobile.results.evidenceCount', { count: pieces })
-        : contention.needsSource ? t('generateResults.needsSource') : t('mobile.results.noEvidence'),
+        : argument.needsSource ? t('generateResults.needsSource') : t('mobile.results.noEvidence'),
       body: (
         <>
-          {contention.needsSource ? <Tag label={t('generateResults.needsSource')} color={colors.warning} icon="alert" /> : null}
-          <Paragraph text={contention.reasoning} />
-          {contention.evidence.trim() ? <Quote text={contention.evidence} chips={chips} onCite={onCite} /> : null}
-          {contention.sourceQuery ? <Labeled label={t('generateResults.searchSuggestion')} text={contention.sourceQuery} /> : null}
-          {contention.impact ? <Labeled label={t('generateResults.impact')} text={contention.impact} /> : null}
+          {argument.needsSource ? <Tag label={t('generateResults.needsSource')} color={colors.warning} icon="alert" /> : null}
+          {argument.title && argument.point ? <Labeled label={t('generateResults.point')} text={argument.point} /> : null}
+          {argument.explanation ? <Labeled label={t('generateResults.explanation')} text={argument.explanation} /> : null}
+          {argument.evidence ? (
+            <View style={styles.evidence}>
+              <View style={styles.evidenceHead}>
+                <SubHeading>{t('generateResults.evidence').replace(/:$/, '')}</SubHeading>
+                {!researched && !argument.needsSource ? <Tag label={t('generateResults.unverified')} color={colors.warning} /> : null}
+              </View>
+              <Quote text={argument.evidence} chips={chips} onCite={onCite} />
+            </View>
+          ) : null}
+          {argument.sourceQuery ? <Labeled label={t('generateResults.searchSuggestion')} text={argument.sourceQuery} /> : null}
+          {argument.whyItMatters ? <Labeled label={t('generateResults.whyItMatters')} text={argument.whyItMatters} /> : null}
         </>
       ),
     };
@@ -111,75 +120,191 @@ export function CaseDocument({
     : null;
   const model = output.metadata?.model || output.metadata?.provider;
   const footer = [model ? t('generateResults.modelLabel', { value: model }) : null, duration].filter(Boolean).join(' • ');
-  const definitions = output.caseStructure.keyDefinitions ?? [];
+  const hasOpening = Boolean(opening.hook || opening.definition || opening.roadmap || legacy.framework || legacy.burdenOfProof || legacy.definitions.length);
+  const hasAnswers = view.ifTheySay.length > 0 || legacy.likelyArguments.length > 0 || legacy.weaknesses.length > 0 || legacy.clashes.length > 0;
 
   return (
     <>
-      <FramingCard
-        blocks={[
-          { label: t('generateResults.thesis'), text: output.caseStructure.thesis },
-          { label: t('generateResults.framework'), text: output.caseStructure.framework },
-        ].filter((block) => block.text?.trim())}
-      />
-
-      {output.exordio && (output.exordio.hook || output.exordio.transition) ? (
-        <DocSection title={t('generateResults.exordio')} description={t('generateResults.exordioDesc')}>
-          <SubHeading>{t('generateResults.hook')}</SubHeading>
-          <Text style={styles.italic} selectable>
-            {output.exordio.hook}
-          </Text>
-          <Divider />
-          <SubHeading>{t('generateResults.transition')}</SubHeading>
-          <Text style={styles.body} selectable>
-            {output.exordio.transition}
+      {researched ? null : (
+        <View style={[styles.caveat, { backgroundColor: colors.tile, borderColor: colors.tileBorder }]} testID="case-unresearched">
+          <Icon name="alert" color={colors.warning} size={16} />
+          <Text tone="secondary" style={styles.caveatText}>
+            {t('generateResults.unresearchedCaveat')}
           </Text>
+        </View>
+      )}
+
+      {hasOpening ? (
+        <DocSection title={t('generateResults.opening')} description={t('generateResults.openingDesc')} testID="case-opening">
+          {opening.hook ? <Quote text={opening.hook} italic /> : null}
+          {opening.definition ? <Labeled label={t('generateResults.definition')} text={opening.definition} /> : null}
+          {opening.roadmap ? (
+            <>
+              <SubHeading>{t('generateResults.roadmap')}</SubHeading>
+              <Text style={styles.body} selectable>
+                {opening.roadmap}
+              </Text>
+            </>
+          ) : null}
+          {legacy.framework ? (
+            <>
+              <SubHeading>{t('generateResults.legacyJudgeBy')}</SubHeading>
+              <Text style={styles.body} selectable>
+                {legacy.framework}
+              </Text>
+            </>
+          ) : null}
+          {legacy.burdenOfProof ? (
+            <>
+              <SubHeading>{t('generateResults.legacyMustShow')}</SubHeading>
+              <Text style={styles.body} selectable>
+                {legacy.burdenOfProof}
+              </Text>
+            </>
+          ) : null}
+          {legacy.definitions.length ? (
+            <>
+              <SubHeading>{t('generateResults.legacyDefinitions')}</SubHeading>
+              <Bullets items={legacy.definitions} />
+            </>
+          ) : null}
         </DocSection>
       ) : null}
 
-      <NumberedItems items={items} testID="case-arguments" outline />
-
-      <DocSection title={t('generateResults.caseStructure')} description={t('generateResults.caseStructureDesc')}>
-        <SubHeading>{t('generateResults.burdenOfProof')}</SubHeading>
-        <Paragraph text={output.caseStructure.burdenOfProof} tone="foreground" />
-        <Divider />
-        <SubHeading>{t('generateResults.keyDefinitions')}</SubHeading>
-        {definitions.length > 0 ? <Bullets items={definitions} /> : <Text tone="faint">{t('generateResults.noDefinitions')}</Text>}
-      </DocSection>
-
-      <DocSection title={t('generateResults.predictedOpponent')} description={t('generateResults.predictedOpponentDesc')}>
-        <SubHeading>{t('generateResults.likelyArguments')}</SubHeading>
-        <Bullets items={output.predictedOpponentCase.likelyArguments ?? []} color={colors.destructive} />
-        <Divider />
-        <SubHeading>{t('generateResults.strategicWeaknesses')}</SubHeading>
-        <Bullets items={output.predictedOpponentCase.strategicWeaknesses ?? []} color={colors.warning} />
-        <Divider />
-        <SubHeading>{t('generateResults.keyClashes')}</SubHeading>
-        <View style={styles.tags}>
-          {(output.predictedOpponentCase.keyClashes ?? []).map((clash, index) => (
-            <Tag key={index} label={clash} />
-          ))}
+      {items.length > 0 ? (
+        <View style={styles.group}>
+          <View style={styles.groupHead}>
+            <Text accessibilityRole="header" weight="bold" tone="heading" style={styles.groupTitle}>
+              {t('generateResults.arguments')}
+            </Text>
+            <Text tone="faint" style={styles.groupDescription}>
+              {t('generateResults.argumentCount', { count: items.length })}
+            </Text>
+          </View>
+          <NumberedItems items={items} testID="case-arguments" outline />
         </View>
-      </DocSection>
-
-      <DocSection title={t('generateResults.preparedCounters')} description={t('generateResults.preparedCountersDesc')}>
-        {output.counters.map((counter, index) => (
-          <View key={index} style={styles.counter}>
-            {index > 0 ? <Divider /> : null}
-            <View style={styles.counterTarget}>
-              <Tag label={t('generateResults.target')} color={colors.destructive} />
-              <Text weight="semibold" style={styles.counterTargetText} selectable>
-                {counter.targetArgument}
+      ) : null}
+
+      {view.reinforce.length > 0 ? (
+        <DocSection title={t('generateResults.reinforce')} description={t('generateResults.reinforceDesc')} testID="case-reinforce">
+          {view.reinforce.map((item, index) => (
+            <View key={index} style={styles.stack}>
+              {index > 0 ? <Divider /> : null}
+              {item.argument ? (
+                <Text weight="bold" style={styles.itemTitle} selectable>
+                  {item.argument}
+                </Text>
+              ) : null}
+              <Text style={styles.body} selectable>
+                {item.text}
               </Text>
             </View>
-            <Labeled label={t('generateResults.counter')} text={counter.counterpoint} />
-            <Callout title={t('generateResults.rebuttal').replace(/:$/, '')}>
-              <Text style={styles.body} selectable>
-                {counter.rebuttal}
+          ))}
+        </DocSection>
+      ) : null}
+
+      {view.whyWeWin.length > 0 ? (
+        <DocSection title={t('generateResults.whyWeWin')} description={t('generateResults.whyWeWinDesc')} testID="case-why-we-win">
+          {view.whyWeWin.map((reason, index) => (
+            <View key={index} style={styles.reason}>
+              <Text weight="bold" style={[styles.reasonNumber, { color: colors.primary }]}>
+                {index + 1}.
               </Text>
-            </Callout>
-          </View>
-        ))}
-      </DocSection>
+              <Text style={[styles.body, styles.flex]} selectable>
+                {reason}
+              </Text>
+            </View>
+          ))}
+        </DocSection>
+      ) : null}
+
+      {hasAnswers ? (
+        <DocSection title={t('generateResults.ifTheySay')} description={t('generateResults.ifTheySayDesc')} testID="case-if-they-say">
+          {view.ifTheySay.map((answer, index) => (
+            <View key={index} style={styles.stack}>
+              {index > 0 ? <Divider /> : null}
+              {answer.theySay ? (
+                <View style={styles.theySay}>
+                  <Tag label={t('generateResults.theySay')} color={colors.destructive} />
+                  <Text weight="semibold" style={styles.theySayText} selectable>
+                    {answer.theySay}
+                  </Text>
+                </View>
+              ) : null}
+              {answer.weAnswer ? <Labeled label={t('generateResults.weAnswer')} text={answer.weAnswer} /> : null}
+              {answer.inRound ? (
+                <Callout title={t('generateResults.legacySayItLike').replace(/:$/, '')}>
+                  <Text style={styles.body} selectable>
+                    {answer.inRound}
+                  </Text>
+                </Callout>
+              ) : null}
+              {answer.source ? (
+                <Text tone="faint" style={styles.small} selectable>
+                  <Text weight="semibold" tone="faint" style={styles.small}>
+                    {t('generateResults.source')}{' '}
+                  </Text>
+                  {answer.source}
+                </Text>
+              ) : null}
+            </View>
+          ))}
+          {legacy.likelyArguments.length ? (
+            <>
+              <SubHeading>{t('generateResults.legacyAlsoSay')}</SubHeading>
+              <Bullets items={legacy.likelyArguments} color={colors.destructive} />
+            </>
+          ) : null}
+          {legacy.weaknesses.length ? (
+            <>
+              <SubHeading>{t('generateResults.legacyWeakSpots')}</SubHeading>
+              <Bullets items={legacy.weaknesses} color={colors.warning} />
+            </>
+          ) : null}
+          {legacy.clashes.length ? (
+            <>
+              <SubHeading>{t('generateResults.legacyDecidingPoints')}</SubHeading>
+              <Bullets items={legacy.clashes} />
+            </>
+          ) : null}
+        </DocSection>
+      ) : null}
+
+      {view.closingLine ? (
+        <DocSection title={t('generateResults.closingLine')} description={t('generateResults.closingLineDesc')} testID="case-closing">
+          <Text weight="semibold" style={styles.closing} selectable>
+            {view.closingLine}
+          </Text>
+        </DocSection>
+      ) : null}
+
+      {view.sources.length > 0 ? (
+        <DocSection title={t('generateResults.sources')} description={t('generateResults.sourcesDesc')} testID="case-sources">
+          {view.sources.map((source, index) => {
+            const url = source.url;
+            const label = [sourceLabel(source), source.claim].filter(Boolean).join(' – ');
+            return url ? (
+              <Pressable
+                key={index}
+                accessibilityRole="link"
+                accessibilityHint={hostOf(url)}
+                onPress={() => void WebBrowser.openBrowserAsync(url)}
+                style={({ pressed }) => [styles.caseSource, pressed && styles.pressed]}>
+                <Text style={[styles.body, styles.flex]}>
+                  <Text weight="semibold">{sourceLabel(source)}</Text>
+                  {source.claim ? `${source.org ? ' – ' : ''}${source.claim}` : ''}
+                  <Text style={{ color: colors.primary }}>{` – ${hostOf(url)}`}</Text>
+                </Text>
+                <Icon name="globe" color={colors.primary} size={16} />
+              </Pressable>
+            ) : (
+              <Text key={index} style={styles.body} selectable>
+                {label}
+              </Text>
+            );
+          })}
+        </DocSection>
+      ) : null}
 
       <ResearchedSources sources={sources} />
 
@@ -227,11 +352,24 @@ export function ResearchedSources({ sources }: { sources: DiscoveredSource[] })
 
 const styles = StyleSheet.create({
   body: { fontSize: 15.5, lineHeight: 22 },
-  italic: { fontSize: 15.5, lineHeight: 22, fontStyle: 'italic' },
-  tags: { flexDirection: 'row', flexWrap: 'wrap', gap: 6 },
-  counter: { gap: 8 },
-  counterTarget: { flexDirection: 'row', alignItems: 'flex-start', gap: 8 },
-  counterTargetText: { flex: 1, fontSize: 15.5, lineHeight: 21 },
+  flex: { flex: 1 },
+  small: { fontSize: 13.5, lineHeight: 19 },
+  caveat: { flexDirection: 'row', alignItems: 'flex-start', gap: 8, borderWidth: 2, borderRadius: 14, padding: 12 },
+  caveatText: { flex: 1, fontSize: 14, lineHeight: 20 },
+  group: { gap: 8 },
+  groupHead: { gap: 2, marginHorizontal: 2 },
+  groupTitle: { fontSize: 19, lineHeight: 25, letterSpacing: -0.2 },
+  groupDescription: { fontSize: 14, lineHeight: 19 },
+  evidence: { gap: 6 },
+  evidenceHead: { flexDirection: 'row', alignItems: 'center', gap: 8, flexWrap: 'wrap' },
+  stack: { gap: 8 },
+  itemTitle: { fontSize: 16, lineHeight: 22 },
+  reason: { flexDirection: 'row', alignItems: 'flex-start', gap: 8 },
+  reasonNumber: { fontSize: 15.5, lineHeight: 22, minWidth: 20 },
+  theySay: { flexDirection: 'row', alignItems: 'flex-start', gap: 8, flexWrap: 'wrap' },
+  theySayText: { flex: 1, minWidth: 160, fontSize: 15.5, lineHeight: 21 },
+  closing: { fontSize: 16.5, lineHeight: 24 },
+  caseSource: { flexDirection: 'row', alignItems: 'center', gap: 8, paddingVertical: 4 },
   footer: { fontSize: 13, textAlign: 'center', marginTop: 6 },
   source: { flexDirection: 'row', alignItems: 'center', gap: 10, paddingVertical: 8 },
   sourceText: { flex: 1, gap: 2 },
diff --git a/apps/mobile/src/components/celebration.tsx b/apps/mobile/src/components/celebration.tsx
new file mode 100644
index 000000000..f9afcfad7
--- /dev/null
+++ b/apps/mobile/src/components/celebration.tsx
@@ -0,0 +1,355 @@
+import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react';
+import { useTranslation } from 'react-i18next';
+import { AccessibilityInfo, Pressable, StyleSheet, View } from 'react-native';
+import Animated, {
+  Easing,
+  ReduceMotion,
+  useAnimatedStyle,
+  useSharedValue,
+  withDelay,
+  withSpring,
+  withTiming,
+  type SharedValue,
+} from 'react-native-reanimated';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+
+import { PrimaryButton } from './buttons';
+import { Owl } from './owl';
+import { SuccessCheck } from './success-check';
+import { Text } from './text';
+
+import { haptics } from '@/lib/haptics';
+import { palette, radius } from '@/theme/colors';
+import { DURATION, EASE, SPRING, staggerDelay, useReduceMotion } from '@/theme/motion';
+import { useTheme } from '@/theme/use-theme';
+
+/** A number the celebration counts up to, with the label the result already uses for it. */
+type CelebrationStat = {
+  key: string;
+  label: string;
+  value: number;
+  /** How the number reads, such as seconds as 4:05; plain digits by default. */
+  format?: (value: number) => string;
+};
+
+/** How long the overlay stays before it goes on its own; longer when nothing moves, never under two seconds. */
+const HOLD_MS = 2400;
+const HOLD_REDUCED_MS = 3000;
+const COUNT_MS = 600;
+const BURST_MS = 1200;
+const PIECES = 36;
+// Pixels per second squared: the burst rises, slows and falls back past the owl within the burst.
+const GRAVITY = 1500;
+
+const plain = (value: number) => String(value);
+
+/**
+ * Results that should celebrate when their document opens: Generate marks the case it just
+ * made, and the case screen takes the mark once, so reopening a saved case never celebrates.
+ */
+const pending = new Set<string>();
+
+export function markCelebration(key: string) {
+  pending.add(key);
+}
+
+/** Whether `key` was just finished; the mark is cleared by `clearCelebration` once the screen has read it. */
+export function hasCelebration(key: string | undefined): boolean {
+  return Boolean(key && pending.has(key));
+}
+
+export function clearCelebration(key: string | undefined) {
+  if (key) pending.delete(key);
+}
+
+/**
+ * The moment a round, a practice or a case is finished, over the result it covers: Ollie cheers,
+ * confetti bursts in the brand colours, the mint check pops and the stats count up. It goes after
+ * a few seconds or on any tap, and lets the screen underneath take touches from that moment.
+ * VoiceOver hears the title and the stats once and finds one button that dismisses it, which then
+ * stays until it is pressed. Under Reduce Motion it fades in with its final numbers, with no
+ * confetti and no cheer. `haptic={false}` where the result's arrival already tapped success.
+ */
+export function Celebration({
+  eyebrow,
+  title,
+  stats,
+  onDone,
+  haptic = true,
+}: {
+  eyebrow?: string;
+  title: string;
+  stats: CelebrationStat[];
+  onDone: () => void;
+  haptic?: boolean;
+}) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  const insets = useSafeAreaInsets();
+  const reduce = useReduceMotion();
+  const shown = stats.slice(0, 3);
+  const [leaving, setLeaving] = useState(false);
+  const fade = useSharedValue(0);
+  const rise = useSharedValue(reduce ? 1 : 0);
+  const onDoneRef = useRef(onDone);
+  const timers = useRef<ReturnType<typeof setTimeout>[]>([]);
+  const gone = useRef(false);
+
+  useEffect(() => {
+    onDoneRef.current = onDone;
+  }, [onDone]);
+
+  const dismiss = useCallback(() => {
+    if (gone.current) return;
+    gone.current = true;
+    setLeaving(true);
+    // A fade is not motion, so it plays under Reduce Motion too.
+    fade.set(withTiming(0, { duration: DURATION.fast, easing: EASE.accelerate, reduceMotion: ReduceMotion.Never }));
+    timers.current.push(setTimeout(() => onDoneRef.current(), DURATION.fast));
+  }, [fade]);
+
+  const announcement = [eyebrow, title, ...shown.map((stat) => `${stat.label}: ${(stat.format ?? plain)(stat.value)}`)].filter(Boolean).join('. ');
+
+  // Once per mount: arrive, announce, and go on its own unless VoiceOver is reading it.
+  useEffect(() => {
+    fade.set(withTiming(1, { duration: DURATION.fast, easing: EASE.decelerate, reduceMotion: ReduceMotion.Never }));
+    if (!reduce) rise.set(withSpring(1, SPRING.pop));
+    AccessibilityInfo.announceForAccessibility(announcement);
+    let cancelled = false;
+    AccessibilityInfo.isScreenReaderEnabled()
+      .then((reading) => {
+        if (!cancelled && !reading) timers.current.push(setTimeout(dismiss, reduce ? HOLD_REDUCED_MS : HOLD_MS));
+      })
+      .catch((): void => {});
+    const pendingTimers = timers.current;
+    return () => {
+      cancelled = true;
+      pendingTimers.forEach(clearTimeout);
+    };
+    // The moment plays once; a re-render of the screen underneath must not replay it.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const overlay = useAnimatedStyle(() => ({ opacity: fade.value }));
+  const card = useAnimatedStyle(() => ({
+    transform: [{ translateY: (1 - rise.value) * 24 }, { scale: 0.92 + 0.08 * rise.value }],
+  }));
+
+  return (
+    // Modal for VoiceOver: the screen underneath is skipped until the celebration goes.
+    <Animated.View style={[StyleSheet.absoluteFill, styles.root, overlay]} pointerEvents={leaving ? 'none' : 'auto'} accessibilityViewIsModal={!leaving}>
+      <Pressable
+        accessible
+        accessibilityRole="button"
+        accessibilityLabel={announcement}
+        accessibilityHint={t('debate.continue')}
+        onAccessibilityEscape={dismiss}
+        onPress={dismiss}
+        testID="celebration"
+        style={[StyleSheet.absoluteFill, styles.scrim, { backgroundColor: colors.background }]}>
+        <Animated.View style={[styles.column, card]}>
+          <View style={styles.hero}>
+            <Owl pose="celebrating" size={148} gesture={reduce ? false : 'cheer'} breathe={false} />
+            <View style={styles.check}>
+              <SuccessCheck size={46} delay={reduce ? 0 : 220} haptic={haptic} />
+            </View>
+            {reduce ? null : <Confetti />}
+          </View>
+          <View style={styles.heading}>
+            {eyebrow ? (
+              <Text weight="semibold" tone="secondary" style={styles.eyebrow} numberOfLines={1}>
+                {eyebrow}
+              </Text>
+            ) : null}
+            {/* A case's title is its motion, so a long one steps down a size. */}
+            <Text weight="display" style={[styles.title, title.length > 48 && styles.titleLong]} numberOfLines={4}>
+              {title}
+            </Text>
+          </View>
+          {shown.length > 0 ? (
+            <View style={styles.stats}>
+              {shown.map((stat, index) => (
+                <StatTile key={stat.key} stat={stat} index={index} animate={!reduce} last={index === shown.length - 1} />
+              ))}
+            </View>
+          ) : null}
+        </Animated.View>
+        <View style={[styles.action, { bottom: insets.bottom + 18 }]}>
+          <View style={styles.actionColumn}>
+            <PrimaryButton label={t('debate.continue')} onPress={dismiss} testID="celebration-continue" />
+          </View>
+        </View>
+      </Pressable>
+    </Animated.View>
+  );
+}
+
+/** One stat: the tile pops in after the title, then its number counts up; the last one ticks as it lands. */
+function StatTile({ stat, index, animate, last }: { stat: CelebrationStat; index: number; animate: boolean; last: boolean }) {
+  const { colors } = useTheme();
+  const delay = 260 + staggerDelay(index) * 2;
+  const pop = useSharedValue(animate ? 0 : 1);
+  useEffect(() => {
+    if (animate) pop.set(withDelay(delay, withSpring(1, SPRING.pop)));
+  }, [animate, delay, pop]);
+  const style = useAnimatedStyle(() => ({
+    opacity: Math.min(1, pop.value * 2),
+    transform: [{ translateY: (1 - pop.value) * 14 }, { scale: 0.8 + 0.2 * pop.value }],
+  }));
+  return (
+    <Animated.View style={[styles.tile, { backgroundColor: colors.tile, borderColor: colors.tileBorder }, style]}>
+      <CountUp value={stat.value} format={stat.format ?? plain} delay={delay + 80} animate={animate} tick={last} />
+      <Text tone="secondary" style={styles.tileLabel} numberOfLines={2}>
+        {stat.label}
+      </Text>
+    </Animated.View>
+  );
+}
+
+/** The number alone re-renders while it counts, on the display's frames, eased out over 600 ms. */
+function CountUp({ value, format, delay, animate, tick }: { value: number; format: (value: number) => string; delay: number; animate: boolean; tick: boolean }) {
+  const { colors } = useTheme();
+  const [counted, setCurrent] = useState(animate ? 0 : value);
+  // Reduce Motion turned on mid-count (or never counting) shows the final number, never a frozen one.
+  const current = animate ? counted : value;
+  useEffect(() => {
+    if (!animate) return;
+    let frame = 0;
+    let start = 0;
+    const step = (now: number) => {
+      if (!start) start = now;
+      const progress = Math.min(1, (now - start) / COUNT_MS);
+      setCurrent(Math.round(value * (1 - Math.pow(1 - progress, 3))));
+      if (progress < 1) frame = requestAnimationFrame(step);
+      else if (tick) haptics.select();
+    };
+    const timer = setTimeout(() => {
+      frame = requestAnimationFrame(step);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+      cancelAnimationFrame(frame);
+    };
+  }, [animate, delay, tick, value]);
+  return (
+    <Text weight="displayBold" style={[styles.tileValue, { color: colors.primary }]} maxFontSizeMultiplier={1.4} numberOfLines={1}>
+      {format(current)}
+    </Text>
+  );
+}
+
+type Piece = { vx: number; vy: number; spin: number; flip: number; start: number; color: string; width: number; height: number; round: number };
+
+/** A burst of rounded pieces from behind the owl: random angles and speeds, gravity, a spin and a flip. */
+function burst(colors: string[]): Piece[] {
+  return Array.from({ length: PIECES }, (_, index) => {
+    // An upward cone, a little wider than straight up, so pieces arc out over both sides.
+    const angle = (-160 + Math.random() * 140) * (Math.PI / 180);
+    const speed = 420 + Math.random() * 420;
+    const dot = index % 4 === 0;
+    const width = dot ? 8 : 7 + Math.random() * 3;
+    const height = dot ? 8 : 11 + Math.random() * 4;
+    return {
+      vx: Math.cos(angle) * speed,
+      vy: Math.sin(angle) * speed,
+      spin: (Math.random() - 0.5) * 1440,
+      flip: 6 + Math.random() * 9,
+      start: Math.random() * 0.08,
+      color: colors[index % colors.length],
+      width,
+      height,
+      round: dot ? 4 : 2.5,
+    };
+  });
+}
+
+function Confetti() {
+  const { colors } = useTheme();
+  // Brand blue, mint, beak gold and the light plume blue; one set of throws for this burst's lifetime.
+  const [pieces] = useState(() => burst([colors.primaryFill, colors.successFill, colors.accent, palette.light.chipSelectedBorder]));
+  const [done, setDone] = useState(false);
+  const progress = useSharedValue(0);
+  useEffect(() => {
+    progress.set(withTiming(1, { duration: BURST_MS, easing: Easing.linear }));
+    const timer = setTimeout(() => setDone(true), BURST_MS + 100);
+    return () => clearTimeout(timer);
+  }, [progress]);
+  if (done) return null;
+  return (
+    <View style={styles.emitter} pointerEvents="none">
+      {pieces.map((piece, index) => (
+        <ConfettiPiece key={index} piece={piece} progress={progress} />
+      ))}
+    </View>
+  );
+}
+
+function ConfettiPiece({ piece, progress }: { piece: Piece; progress: SharedValue<number> }) {
+  const style = useAnimatedStyle(() => {
+    const seconds = Math.max(0, progress.value * (BURST_MS / 1000) - piece.start);
+    // Air slows the sideways throw; gravity pulls the rise back down.
+    const x = piece.vx * seconds * (1 - Math.min(seconds, 1.2) * 0.32);
+    const y = piece.vy * seconds + 0.5 * GRAVITY * seconds * seconds;
+    const life = progress.value;
+    return {
+      opacity: life >= 1 ? 0 : life < 0.7 ? 1 : 1 - (life - 0.7) / 0.3,
+      transform: [
+        { translateX: x },
+        { translateY: y },
+        { rotate: `${piece.spin * seconds}deg` },
+        { scaleX: Math.cos(piece.flip * seconds) },
+      ],
+    };
+  });
+  return (
+    <Animated.View
+      style={[
+        styles.piece,
+        { width: piece.width, height: piece.height, marginLeft: -piece.width / 2, marginTop: -piece.height / 2, borderRadius: piece.round, backgroundColor: piece.color },
+        style,
+      ]}
+    />
+  );
+}
+
+/**
+ * Content that arrives with a short pop, `index` steps after the first, once `hold` is off: a
+ * scorecard's cards wait under the celebration and arrive as it goes. Under Reduce Motion it is
+ * simply there.
+ */
+export function PopIn({ index = 0, hold = false, children }: { index?: number; hold?: boolean; children: ReactNode }) {
+  const reduce = useReduceMotion();
+  const pop = useSharedValue(reduce ? 1 : 0);
+  useEffect(() => {
+    if (reduce) {
+      pop.set(1);
+      return;
+    }
+    if (!hold) pop.set(withDelay(staggerDelay(index), withTiming(1, { duration: 260, easing: EASE.overshoot })));
+  }, [hold, index, pop, reduce]);
+  const style = useAnimatedStyle(() => ({
+    opacity: Math.min(1, pop.value * 1.5),
+    transform: [{ translateY: (1 - pop.value) * 12 }, { scale: 0.96 + 0.04 * pop.value }],
+  }));
+  return <Animated.View style={style}>{children}</Animated.View>;
+}
+
+const styles = StyleSheet.create({
+  root: { zIndex: 50 },
+  scrim: { alignItems: 'center', justifyContent: 'center', paddingHorizontal: 24 },
+  column: { width: '100%', maxWidth: 420, alignItems: 'center', gap: 18 },
+  hero: { width: 148, height: 148, alignItems: 'center', justifyContent: 'center' },
+  check: { position: 'absolute', right: -6, bottom: 4 },
+  emitter: { position: 'absolute', left: '50%', top: '42%', width: 0, height: 0 },
+  piece: { position: 'absolute', left: 0, top: 0 },
+  heading: { alignItems: 'center', gap: 4 },
+  eyebrow: { fontSize: 15, textAlign: 'center' },
+  title: { fontSize: 30, lineHeight: 36, letterSpacing: -0.6, textAlign: 'center' },
+  titleLong: { fontSize: 22, lineHeight: 28, letterSpacing: -0.3 },
+  stats: { flexDirection: 'row', gap: 10, alignSelf: 'stretch', justifyContent: 'center' },
+  tile: { flex: 1, maxWidth: 136, borderWidth: 2, borderRadius: radius.tile, paddingHorizontal: 10, paddingVertical: 12, alignItems: 'center', gap: 2 },
+  tileValue: { fontSize: 30, lineHeight: 36, fontVariant: ['tabular-nums'] },
+  tileLabel: { fontSize: 13.5, lineHeight: 18, textAlign: 'center' },
+  action: { position: 'absolute', left: 0, right: 0, alignItems: 'center' },
+  actionColumn: { width: '100%', maxWidth: 420, paddingHorizontal: 24 },
+});
diff --git a/apps/mobile/src/components/claim-panel.tsx b/apps/mobile/src/components/claim-panel.tsx
index b1dc0c1be..b2b534f26 100644
--- a/apps/mobile/src/components/claim-panel.tsx
+++ b/apps/mobile/src/components/claim-panel.tsx
@@ -126,7 +126,7 @@ export function ClaimPanel({
     return (
       <Container testID="claim-sheet">
         {header}
-        <Text weight="semibold" style={styles.section}>
+        <Text accessibilityRole="header" weight="semibold" style={styles.section}>
           {t('flowchart.editNode')}
         </Text>
         <CardForm
@@ -148,7 +148,7 @@ export function ClaimPanel({
       <Container testID="claim-sheet">
         {header}
         <View style={styles.block}>
-          <Text weight="semibold" style={styles.section}>
+          <Text accessibilityRole="header" weight="semibold" style={styles.section}>
             {t('mobile.flowchart.linkTitle')}
           </Text>
           <Text tone="secondary" style={styles.body}>
@@ -215,7 +215,7 @@ export function ClaimPanel({
       </View>
       {links.length > 0 ? (
         <View style={styles.block}>
-          <Text weight="semibold" style={styles.section}>
+          <Text accessibilityRole="header" weight="semibold" style={styles.section}>
             {t('mobile.flowchart.linksTitle')}
           </Text>
           <View style={[styles.list, { backgroundColor: flow.cardFill, borderColor: colors.border }]}>
diff --git a/apps/mobile/src/components/crossfire-views.tsx b/apps/mobile/src/components/crossfire-views.tsx
index 9cc3734b2..80409ab1d 100644
--- a/apps/mobile/src/components/crossfire-views.tsx
+++ b/apps/mobile/src/components/crossfire-views.tsx
@@ -2,6 +2,7 @@ import type { CrossfireDebrief, CrossfireTurn } from '@debatelab/core/crossfire/
 import { useTranslation } from 'react-i18next';
 import { Pressable, StyleSheet, View } from 'react-native';
 
+import { PopIn } from './celebration';
 import { Callout, DocSection, Paragraph, Tag } from './document';
 import { Icon } from './icon';
 import { Text } from './text';
@@ -163,47 +164,64 @@ function Findings({ title, items }: { title: string; items: { turnIds: string[];
   );
 }
 
-/** The debrief as a document (mock 03's style), in the website's order. */
-export function CrossfireDebriefDocument({ debrief }: { debrief: CrossfireDebrief }) {
+/**
+ * The debrief as a document (mock 03's style), in the website's order. Its parts pop in one
+ * after another, once `holdEntrance` (a celebration over them) is off.
+ */
+export function CrossfireDebriefDocument({ debrief, holdEntrance = false }: { debrief: CrossfireDebrief; holdEntrance?: boolean }) {
   const { t } = useTranslation();
   return (
     <View style={styles.debrief} testID="crossfire-debrief">
-      <Findings title={t('crossfire.concessionsSecured')} items={debrief.concessionsSecured} />
-      <Findings title={t('crossfire.controlledQuestions')} items={debrief.controlledQuestions} />
-      <Findings title={t('crossfire.weakOrRepetitiveQuestions')} items={debrief.weakOrRepetitiveQuestions} />
-      <Findings title={t('crossfire.evasiveOrIncompleteAnswers')} items={debrief.evasiveOrIncompleteAnswers} />
-      <Findings title={t('crossfire.missedFollowUps')} items={debrief.missedFollowUps} />
-      <DocSection title={t('crossfire.betterFollowUpQuestions')}>
-        {debrief.betterFollowUpQuestions.length === 0 ? (
-          <Text tone="faint" style={styles.none}>
-            {t('crossfire.noGroundedFinding')}
-          </Text>
-        ) : (
-          debrief.betterFollowUpQuestions.map((item, index) => (
-            <View key={index} style={styles.finding}>
-              <Text weight="semibold" style={styles.question} selectable>
-                {item.question}
-              </Text>
-              <Paragraph text={item.reason} />
-              <TurnRefs turnIds={item.turnIds} />
-            </View>
-          ))
-        )}
-      </DocSection>
-      <View style={styles.strongest}>
-        <Callout title={t('crossfire.strongestExchange')}>
-          {debrief.strongestExchange ? (
-            <View style={styles.finding}>
-              <Paragraph text={debrief.strongestExchange.claim} tone="foreground" />
-              <TurnRefs turnIds={debrief.strongestExchange.turnIds} />
-            </View>
-          ) : (
+      <PopIn index={0} hold={holdEntrance}>
+        <Findings title={t('crossfire.concessionsSecured')} items={debrief.concessionsSecured} />
+      </PopIn>
+      <PopIn index={1} hold={holdEntrance}>
+        <Findings title={t('crossfire.controlledQuestions')} items={debrief.controlledQuestions} />
+      </PopIn>
+      <PopIn index={2} hold={holdEntrance}>
+        <Findings title={t('crossfire.weakOrRepetitiveQuestions')} items={debrief.weakOrRepetitiveQuestions} />
+      </PopIn>
+      <PopIn index={3} hold={holdEntrance}>
+        <Findings title={t('crossfire.evasiveOrIncompleteAnswers')} items={debrief.evasiveOrIncompleteAnswers} />
+      </PopIn>
+      <PopIn index={4} hold={holdEntrance}>
+        <Findings title={t('crossfire.missedFollowUps')} items={debrief.missedFollowUps} />
+      </PopIn>
+      <PopIn index={5} hold={holdEntrance}>
+        <DocSection title={t('crossfire.betterFollowUpQuestions')}>
+          {debrief.betterFollowUpQuestions.length === 0 ? (
             <Text tone="faint" style={styles.none}>
               {t('crossfire.noGroundedFinding')}
             </Text>
+          ) : (
+            debrief.betterFollowUpQuestions.map((item, index) => (
+              <View key={index} style={styles.finding}>
+                <Text weight="semibold" style={styles.question} selectable>
+                  {item.question}
+                </Text>
+                <Paragraph text={item.reason} />
+                <TurnRefs turnIds={item.turnIds} />
+              </View>
+            ))
           )}
-        </Callout>
-      </View>
+        </DocSection>
+      </PopIn>
+      <PopIn index={6} hold={holdEntrance}>
+        <View style={styles.strongest}>
+          <Callout title={t('crossfire.strongestExchange')}>
+            {debrief.strongestExchange ? (
+              <View style={styles.finding}>
+                <Paragraph text={debrief.strongestExchange.claim} tone="foreground" />
+                <TurnRefs turnIds={debrief.strongestExchange.turnIds} />
+              </View>
+            ) : (
+              <Text tone="faint" style={styles.none}>
+                {t('crossfire.noGroundedFinding')}
+              </Text>
+            )}
+          </Callout>
+        </View>
+      </PopIn>
     </View>
   );
 }
diff --git a/apps/mobile/src/components/document-status.tsx b/apps/mobile/src/components/document-status.tsx
index 52cebe2d7..467ff7fc5 100644
--- a/apps/mobile/src/components/document-status.tsx
+++ b/apps/mobile/src/components/document-status.tsx
@@ -1,17 +1,18 @@
 import { useTranslation } from 'react-i18next';
-import { ActivityIndicator, StyleSheet, View } from 'react-native';
+import { StyleSheet, View } from 'react-native';
 
+import { Skeleton } from './skeleton';
 import { Text } from './text';
 
 /** What a document screen shows before its result is ready, or when it cannot be shown. */
 export function DocumentStatus({ status, incomplete }: { status: 'loading' | 'missing' | 'failed' | 'incomplete'; incomplete?: { title: string; body: string } }) {
   const { t } = useTranslation();
-  if (status === 'loading') return <ActivityIndicator style={styles.loading} accessibilityRole="progressbar" accessibilityLabel={t('common.loading')} />;
+  if (status === 'loading') return <DocumentSkeleton />;
   return (
     <View style={styles.box} accessibilityRole="alert">
       {status === 'incomplete' && incomplete ? (
         <>
-          <Text weight="semibold" style={styles.title}>
+          <Text accessibilityRole="header" weight="semibold" style={styles.title}>
             {incomplete.title}
           </Text>
           <Text tone="secondary" style={styles.body}>
@@ -27,8 +28,33 @@ export function DocumentStatus({ status, incomplete }: { status: 'loading' | 'mi
   );
 }
 
+// Line widths for the paragraphs, so the page reads as text, not as a grid of bars.
+const PARAGRAPHS = [
+  ['100%', '96%', '88%', '62%'],
+  ['100%', '92%', '97%', '48%'],
+  ['98%', '90%', '70%'],
+] as const;
+
+/** A document loading in its own shape: a heading, then paragraphs. It is the loading indicator. */
+function DocumentSkeleton() {
+  const { t } = useTranslation();
+  return (
+    <View accessible accessibilityRole="progressbar" accessibilityLabel={t('common.loading')} style={styles.loading}>
+      <Skeleton width="72%" height={24} round={8} />
+      {PARAGRAPHS.map((lines, paragraph) => (
+        <View key={paragraph} style={styles.paragraph}>
+          {lines.map((width, line) => (
+            <Skeleton key={line} width={width} height={13} />
+          ))}
+        </View>
+      ))}
+    </View>
+  );
+}
+
 const styles = StyleSheet.create({
-  loading: { marginTop: 48 },
+  loading: { marginTop: 20, gap: 22 },
+  paragraph: { gap: 10 },
   box: { gap: 6, marginTop: 24 },
   title: { fontSize: 18 },
   body: { fontSize: 16, lineHeight: 22 },
diff --git a/apps/mobile/src/components/document.tsx b/apps/mobile/src/components/document.tsx
index d810837c0..37b792fc7 100644
--- a/apps/mobile/src/components/document.tsx
+++ b/apps/mobile/src/components/document.tsx
@@ -1,8 +1,9 @@
 import { Children, Fragment, isValidElement, useRef, useState, type ReactNode } from 'react';
-import { Pressable, ScrollView, StyleSheet, View, useWindowDimensions } from 'react-native';
+import { Pressable, ScrollView, StyleSheet, View } from 'react-native';
 import Svg, { Defs, LinearGradient, Rect, Stop } from 'react-native-svg';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
+import { SuccessCheck } from './success-check';
 import { Chip, CiteBadge } from './chip';
 import type { CitationTarget } from './citation-target';
 import { Icon } from './icon';
@@ -11,7 +12,7 @@ import { OfflineNotice } from './offline-notice';
 import { OutlineProvider, OutlineRail, useOutlineAnchor, useOutlineItems, useOutlineRail } from './outline';
 import { Text } from './text';
 
-import { RAIL_MIN_WIDTH, RAIL_WIDTH, useHeaderCover, useLayoutClass } from '@/lib/layout';
+import { RAIL_MIN_WIDTH, RAIL_WIDTH, useContentWidth, useHeaderCover, useLayoutClass } from '@/lib/layout';
 import { radius } from '@/theme/colors';
 import { useTheme } from '@/theme/use-theme';
 
@@ -77,9 +78,7 @@ function DocumentNotice({ text, tone = 'info', bottom }: { text: string; tone?:
       testID="document-notice">
       {/* As the website's success toast: the mint check carries the meaning, the text stays readable. */}
       {success ? (
-        <View style={[styles.noticeCheck, { backgroundColor: colors.successFill }]}>
-          <Icon name="check" color={colors.successTint} size={15} />
-        </View>
+        <SuccessCheck size={24} haptic={false} />
       ) : null}
       <Text weight={success ? 'semibold' : 'regular'} style={[styles.noticeText, { color: success ? colors.success : colors.background }]}>
         {text}
@@ -114,7 +113,7 @@ export function DocumentScreen({
   const { colors } = useTheme();
   const insets = useSafeAreaInsets();
   const layout = useLayoutClass();
-  const { width } = useWindowDimensions();
+  const width = useContentWidth();
   const bottom = Math.max(insets.bottom - 6, 14);
   // The bar grows when a label wraps, so the page and the notice clear its measured height.
   const [barHeight, setBarHeight] = useState(PINNED_FADE + PINNED_HEIGHT + bottom);
@@ -128,8 +127,12 @@ export function DocumentScreen({
   return (
     <View style={[styles.root, { backgroundColor: colors.card }]} testID={testID}>
       {header}
+      {/* Tool forms are documents too: fields scroll clear of the keyboard. */}
       <ScrollView
         contentInsetAdjustmentBehavior="automatic"
+        automaticallyAdjustKeyboardInsets
+        keyboardShouldPersistTaps="handled"
+        keyboardDismissMode="interactive"
         contentContainerStyle={[styles.content, { paddingBottom: actions ? barHeight + 8 : 16 + bottom }]}>
         <OfflineNotice />
         {children}
@@ -176,6 +179,9 @@ function RailDocument({
           <ScrollView
             ref={scroll}
             contentInsetAdjustmentBehavior="automatic"
+            automaticallyAdjustKeyboardInsets
+            keyboardShouldPersistTaps="handled"
+            keyboardDismissMode="interactive"
             scrollEventThrottle={32}
             onScroll={(event) => rail.onScroll(event.nativeEvent.contentOffset.y)}
             onContentSizeChange={rail.measure}>
diff --git a/apps/mobile/src/components/empty-state.tsx b/apps/mobile/src/components/empty-state.tsx
index 119579234..3b488a805 100644
--- a/apps/mobile/src/components/empty-state.tsx
+++ b/apps/mobile/src/components/empty-state.tsx
@@ -11,7 +11,7 @@ export function EmptyState({ pose, title, description, children }: { pose: OwlPo
     <Card style={styles.card}>
       <Owl pose={pose} size={88} />
       <View style={styles.text}>
-        <Text weight="bold" tone="heading" style={styles.title}>
+        <Text accessibilityRole="header" weight="bold" tone="heading" style={styles.title}>
           {title}
         </Text>
         {description ? (
diff --git a/apps/mobile/src/components/factoids-document.tsx b/apps/mobile/src/components/factoids-document.tsx
index 197fe076b..4a0b27079 100644
--- a/apps/mobile/src/components/factoids-document.tsx
+++ b/apps/mobile/src/components/factoids-document.tsx
@@ -50,9 +50,11 @@ export function FactoidsDocument({
   /** Researched sources, known only for factoids found in this session. */
   sources: DiscoveredSource[];
   onCite: (target: CitationTarget) => void;
-  onSave: (factoid: Factoid) => void;
-  onSearch: (query: string) => void;
-  saving: boolean;
+  /** Absent on a shared copy: the reader has no Library to keep it in. */
+  onSave?: (factoid: Factoid) => void;
+  /** Absent on a shared copy: the suggestions are shown as text. */
+  onSearch?: (query: string) => void;
+  saving?: boolean;
 }) {
   const { t } = useTranslation();
   const { colors } = useTheme();
@@ -90,14 +92,16 @@ export function FactoidsDocument({
             <Text style={[styles.unverifiedUrl, { color: colors.warning }]}>{t('factoidsResults.urlNeedsVerification')}</Text>
           )}
           <Labeled label={t('factoidsResults.howToUse')} text={factoid.howToUse} />
-          <View style={styles.saveRow}>
-            <TextButton
-              label={t('factoidsResults.saveToLibrary')}
-              accessibilityLabel={t('factoidsResults.saveClaimToLibrary', { claim: factoid.shortClaim })}
-              onPress={() => onSave(factoid)}
-              disabled={saving}
-            />
-          </View>
+          {onSave ? (
+            <View style={styles.saveRow}>
+              <TextButton
+                label={t('factoidsResults.saveToLibrary')}
+                accessibilityLabel={t('factoidsResults.saveClaimToLibrary', { claim: factoid.shortClaim })}
+                onPress={() => onSave(factoid)}
+                disabled={saving}
+              />
+            </View>
+          ) : null}
         </>
       ),
     };
@@ -146,7 +150,13 @@ export function FactoidsDocument({
 
       {suggestions.length > 0 ? (
         <DocSection title={t('factoidsResults.findMore')} description={t('factoidsResults.findMoreDesc')} testID="factoids-suggestions">
-          {suggestions.map((query, index) => (
+          {suggestions.map((query, index) => !onSearch ? (
+            <View key={index} style={[styles.suggestion, { backgroundColor: colors.background }]}>
+              <Text style={styles.suggestionText} selectable>
+                {query}
+              </Text>
+            </View>
+          ) : (
             <Pressable
               key={index}
               accessibilityRole="button"
diff --git a/apps/mobile/src/components/field.tsx b/apps/mobile/src/components/field.tsx
index 2a57d27d2..5e00c3771 100644
--- a/apps/mobile/src/components/field.tsx
+++ b/apps/mobile/src/components/field.tsx
@@ -1,6 +1,7 @@
 import { forwardRef, useState } from 'react';
 import { StyleSheet, TextInput, View, type TextInputProps } from 'react-native';
 
+import { AppTextInput } from './app-text-input';
 import { Text } from './text';
 
 import { radius } from '@/theme/colors';
@@ -19,7 +20,7 @@ export const Field = forwardRef<TextInput, Props>(function Field({ label, hint,
       <Text weight="medium" tone="secondary" style={styles.label}>
         {label}
       </Text>
-      <TextInput
+      <AppTextInput
         ref={ref}
         accessibilityLabel={label}
         accessibilityHint={hint}
diff --git a/apps/mobile/src/components/flowchart-views.tsx b/apps/mobile/src/components/flowchart-views.tsx
index 7f7a4fffe..adbfe7722 100644
--- a/apps/mobile/src/components/flowchart-views.tsx
+++ b/apps/mobile/src/components/flowchart-views.tsx
@@ -1,10 +1,11 @@
 import { flowColumns, mapRows, type FlowchartDocument, type FlowEdgeKind, type FlowNode, type FlowNodeType } from '@debatelab/core/flowchart';
 import { useTranslation } from 'react-i18next';
-import { Pressable, ScrollView, StyleSheet, View, useWindowDimensions } from 'react-native';
+import { Pressable, ScrollView, StyleSheet, View } from 'react-native';
 
 import { Text } from './text';
 
 import { flowMeta, mapMeta, typeLabel, viaLabel } from '@/lib/flowchart-text';
+import { useContentWidth } from '@/lib/layout';
 import { radius } from '@/theme/colors';
 import { useTheme } from '@/theme/use-theme';
 
@@ -104,7 +105,7 @@ export function FlowLegend() {
 export function FlowColumnsView({ doc, onOpen, selectedId }: { doc: FlowchartDocument; onOpen: (node: FlowNode) => void; selectedId?: string }) {
   const { t } = useTranslation();
   const flow = useFlowColors();
-  const { width } = useWindowDimensions();
+  const width = useContentWidth();
   const wide = width >= WIDE;
   const groups = flowColumns(doc);
   const columns = [
diff --git a/apps/mobile/src/components/library-header.web.tsx b/apps/mobile/src/components/library-header.web.tsx
index a154bc1b5..08c1da5e7 100644
--- a/apps/mobile/src/components/library-header.web.tsx
+++ b/apps/mobile/src/components/library-header.web.tsx
@@ -3,6 +3,9 @@ import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Pressable, ScrollView, StyleSheet, View } from 'react-native';
 
+/** Menus are fixed chrome: iOS's own menus stop growing at large accessibility sizes. */
+const MENU_MAX_FONT_SCALE = 1.6;
+
 import { Icon } from './icon';
 import type { IconName } from './icon-paths';
 import { SORT_LABELS, TYPE_FILTERS, type AddSourceKind, type LibraryHeaderProps } from './library-options';
@@ -51,7 +54,7 @@ export function LibraryHeader({ title, onAdd, disabled, sort, onSort, filter, on
       }}
       style={({ pressed }) => [styles.item, divider && { borderTopWidth: 1, borderTopColor: colors.line }, pressed && { backgroundColor: colors.line }, item.disabled && styles.disabled]}>
       <View style={styles.check}>{item.on ? <Icon name="check" color={colors.primary} size={18} /> : null}</View>
-      <Text style={[styles.itemLabel, item.destructive && { color: colors.destructive }]} numberOfLines={2}>
+      <Text style={[styles.itemLabel, item.destructive && { color: colors.destructive }]} numberOfLines={2} maxFontSizeMultiplier={MENU_MAX_FONT_SCALE}>
         {item.label}
       </Text>
       {item.icon ? <Icon name={item.icon} color={item.destructive ? colors.destructive : colors.foreground} size={21} /> : null}
@@ -84,28 +87,29 @@ export function LibraryHeader({ title, onAdd, disabled, sort, onSort, filter, on
           style={[styles.round, { backgroundColor: colors.primaryFill }, disabled && styles.disabled]}>
           <Icon name="plus" color={colors.onPrimary} size={24} />
         </Pressable>
+        {/* Under the buttons, wherever a large text size puts them. */}
+        {open === 'add' ? (
+          <View accessibilityRole="menu" style={[styles.menu, { backgroundColor: colors.card, borderColor: colors.line }]}>
+            {add.map((item, index) => row(item, index > 0))}
+          </View>
+        ) : null}
+        {open === 'more' ? (
+          <View accessibilityRole="menu" testID="library-more-menu" style={[styles.menu, styles.moreMenu, { backgroundColor: colors.card, borderColor: colors.line }]}>
+            <ScrollView>
+              {sections.map((section, index) => (
+                <View key={section.title ?? index} style={index > 0 && { borderTopWidth: 6, borderTopColor: colors.line }}>
+                  {section.title ? (
+                    <Text tone="faint" weight="semibold" style={styles.section} maxFontSizeMultiplier={MENU_MAX_FONT_SCALE}>
+                      {section.title}
+                    </Text>
+                  ) : null}
+                  {section.items.map((item, itemIndex) => row(item, itemIndex > 0 || Boolean(section.title)))}
+                </View>
+              ))}
+            </ScrollView>
+          </View>
+        ) : null}
       </View>
-      {open === 'add' ? (
-        <View accessibilityRole="menu" style={[styles.menu, { backgroundColor: colors.card, borderColor: colors.line }]}>
-          {add.map((item, index) => row(item, index > 0))}
-        </View>
-      ) : null}
-      {open === 'more' ? (
-        <View accessibilityRole="menu" testID="library-more-menu" style={[styles.menu, styles.moreMenu, { backgroundColor: colors.card, borderColor: colors.line }]}>
-          <ScrollView>
-            {sections.map((section, index) => (
-              <View key={section.title ?? index} style={index > 0 && { borderTopWidth: 6, borderTopColor: colors.line }}>
-                {section.title ? (
-                  <Text tone="faint" weight="semibold" style={styles.section}>
-                    {section.title}
-                  </Text>
-                ) : null}
-                {section.items.map((item, itemIndex) => row(item, itemIndex > 0 || Boolean(section.title)))}
-              </View>
-            ))}
-          </ScrollView>
-        </View>
-      ) : null}
     </View>
   );
 }
@@ -118,7 +122,8 @@ const styles = StyleSheet.create({
   disabled: { opacity: 0.5 },
   menu: {
     position: 'absolute',
-    top: 50,
+    top: '100%',
+    marginTop: 8,
     right: 0,
     width: 272,
     borderRadius: 16,
diff --git a/apps/mobile/src/components/live-run.tsx b/apps/mobile/src/components/live-run.tsx
index 6b7dbba21..a8503e4c8 100644
--- a/apps/mobile/src/components/live-run.tsx
+++ b/apps/mobile/src/components/live-run.tsx
@@ -3,12 +3,14 @@ import type { DraftBlock, DraftSection } from '@debatelab/core/ai/live-sections'
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Animated, StyleSheet, View } from 'react-native';
+import Reanimated, { FadeInDown } from 'react-native-reanimated';
 
 import { TextButton } from './buttons';
 import { OwlAvatar, useReduceMotion, type OwlPose } from './owl';
 import { Text } from './text';
 import { ToolProgress } from './tool-form';
 
+import { motionSetting, SPRING } from '@/theme/motion';
 import { radius } from '@/theme/colors';
 import { useTheme } from '@/theme/use-theme';
 
@@ -103,7 +105,7 @@ function Block({ block, writing }: { block: DraftBlock; writing: boolean }) {
   if (block.heading) {
     return (
       <View style={styles.inline}>
-        <Text weight="bold" style={styles.heading}>
+        <Text accessibilityRole="header" weight="bold" style={styles.heading}>
           {block.heading}
         </Text>
         {writing ? <Caret /> : null}
@@ -161,6 +163,7 @@ export function LiveToolRun({
   /** The tool's own owl before the answer starts; the phase picks it otherwise. */
   pose?: OwlPose;
 }) {
+  const reduceMotion = useReduceMotion();
   const { t } = useTranslation();
   const { colors } = useTheme();
   const status = usePhaseLabel(run.phase, label);
@@ -177,7 +180,7 @@ export function LiveToolRun({
   return (
     <View style={styles.root} testID="live-draft">
       <View style={[styles.strip, { backgroundColor: colors.tile, borderColor: colors.tileBorder }]}>
-        <OwlAvatar pose={writing ? 'point' : 'idea'} size={36} />
+        <OwlAvatar pose={writing ? 'point' : 'idea'} size={36} blink />
         <View style={styles.stripText}>
           <Text weight="bold" style={styles.stripStatus} accessibilityRole="progressbar" accessibilityLiveRegion="polite">
             {writing ? t('tools.live.writingLive') : status}
@@ -190,9 +193,11 @@ export function LiveToolRun({
         </View>
         <TextButton label={t('common.cancel')} onPress={onCancel} />
       </View>
+      {/* Each section pops in as the draft starts writing it (Reanimated; still under Reduce Motion). */}
       {sections.map((section, sectionIndex) => (
-        <View
+        <Reanimated.View
           key={section.id}
+          entering={FadeInDown.springify().damping(SPRING.pop.damping).stiffness(SPRING.pop.stiffness).reduceMotion(motionSetting(reduceMotion))}
           accessibilityLabel={section.title}
           style={[styles.section, { backgroundColor: colors.card, borderColor: colors.border }]}>
           <Text accessibilityRole="header" weight="display" tone="heading" style={styles.sectionTitle}>
@@ -201,7 +206,7 @@ export function LiveToolRun({
           {section.blocks.map((block, blockIndex) => (
             <Block key={blockIndex} block={block} writing={writing && sectionIndex === lastSection && blockIndex === lastBlock} />
           ))}
-        </View>
+        </Reanimated.View>
       ))}
     </View>
   );
diff --git a/apps/mobile/src/components/offline-notice.tsx b/apps/mobile/src/components/offline-notice.tsx
index 69b1c4c74..f28fc1b13 100644
--- a/apps/mobile/src/components/offline-notice.tsx
+++ b/apps/mobile/src/components/offline-notice.tsx
@@ -3,30 +3,46 @@ import { StyleSheet, View, type StyleProp, type ViewStyle } from 'react-native';
 
 import { Icon } from '@/components/icon';
 import { Text } from '@/components/text';
+import { useAuth } from '@/lib/auth';
 import { useOfflineStatus } from '@/lib/network-status';
+import { waitingCount } from '@/lib/offline-queue';
+import { useQueuedWrites } from '@/lib/use-offline-queue';
 import { radius } from '@/theme/colors';
 import { useTheme } from '@/theme/use-theme';
 
 /**
  * Shown while the device is offline or the screen's data came from saved
- * copies. AI and saving stay where they are and fail with their network
- * error, so the notice says they wait for the connection.
+ * copies, and while changes wait in the offline queue. New notes, source
+ * edits and switches are kept on the phone and sync later; AI and every other
+ * save fail with their network error, so the notice says they wait.
  */
 export function OfflineNotice({ style }: { style?: StyleProp<ViewStyle> }) {
   const { t } = useTranslation();
   const { colors } = useTheme();
   const { offline, savedCopies } = useOfflineStatus();
-  if (!offline && !savedCopies) return null;
+  const { session } = useAuth();
+  const count = waitingCount(useQueuedWrites(session?.user.id ?? null));
+  if (!offline && !savedCopies && count === 0) return null;
+  const reading = offline || savedCopies;
   return (
     <View
       accessibilityRole="alert"
       accessibilityLiveRegion="polite"
       style={[styles.notice, { backgroundColor: colors.line }, style]}
       testID="offline-notice">
-      <Icon name="cloudOff" size={16} color={colors.faint} />
-      <Text tone="secondary" style={styles.text}>
-        {t('mobile.offline.notice')}
-      </Text>
+      <Icon name={reading ? 'cloudOff' : 'upload'} size={16} color={colors.faint} />
+      <View style={styles.lines}>
+        {reading ? (
+          <Text tone="secondary" style={styles.text}>
+            {t('mobile.offlineQueue.notice')}
+          </Text>
+        ) : null}
+        {count > 0 ? (
+          <Text tone="secondary" weight={reading ? 'semibold' : 'regular'} style={styles.text} testID="offline-queue-count">
+            {offline ? t('mobile.offlineQueue.pending', { count }) : t('mobile.offlineQueue.syncing', { count })}
+          </Text>
+        ) : null}
+      </View>
     </View>
   );
 }
@@ -40,5 +56,6 @@ const styles = StyleSheet.create({
     paddingHorizontal: 12,
     paddingVertical: 8,
   },
-  text: { flex: 1, fontSize: 13.5, lineHeight: 18 },
+  lines: { flex: 1, gap: 2 },
+  text: { fontSize: 13.5, lineHeight: 18 },
 });
diff --git a/apps/mobile/src/components/outline.tsx b/apps/mobile/src/components/outline.tsx
index a830ad487..22423c9e1 100644
--- a/apps/mobile/src/components/outline.tsx
+++ b/apps/mobile/src/components/outline.tsx
@@ -121,7 +121,7 @@ export function OutlineRail({ entries, current, onJump }: { entries: Anchor[]; c
   if (entries.length === 0) return null;
   return (
     <View style={styles.rail} accessibilityRole="menu" testID="document-outline">
-      <Text weight="semibold" tone="faint" style={styles.heading}>
+      <Text accessibilityRole="header" weight="semibold" tone="faint" style={styles.heading}>
         {t('mobile.document.onThisPage')}
       </Text>
       {entries.map((anchor) => {
diff --git a/apps/mobile/src/components/owl.tsx b/apps/mobile/src/components/owl.tsx
index 126ce027d..e59c1e8f0 100644
--- a/apps/mobile/src/components/owl.tsx
+++ b/apps/mobile/src/components/owl.tsx
@@ -1,6 +1,19 @@
-import { useEffect, useRef, useState } from 'react';
-import { AccessibilityInfo, Animated, Easing, Image, type ImageSourcePropType, type ImageStyle, StyleSheet, View } from 'react-native';
+import { useEffect, useState } from 'react';
+import { Image, type ImageSourcePropType, type ImageStyle, StyleSheet, View } from 'react-native';
+import Animated, {
+  cancelAnimation,
+  interpolate,
+  useAnimatedStyle,
+  useSharedValue,
+  withDelay,
+  withRepeat,
+  withSequence,
+  withSpring,
+  withTiming,
+  type SharedValue,
+} from 'react-native-reanimated';
 
+import { DURATION, EASE, SPRING, useReduceMotion } from '@/theme/motion';
 import { useTheme } from '@/theme/use-theme';
 
 /**
@@ -9,6 +22,11 @@ import { useTheme } from '@/theme/use-theme';
  * pose the website uses there: point (an empty start), coach (the Ask coach),
  * arguing (the Sparring opponent), reading (the Library), sleepy (nothing
  * saved yet), surprised (no match, an error), celebrating (done), timekeeper.
+ *
+ * It moves as the website's owl does (src/index.css, "The owl's motion"), on the
+ * UI thread with Reanimated: it blinks on its own clock, breathes, plays its
+ * pose's gesture (wave, cheer, hop) when it arrives or changes pose, and pops
+ * into a new pose. Under Reduce Motion it stays still.
  */
 export type OwlPose =
   | 'point'
@@ -39,6 +57,131 @@ const POSES: Record<OwlPose, ImageSourcePropType> = {
 
 const MARK: ImageSourcePropType = require('@/assets/owl/mark.png');
 
+/** A one-shot move the owl plays when it arrives or changes pose. */
+export type OwlGesture = 'wave' | 'cheer' | 'hop';
+
+const GESTURES: Partial<Record<OwlPose, OwlGesture>> = {
+  point: 'wave',
+  coach: 'wave',
+  arguing: 'wave',
+  celebrating: 'cheer',
+  surprised: 'hop',
+  idea: 'hop',
+};
+
+/** Each eye as [left, top, width, height] in % of the square (the website's EYES); sleepy's are shut. */
+type EyeBox = readonly [number, number, number, number];
+const EYES: Partial<Record<OwlPose | 'mark', readonly [EyeBox, EyeBox]>> = {
+  arguing: [[34.4, 22.2, 12.8, 14], [56.6, 22.2, 11.8, 14]],
+  celebrating: [[31.3, 20, 11.7, 12.8], [50.9, 19.4, 10.9, 12.8]],
+  coach: [[37.7, 23.9, 13, 14.4], [60.4, 23.9, 12.1, 14.4]],
+  idea: [[41.7, 23.5, 13.4, 14.7], [64.3, 24, 12.5, 14.7]],
+  point: [[35.5, 22.7, 13.5, 14.8], [59, 22.7, 12.5, 14.8]],
+  reading: [[33, 25.9, 12.8, 14], [55.2, 25.9, 11.8, 14]],
+  skeptical: [[29.3, 27.8, 12.2, 11.8], [50.6, 27.4, 11.5, 11.8]],
+  surprised: [[38.3, 17, 13, 14.3], [60.4, 17.5, 12.1, 14.3]],
+  thinking: [[31.2, 25.9, 12.8, 14], [53.3, 25.9, 11.8, 14]],
+  timekeeper: [[30.1, 22.2, 12.8, 14], [52.3, 22.2, 11.8, 14]],
+  mark: [[27.3, 36.3, 18, 19.5], [54.7, 36.3, 18, 19.5]],
+};
+
+// Below this the lids are a pixel or two and a blink reads as flicker.
+const MIN_BLINK_SIZE = 28;
+
+/** Whether iOS's Reduce Motion is on, kept current; every moving part of the app checks it. */
+export { useReduceMotion };
+
+/**
+ * A blink on this owl's own clock (a period of 4.6 to 7 s and a random phase, fixed for its
+ * lifetime): flat lids pull down over the eyes for about a tenth of a second, the website's
+ * owl-blink keyframes (closed at 95%, nearly open at 97%).
+ */
+function useBlink(enabled: boolean): SharedValue<number> {
+  const lid = useSharedValue(0);
+  const [clock] = useState(() => ({ period: 4600 + Math.random() * 2400, phase: Math.random() * 6000 }));
+  useEffect(() => {
+    if (!enabled) {
+      cancelAnimation(lid);
+      lid.set(0);
+      return;
+    }
+    const { period, phase } = clock;
+    lid.set(withDelay(
+      phase,
+      withRepeat(
+        withSequence(
+          withDelay(period * 0.93, withTiming(1, { duration: period * 0.02 })),
+          withTiming(0.15, { duration: period * 0.02 }),
+          withTiming(0, { duration: period * 0.03 }),
+        ),
+        -1,
+      ),
+    ));
+    return () => cancelAnimation(lid);
+  }, [enabled, clock, lid]);
+  return lid;
+}
+
+/** Two lids over the eyes, in the owl's blue with a navy lash; flat (scaleY 0) between blinks. */
+function OwlLids({ eyes, size, lid, offset = { left: 0, top: 0 } }: { eyes: readonly [EyeBox, EyeBox]; size: number; lid: SharedValue<number>; offset?: { left: number; top: number } }) {
+  const style = useAnimatedStyle(() => ({ transform: [{ scaleY: lid.value }] }));
+  const lash = Math.max(1, size * 0.012) * 1.6;
+  return (
+    <>
+      {eyes.map(([left, top, width, height], index) => (
+        <Animated.View
+          key={index}
+          pointerEvents="none"
+          style={[
+            styles.lid,
+            {
+              left: offset.left + (left / 100) * size,
+              top: offset.top + (top / 100) * size,
+              width: (width / 100) * size,
+              height: (height / 100) * size,
+              borderBottomWidth: lash,
+            },
+            style,
+          ]}
+        />
+      ))}
+    </>
+  );
+}
+
+/** The gesture's transform at progress 0..1: the website's owl-wave, owl-cheer and owl-hop keyframes. */
+function gestureTransform(move: OwlGesture | undefined, t: number, size: number) {
+  'worklet';
+  if (move === 'wave') {
+    return [{ rotate: `${interpolate(t, [0, 0.18, 0.38, 0.58, 0.78, 1], [0, -7, 6, -4, 2, 0])}deg` }];
+  }
+  if (move === 'cheer') {
+    // Two jumps with squash and stretch.
+    const at = [0, 0.1, 0.28, 0.44, 0.58, 0.74, 0.88, 1];
+    return [
+      { translateY: (interpolate(t, at, [0, 0, -14, 0, -7, 0, 0, 0]) / 100) * size },
+      { rotate: `${interpolate(t, at, [0, 0, 0, 0, -3, 0, 0, 0])}deg` },
+      { scaleX: interpolate(t, at, [1, 1.07, 0.95, 1.06, 0.98, 1.03, 0.995, 1]) },
+      { scaleY: interpolate(t, at, [1, 0.9, 1.07, 0.93, 1.03, 0.97, 1.005, 1]) },
+    ];
+  }
+  if (move === 'hop') {
+    const at = [0, 0.18, 0.45, 0.72, 1];
+    return [
+      { translateY: (interpolate(t, at, [0, 0, -8, 0, 0]) / 100) * size },
+      { scaleX: interpolate(t, at, [1, 1.05, 0.97, 1.03, 1]) },
+      { scaleY: interpolate(t, at, [1, 0.93, 1.04, 0.97, 1]) },
+    ];
+  }
+  return [];
+}
+
+const GESTURE_TIMING: Record<OwlGesture, { duration: number; delay: number; origin: string }> = {
+  wave: { duration: 900, delay: 120, origin: '50% 90%' },
+  cheer: { duration: 1100, delay: 80, origin: '50% 100%' },
+  hop: { duration: 600, delay: 80, origin: '50% 100%' },
+};
+
 type OwlProps = {
   pose: OwlPose;
   size: number;
@@ -47,28 +190,97 @@ type OwlProps = {
   /** Read out by VoiceOver; without it the owl is decoration. */
   label?: string;
   style?: ImageStyle;
+  /** The move played on arrival and on each pose change; false keeps it still. Defaults by pose. */
+  gesture?: OwlGesture | false;
+  /** A slow breath while idle; off where something else moves the owl (a loader's bob). */
+  breathe?: boolean;
+  /** Plays the gesture again when this changes, such as a result arriving. */
+  replay?: unknown;
 };
 
-export function Owl({ pose, size, mirrored, label, style }: OwlProps) {
+/**
+ * Ollie, full body: blinks, breathes, plays its pose's gesture when it arrives, a pose change
+ * pops in on the website's `pop` spring, and `replay` cheers again on demand.
+ */
+export function Owl({ pose, size, mirrored, label, style, gesture, breathe = true, replay }: OwlProps) {
+  const reduce = useReduceMotion();
+  const move = gesture === undefined ? GESTURES[pose] : gesture || undefined;
+  const eyes = size >= MIN_BLINK_SIZE ? EYES[pose] : undefined;
+  const lid = useBlink(!reduce && Boolean(eyes));
+
+  const breath = useSharedValue(0);
+  useEffect(() => {
+    if (reduce || !breathe) {
+      cancelAnimation(breath);
+      breath.set(0);
+      return;
+    }
+    breath.set(withRepeat(withTiming(1, { duration: 1900, easing: EASE.standard }), -1, true));
+    return () => cancelAnimation(breath);
+  }, [reduce, breathe, breath]);
+
+  // Arrival and each pose change: a pop from slightly small and low, then the pose's gesture.
+  const arrive = useSharedValue(reduce ? 1 : 0);
+  const play = useSharedValue(1);
+  useEffect(() => {
+    if (reduce) {
+      arrive.set(1);
+      play.set(1);
+      return;
+    }
+    arrive.set(withSequence(withTiming(0, { duration: 0 }), withSpring(1, SPRING.pop)));
+    if (move) {
+      const { duration, delay } = GESTURE_TIMING[move];
+      play.set(withSequence(withTiming(0, { duration: 0 }), withDelay(delay, withTiming(1, { duration, easing: EASE.standard }))));
+    }
+  }, [pose, move, replay, reduce, arrive, play]);
+
+  const bodyStyle = useAnimatedStyle(() => ({
+    transformOrigin: '50% 92%',
+    transform: [{ scaleX: 1 + 0.012 * breath.value }, { scaleY: 1 + 0.028 * breath.value }],
+  }));
+  const poseStyle = useAnimatedStyle(() => ({
+    opacity: Math.min(1, arrive.value * 2),
+    transform: [{ translateY: (1 - arrive.value) * 6 }, { scale: 0.9 + 0.1 * arrive.value }],
+  }));
+  const gestureStyle = useAnimatedStyle(() => ({
+    transformOrigin: move ? GESTURE_TIMING[move].origin : '50% 50%',
+    transform: gestureTransform(move, play.value, size),
+  }));
+
   return (
-    <Image
-      source={POSES[pose]}
+    <View
       accessible={Boolean(label)}
       accessibilityRole={label ? 'image' : undefined}
       accessibilityLabel={label}
       accessibilityElementsHidden={!label}
       importantForAccessibility={label ? 'yes' : 'no-hide-descendants'}
-      style={[{ width: size, height: size }, mirrored && styles.mirrored, style]}
-      resizeMode="contain"
-    />
+      style={[{ width: size, height: size }, mirrored && styles.mirrored, style]}>
+      <Animated.View style={[StyleSheet.absoluteFill, bodyStyle]}>
+        <Animated.View style={[StyleSheet.absoluteFill, poseStyle]}>
+          <Animated.View style={[StyleSheet.absoluteFill, gestureStyle]}>
+            <Image source={POSES[pose]} style={{ width: size, height: size }} resizeMode="contain" />
+            {eyes ? <OwlLids eyes={eyes} size={size} lid={lid} /> : null}
+          </Animated.View>
+        </Animated.View>
+      </Animated.View>
+    </View>
   );
 }
 
-/** The owl's head in a tinted circle: the Ask coach and the Sparring opponent beside their messages. */
-export function OwlAvatar({ pose, size, label }: { pose: OwlPose; size: number; label?: string }) {
+/**
+ * The owl's head in a tinted circle: the Ask coach and the Sparring opponent beside their
+ * messages. `blink` only where the avatar is present (a header, a working indicator), as on the
+ * website: a transcript of blinking owls reads as noise.
+ */
+export function OwlAvatar({ pose, size, label, blink = false }: { pose: OwlPose; size: number; label?: string; blink?: boolean }) {
   const { scheme } = useTheme();
+  const reduce = useReduceMotion();
   // The website zooms the full pose 1.6x about 52% across and 32% down, onto the head and shoulders.
   const zoomed = size * 1.6;
+  const offset = { left: -0.52 * (zoomed - size), top: -0.32 * (zoomed - size) };
+  const eyes = blink && zoomed >= MIN_BLINK_SIZE ? EYES[pose] : undefined;
+  const lid = useBlink(!reduce && Boolean(eyes));
   return (
     <View
       accessible={Boolean(label)}
@@ -81,63 +293,46 @@ export function OwlAvatar({ pose, size, label }: { pose: OwlPose; size: number;
         { width: size, height: size, borderRadius: size / 2 },
         scheme === 'dark' ? styles.avatarDark : styles.avatarLight,
       ]}>
-      <Image
-        source={POSES[pose]}
-        resizeMode="contain"
-        style={{ position: 'absolute', width: zoomed, height: zoomed, left: -0.52 * (zoomed - size), top: -0.32 * (zoomed - size) }}
-      />
+      <Image source={POSES[pose]} resizeMode="contain" style={{ position: 'absolute', width: zoomed, height: zoomed, ...offset }} />
+      {eyes ? <OwlLids eyes={eyes} size={zoomed} lid={lid} offset={offset} /> : null}
     </View>
   );
 }
 
-/** The owl mark on its tile, as the website's sign-in and header show it. */
+/** The owl mark on its tile, as the website's sign-in and header show it; it blinks from 28 points. */
 export function OwlMark({ size }: { size: number }) {
   const { scheme } = useTheme();
+  const reduce = useReduceMotion();
+  const eyes = size >= MIN_BLINK_SIZE ? EYES.mark : undefined;
+  const lid = useBlink(!reduce && Boolean(eyes));
   return (
     <View
       accessibilityElementsHidden
       importantForAccessibility="no-hide-descendants"
       style={[styles.mark, { width: size, height: size + 2, borderRadius: size * 0.28, backgroundColor: scheme === 'dark' ? '#061442' : '#B3D8FC' }]}>
       <Image source={MARK} style={{ width: size, height: size, borderRadius: size * 0.28 }} />
+      {eyes ? <OwlLids eyes={eyes} size={size} lid={lid} /> : null}
     </View>
   );
 }
 
-/** Whether iOS's Reduce Motion is on, kept current while the screen shows. */
-export function useReduceMotion(): boolean {
-  const [reduce, setReduce] = useState(false);
-  useEffect(() => {
-    let active = true;
-    void AccessibilityInfo.isReduceMotionEnabled().then((value) => {
-      if (active) setReduce(value);
-    });
-    const subscription = AccessibilityInfo.addEventListener('reduceMotionChanged', setReduce);
-    return () => {
-      active = false;
-      subscription.remove();
-    };
-  }, []);
-  return reduce;
-}
-
-/** The owl bobbing gently while a request runs, where the website shows OwlLoader; still under Reduce Motion. */
+/**
+ * The owl floating gently while a request runs, where the website shows OwlLoader (owl-bob:
+ * 5 points up and down over 2.4 s), blinking as it waits; still under Reduce Motion.
+ */
 export function OwlLoader({ pose, size, label }: { pose: OwlPose; size: number; label?: string }) {
-  const bob = useRef(new Animated.Value(0)).current;
-  const reduceMotion = useReduceMotion();
+  const reduce = useReduceMotion();
+  const bob = useSharedValue(0);
   useEffect(() => {
-    if (reduceMotion) {
-      bob.setValue(0);
+    if (reduce) {
+      cancelAnimation(bob);
+      bob.set(0);
       return;
     }
-    const loop = Animated.loop(
-      Animated.sequence([
-        Animated.timing(bob, { toValue: 1, duration: 600, easing: Easing.inOut(Easing.quad), useNativeDriver: true }),
-        Animated.timing(bob, { toValue: 0, duration: 600, easing: Easing.inOut(Easing.quad), useNativeDriver: true }),
-      ]),
-    );
-    loop.start();
-    return () => loop.stop();
-  }, [bob, reduceMotion]);
+    bob.set(withRepeat(withTiming(1, { duration: DURATION.ambient / 2, easing: EASE.standard }), -1, true));
+    return () => cancelAnimation(bob);
+  }, [reduce, bob]);
+  const style = useAnimatedStyle(() => ({ transform: [{ translateY: -5 * bob.value }] }));
   return (
     // Labelled, it is the progress indicator; unlabelled, a progress line beside it speaks and the owl is decoration.
     <Animated.View
@@ -145,8 +340,8 @@ export function OwlLoader({ pose, size, label }: { pose: OwlPose; size: number;
       accessibilityLabel={label}
       accessibilityElementsHidden={!label}
       importantForAccessibility={label ? 'yes' : 'no-hide-descendants'}
-      style={{ transform: [{ translateY: bob.interpolate({ inputRange: [0, 1], outputRange: [0, -size * 0.05] }) }] }}>
-      <Owl pose={pose} size={size} />
+      style={style}>
+      <Owl pose={pose} size={size} breathe={false} gesture={false} />
     </Animated.View>
   );
 }
@@ -157,4 +352,6 @@ const styles = StyleSheet.create({
   avatarLight: { backgroundColor: '#D6EAFE', borderColor: '#FFFFFF' },
   avatarDark: { backgroundColor: '#0B2A6E', borderColor: '#131E33' },
   mark: { overflow: 'hidden' },
+  // The website's .owl-lid: the owl's blue, a navy lash, closing from the top.
+  lid: { position: 'absolute', borderRadius: 999, backgroundColor: '#1E8DFB', borderBottomColor: '#0B2A6E', transformOrigin: '50% 0%' },
 });
diff --git a/apps/mobile/src/components/press-scale.tsx b/apps/mobile/src/components/press-scale.tsx
new file mode 100644
index 000000000..f225339e9
--- /dev/null
+++ b/apps/mobile/src/components/press-scale.tsx
@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react';
+import { Pressable, type PressableProps, type StyleProp, type ViewStyle } from 'react-native';
+import Animated, { useAnimatedStyle, useSharedValue, withSpring, withTiming } from 'react-native-reanimated';
+
+import { SPRING, useReduceMotion } from '@/theme/motion';
+
+/**
+ * A pressable card or row that gives under the finger: it eases to 97% as a finger lands and
+ * springs back on release, on the UI thread. Rows never lift (the website's motion-list-item);
+ * they only press in. Under Reduce Motion it does not move.
+ */
+export function PressScale({ children, style, scaleTo = 0.97, onPressIn, onPressOut, ...props }: Omit<PressableProps, 'style' | 'children'> & { children: ReactNode; style?: StyleProp<ViewStyle>; scaleTo?: number }) {
+  const reduce = useReduceMotion();
+  const scale = useSharedValue(1);
+  const animated = useAnimatedStyle(() => ({ transform: [{ scale: scale.value }] }));
+  return (
+    <Pressable
+      {...props}
+      onPressIn={(event) => {
+        if (!reduce) scale.set(withTiming(scaleTo, { duration: 90 }));
+        onPressIn?.(event);
+      }}
+      onPressOut={(event) => {
+        if (!reduce) scale.set(withSpring(1, SPRING.pop));
+        onPressOut?.(event);
+      }}>
+      <Animated.View style={[style, animated]}>{children}</Animated.View>
+    </Pressable>
+  );
+}
diff --git a/apps/mobile/src/components/regenerating-strip.tsx b/apps/mobile/src/components/regenerating-strip.tsx
index 929d4f047..072418d9d 100644
--- a/apps/mobile/src/components/regenerating-strip.tsx
+++ b/apps/mobile/src/components/regenerating-strip.tsx
@@ -13,7 +13,7 @@ export function RegeneratingStrip({ title }: { title: string }) {
   const { colors } = useTheme();
   return (
     <View style={[styles.strip, { backgroundColor: colors.tile, borderColor: colors.tileBorder }]} testID="regenerating">
-      <OwlAvatar pose="thinking" size={34} />
+      <OwlAvatar pose="thinking" size={34} blink />
       <Text weight="bold" style={styles.text} accessibilityRole="progressbar" accessibilityLiveRegion="polite">
         {t('common.regenerating', { title })}
       </Text>
diff --git a/apps/mobile/src/components/screen.tsx b/apps/mobile/src/components/screen.tsx
index 1b0ab98f4..4d7411bd5 100644
--- a/apps/mobile/src/components/screen.tsx
+++ b/apps/mobile/src/components/screen.tsx
@@ -15,8 +15,12 @@ import { HOME_MAX_WIDTH } from '@/lib/layout';
 export function Screen({ children, safeTop, gap, wide }: { children: ReactNode; safeTop?: boolean; gap?: number; wide?: boolean }) {
   const insets = useSafeAreaInsets();
   return (
+    // Fields scroll clear of the keyboard; a tap on a button works with the keyboard up.
     <ScrollView
       contentInsetAdjustmentBehavior="automatic"
+      automaticallyAdjustKeyboardInsets
+      keyboardShouldPersistTaps="handled"
+      keyboardDismissMode="interactive"
       contentContainerStyle={[styles.content, wide && styles.wide, safeTop && { paddingTop: insets.top + 12 }, gap !== undefined && { gap }]}>
       <OfflineNotice />
       {children}
diff --git a/apps/mobile/src/components/search-field.tsx b/apps/mobile/src/components/search-field.tsx
index f230c87d6..dad6fcef2 100644
--- a/apps/mobile/src/components/search-field.tsx
+++ b/apps/mobile/src/components/search-field.tsx
@@ -1,5 +1,6 @@
-import { StyleSheet, TextInput, View } from 'react-native';
+import { StyleSheet, View } from 'react-native';
 
+import { AppTextInput } from './app-text-input';
 import { Icon } from './icon';
 
 import { radius } from '@/theme/colors';
@@ -12,7 +13,7 @@ export function SearchField({ value, onChangeText, placeholder }: { value: strin
   return (
     <View style={[styles.search, { backgroundColor: colors.segmentTrack }]}>
       <Icon name="search" color={colors.faint} size={19} />
-      <TextInput
+      <AppTextInput
         value={value}
         onChangeText={onChangeText}
         placeholder={placeholder}
diff --git a/apps/mobile/src/components/segmented-control.tsx b/apps/mobile/src/components/segmented-control.tsx
index 061095f22..66562b966 100644
--- a/apps/mobile/src/components/segmented-control.tsx
+++ b/apps/mobile/src/components/segmented-control.tsx
@@ -39,7 +39,7 @@ export function SegmentedControl<T extends string>({
               selected && [styles.selected, { backgroundColor: colors.segmentSelected }],
               selected && scheme === 'light' && styles.selectedShadow,
             ]}>
-            <Text weight="semibold" tone={selected ? 'foreground' : 'secondary'} style={styles.label}>
+            <Text weight="semibold" tone={selected ? 'foreground' : 'secondary'} style={styles.label} maxFontSizeMultiplier={1.6}>
               {option.label}
             </Text>
           </Pressable>
diff --git a/apps/mobile/src/components/sheet.tsx b/apps/mobile/src/components/sheet.tsx
index 1704df017..788e88197 100644
--- a/apps/mobile/src/components/sheet.tsx
+++ b/apps/mobile/src/components/sheet.tsx
@@ -2,6 +2,7 @@ import type { ReactNode } from 'react';
 import { ScrollView, StyleSheet, type StyleProp, type ViewStyle } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
+import { ReservedWidth } from '@/lib/layout';
 import { useTheme } from '@/theme/use-theme';
 
 /**
@@ -30,7 +31,8 @@ export function SheetScrollView({
       keyboardShouldPersistTaps="handled"
       keyboardDismissMode="interactive"
       testID={testID}>
-      {children}
+      {/* A sheet covers the iPad sidebar, so what it holds lays out for the whole window. */}
+      <ReservedWidth.Provider value={0}>{children}</ReservedWidth.Provider>
     </ScrollView>
   );
 }
diff --git a/apps/mobile/src/components/sidebar-items.ts b/apps/mobile/src/components/sidebar-items.ts
new file mode 100644
index 000000000..4c0e311a2
--- /dev/null
+++ b/apps/mobile/src/components/sidebar-items.ts
@@ -0,0 +1,90 @@
+import type { IconName } from './icon-paths';
+
+/** Where a sidebar row goes: one of the five tabs, or a screen pushed above them. */
+export type SidebarTarget =
+  | { kind: 'tab'; href: '/' | '/library' | '/you' }
+  | { kind: 'screen'; pathname: string; params?: Record<string, string> }
+  /** Import file: the Files picker opens first, as the Library's Add menu does. */
+  | { kind: 'pickFile' };
+
+export interface SidebarItem {
+  key: string;
+  /** A catalog key. */
+  label: string;
+  icon: IconName;
+  target: SidebarTarget;
+  /** Paths that count as this row, so it stays highlighted on the documents it opens. */
+  matches: (pathname: string) => boolean;
+}
+
+export interface SidebarSection {
+  key: 'debate' | 'prepare' | 'practice' | 'library' | 'you';
+  label: string;
+  items: SidebarItem[];
+}
+
+const under = (...prefixes: string[]) => (pathname: string) =>
+  prefixes.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`));
+
+/**
+ * Every place in the app, grouped the way Adam asked for the iPad sidebar:
+ * Debate, Prepare, Practice, Library and You. A tool's documents count as the
+ * tool, so a saved case keeps Generate highlighted. Practice tools from round 3
+ * go at the end of their section once they exist.
+ */
+export const SIDEBAR_SECTIONS: SidebarSection[] = [
+  {
+    key: 'debate',
+    label: 'mobile.tabs.debate',
+    items: [
+      { key: 'dashboard', label: 'mobile.sidebar.dashboard', icon: 'target', target: { kind: 'tab', href: '/' }, matches: (pathname) => pathname === '/' },
+      { key: 'history', label: 'nav.history', icon: 'history', target: { kind: 'screen', pathname: '/history' }, matches: under('/history') },
+    ],
+  },
+  {
+    key: 'prepare',
+    label: 'mobile.tabs.prepare',
+    items: [
+      { key: 'generate', label: 'nav.generate', icon: 'sparkles', target: { kind: 'screen', pathname: '/generate' }, matches: under('/generate', '/case', '/save-case') },
+      { key: 'attack', label: 'nav.attack', icon: 'shield', target: { kind: 'screen', pathname: '/attack' }, matches: under('/attack') },
+      { key: 'brainstorm', label: 'nav.brainstorm', icon: 'bulb', target: { kind: 'screen', pathname: '/brainstorm' }, matches: under('/brainstorm') },
+      { key: 'factoids', label: 'nav.factoids', icon: 'book', target: { kind: 'screen', pathname: '/factoids' }, matches: under('/factoids') },
+      { key: 'ask', label: 'nav.ask', icon: 'chat', target: { kind: 'screen', pathname: '/ask' }, matches: under('/ask') },
+    ],
+  },
+  {
+    key: 'practice',
+    label: 'mobile.tabs.practice',
+    items: [
+      { key: 'sparring', label: 'nav.sparring', icon: 'swords', target: { kind: 'screen', pathname: '/sparring' }, matches: under('/sparring') },
+      { key: 'crossfire', label: 'nav.crossfire', icon: 'help', target: { kind: 'screen', pathname: '/crossfire' }, matches: under('/crossfire') },
+      { key: 'flowchart', label: 'nav.flowchart', icon: 'branch', target: { kind: 'screen', pathname: '/flowchart' }, matches: under('/flowchart') },
+      { key: 'timer', label: 'nav.timer', icon: 'timer', target: { kind: 'screen', pathname: '/timer' }, matches: under('/timer') },
+    ],
+  },
+  {
+    key: 'library',
+    label: 'mobile.tabs.library',
+    items: [
+      { key: 'sources', label: 'mobile.sidebar.sources', icon: 'library', target: { kind: 'tab', href: '/library' }, matches: under('/library', '/source') },
+      { key: 'add-link', label: 'mobile.library.pasteLink', icon: 'link', target: { kind: 'screen', pathname: '/add-link' }, matches: under('/add-link') },
+      { key: 'new-note', label: 'mobile.library.writeNote', icon: 'note', target: { kind: 'screen', pathname: '/new-note' }, matches: under('/new-note') },
+      { key: 'add-file', label: 'mobile.library.importFile', icon: 'upload', target: { kind: 'pickFile' }, matches: under('/add-file') },
+    ],
+  },
+  {
+    key: 'you',
+    label: 'mobile.tabs.you',
+    items: [
+      { key: 'account', label: 'mobile.sidebar.account', icon: 'user', target: { kind: 'tab', href: '/you' }, matches: under('/you', '/delete-account', '/delete-data') },
+    ],
+  },
+];
+
+/** The row the current path belongs to, if any. Sheets like the switcher belong to none and keep the last one. */
+export function activeSidebarItem(pathname: string): string | null {
+  for (const section of SIDEBAR_SECTIONS) {
+    for (const item of section.items) if (item.matches(pathname)) return item.key;
+  }
+  return null;
+}
diff --git a/apps/mobile/src/components/skeleton.tsx b/apps/mobile/src/components/skeleton.tsx
new file mode 100644
index 000000000..659a6cb2d
--- /dev/null
+++ b/apps/mobile/src/components/skeleton.tsx
@@ -0,0 +1,74 @@
+import { useEffect, useState } from 'react';
+import { StyleSheet, View, type DimensionValue, type LayoutChangeEvent, type ViewStyle } from 'react-native';
+import Animated, { cancelAnimation, useAnimatedStyle, useSharedValue, withDelay, withRepeat, withTiming } from 'react-native-reanimated';
+import { useTranslation } from 'react-i18next';
+
+import { useReduceMotion } from '@/theme/motion';
+import { radius } from '@/theme/colors';
+import { useTheme } from '@/theme/use-theme';
+
+// The website's --do-skeleton, light and dark.
+const SKELETON = { light: '#E2E9F2', dark: '#1C2A44' } as const;
+const SHINE = { light: 'rgba(255,255,255,0.55)', dark: 'rgba(255,255,255,0.06)' } as const;
+
+/**
+ * One grey shape that shimmers left to right, as the website's .skeleton-shimmer (1.2 s,
+ * starting after 300 ms so a fast load never flashes). Still under Reduce Motion.
+ */
+export function Skeleton({ width = '100%', height = 14, round = 6, style }: { width?: DimensionValue; height?: number; round?: number; style?: ViewStyle }) {
+  const { scheme } = useTheme();
+  const reduce = useReduceMotion();
+  const [span, setSpan] = useState(0);
+  const sweep = useSharedValue(0);
+  useEffect(() => {
+    if (reduce || span === 0) {
+      cancelAnimation(sweep);
+      return;
+    }
+    sweep.set(withDelay(300, withRepeat(withTiming(1, { duration: 1200 }), -1)));
+    return () => cancelAnimation(sweep);
+  }, [reduce, span, sweep]);
+  const shine = useAnimatedStyle(() => ({ transform: [{ translateX: (sweep.value * 2 - 1) * span }] }));
+  return (
+    <View
+      onLayout={(event: LayoutChangeEvent) => setSpan(event.nativeEvent.layout.width)}
+      style={[{ width, height, borderRadius: round, backgroundColor: SKELETON[scheme] }, styles.shape, style]}>
+      {reduce ? null : <Animated.View style={[StyleSheet.absoluteFill, styles.band, { backgroundColor: SHINE[scheme] }, shine]} />}
+    </View>
+  );
+}
+
+/**
+ * A list loading in the shape of its rows: an icon tile, a title and a meta line per row.
+ * It is the loading indicator (progressbar, "Loading") for VoiceOver and the screenshot script.
+ */
+export function SkeletonRows({ rows = 3, card = true, testID }: { rows?: number; card?: boolean; testID?: string }) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  return (
+    <View
+      accessible
+      accessibilityRole="progressbar"
+      accessibilityLabel={t('common.loading')}
+      testID={testID}
+      style={[card && [styles.card, { backgroundColor: colors.card, borderColor: colors.border }]]}>
+      {Array.from({ length: rows }, (_, index) => (
+        <View key={index} style={[styles.row, index > 0 && { borderTopWidth: 1, borderTopColor: colors.line }]}>
+          <Skeleton width={40} height={40} round={radius.tile} />
+          <View style={styles.text}>
+            <Skeleton width={`${78 - (index % 3) * 14}%`} height={15} />
+            <Skeleton width="42%" height={12} />
+          </View>
+        </View>
+      ))}
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  shape: { overflow: 'hidden' },
+  band: { width: '60%', opacity: 1 },
+  card: { borderWidth: 2, borderRadius: radius.card, overflow: 'hidden' },
+  row: { flexDirection: 'row', alignItems: 'center', gap: 12, paddingHorizontal: 14, paddingVertical: 13 },
+  text: { flex: 1, gap: 8 },
+});
diff --git a/apps/mobile/src/components/source-row.tsx b/apps/mobile/src/components/source-row.tsx
index fc3b0cf39..65190e017 100644
--- a/apps/mobile/src/components/source-row.tsx
+++ b/apps/mobile/src/components/source-row.tsx
@@ -2,9 +2,10 @@ import { Link } from 'expo-router';
 import { useRef } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Pressable, StyleSheet, Switch, View } from 'react-native';
+import Animated from 'react-native-reanimated';
 import ReanimatedSwipeable, { type SwipeableMethods } from 'react-native-gesture-handler/ReanimatedSwipeable';
 
-import { IconTile } from './card';
+import { IconTile, usePressScale } from './card';
 import { WEB_SWITCH_THUMB } from './form-rows';
 import { Icon } from './icon';
 import { folderLabel, SOURCE_ICONS, sourceMeta } from './source-display';
@@ -25,7 +26,7 @@ export interface SourceRowActions {
 }
 
 /** The website's quality badges: used in a case, importance and strength. */
-function QualityBadges({ source, showFolder, compact }: { source: Source; showFolder: boolean; compact: boolean }) {
+function QualityBadges({ source, showFolder, compact, pending }: { source: Source; showFolder: boolean; compact: boolean; pending: boolean }) {
   const { t } = useTranslation();
   const { colors } = useTheme();
   const semantic = source.metadata?.semantic;
@@ -40,6 +41,7 @@ function QualityBadges({ source, showFolder, compact }: { source: Source; showFo
   );
   return (
     <View style={styles.badges}>
+      {pending ? <WaitingToSync /> : null}
       {showFolder ? (
         <View style={[styles.badge, styles.folderBadge, { backgroundColor: colors.segmentTrack, borderColor: colors.segmentTrack }]}>
           <Icon name="folder" color={colors.secondary} size={12} />
@@ -55,11 +57,26 @@ function QualityBadges({ source, showFolder, compact }: { source: Source; showFo
   );
 }
 
+/** A queued change that waits for the connection (offline-queue.ts). */
+export function WaitingToSync() {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  return (
+    <View style={[styles.badge, styles.folderBadge, { backgroundColor: colors.line, borderColor: colors.line }]} testID="waiting-to-sync">
+      <Icon name="cloudOff" color={colors.faint} size={12} />
+      <Text weight="semibold" style={[styles.badgeText, { color: colors.faint }]} numberOfLines={1}>
+        {t('mobile.offlineQueue.waiting')}
+      </Text>
+    </View>
+  );
+}
+
 /**
  * A Library source. Its switch says whether the AI uses it, as on the
  * website, and a source that is off is dimmed. Swipe left to delete (with
  * Undo), swipe right to turn it on or off, and press and hold for a preview
- * and the menu. On iPad, `selectInstead` opens it beside the list.
+ * and the menu. On iPad, `selectInstead` opens it beside the list. A
+ * `pending` source has a change that waits for the connection.
  */
 export function SourceRow({
   source,
@@ -69,6 +86,7 @@ export function SourceRow({
   selectInstead = false,
   showFolder = true,
   compact = false,
+  pending = false,
   actions,
 }: {
   source: Source;
@@ -80,11 +98,13 @@ export function SourceRow({
   showFolder?: boolean;
   /** Beside an open source on iPad, whose pane shows the rankings: only the folder and use. */
   compact?: boolean;
+  pending?: boolean;
   actions: SourceRowActions;
 }) {
   const { t } = useTranslation();
   const { colors } = useTheme();
   const swipeable = useRef<SwipeableMethods>(null);
+  const press = usePressScale();
   const title = source.title || t('libraryPage.untitledSource');
   const toggleLabel = source.isActive ? t('mobile.library.turnOff') : t('mobile.library.turnOn');
 
@@ -139,6 +159,8 @@ export function SourceRow({
           onPress={(event) => {
             if (!selectInstead) return;
             event.preventDefault();
+            // On iPad the row is picked to open beside the list, not opened over it.
+            if (!selected) haptics.select();
             actions.onOpen();
           }}>
           <Link.Trigger>
@@ -154,11 +176,13 @@ export function SourceRow({
                 if (event.nativeEvent.actionName === 'toggle') toggle();
                 if (event.nativeEvent.actionName === 'delete') void remove();
               }}
+              onPressIn={press.onPressIn}
+              onPressOut={press.onPressOut}
               testID="source-row"
               // One flat style object: inside a Link's slot the web preview hands it to the DOM as is.
               style={{ flex: 1 }}>
               {({ pressed }) => (
-                <View style={[styles.content, pressed && styles.pressed]}>
+                <Animated.View style={[styles.content, pressed && styles.pressed, press.style]}>
                   <View style={!source.isActive && styles.off}>
                     <IconTile name={SOURCE_ICONS[source.type]} size={42} />
                   </View>
@@ -169,9 +193,9 @@ export function SourceRow({
                     <Text tone="faint" style={styles.rowMeta} numberOfLines={3}>
                       {source.isActive ? sourceMeta(t, source) : `${t('mobile.library.turnedOff')} · ${sourceMeta(t, source)}`}
                     </Text>
-                    <QualityBadges source={source} showFolder={showFolder} compact={compact} />
+                    <QualityBadges source={source} showFolder={showFolder} compact={compact} pending={pending} />
                   </View>
-                </View>
+                </Animated.View>
               )}
             </Pressable>
           </Link.Trigger>
diff --git a/apps/mobile/src/components/source-view.tsx b/apps/mobile/src/components/source-view.tsx
index a033fbc89..9e8b3ce09 100644
--- a/apps/mobile/src/components/source-view.tsx
+++ b/apps/mobile/src/components/source-view.tsx
@@ -1,9 +1,10 @@
 import { useFocusEffect } from 'expo-router';
 import * as WebBrowser from 'expo-web-browser';
-import { useCallback, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { ActivityIndicator, Pressable, StyleSheet, View } from 'react-native';
 
+import { SuccessCheck } from './success-check';
 import { MainActionButton, SecondaryButton, TextButton } from './buttons';
 import { Card, IconTile } from './card';
 import { Field } from './field';
@@ -11,14 +12,18 @@ import { FolderSelect } from './folder-select';
 import { FormGroup, SelectRow, SwitchRow } from './form-rows';
 import { Icon } from './icon';
 import { folderLabel, SOURCE_ICONS, sourceMeta } from './source-display';
+import { WaitingToSync } from './source-row';
 import { Text } from './text';
 import { useToast } from './toast';
 
 import { useAuth } from '@/lib/auth';
 import { formatRelativeDate } from '@/lib/dates';
 import { haptics } from '@/lib/haptics';
+import { currentSourceId, isLocalSourceId, queuedSource, queueUpdateSource, waitingSourceIds, withQueuedWrite, type QueuedPatch } from '@/lib/offline-queue';
 import { useSourceActions } from '@/lib/source-actions';
-import { fetchSource, updateSource, type Source, type SourcePatch, type SourceType } from '@/lib/sources';
+import { fetchSource, subscribeSourcesChanged, type Source, type SourceType } from '@/lib/sources';
+import { useOfflineStatus } from '@/lib/network-status';
+import { useQueuedWrites } from '@/lib/use-offline-queue';
 import { useCopyHolder } from '@/lib/use-copy-holder';
 import { useLibraryFolders } from '@/lib/use-library-folders';
 import { radius } from '@/theme/colors';
@@ -40,6 +45,9 @@ type Draft = Pick<Source, 'title' | 'content' | 'type'> & { origin: string };
  * title, type, origin and text; Save sends only what was changed.
  * The source sheet shows it with a Done button; the iPad Library shows it
  * beside the list. Mount it with a key per source, so a new selection never shows the last one.
+ * Edits, the switch and moves go through the offline queue; a note that has
+ * not reached the server is read from the queue, and its temporary id gives way
+ * to the row's once it syncs.
  */
 export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: () => void; onRemoved?: () => void }) {
   const { t, i18n } = useTranslation();
@@ -55,15 +63,28 @@ export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: ()
   const [saveError, setSaveError] = useState('');
   const copies = useCopyHolder();
   const actions = useSourceActions();
-  const { folders } = useLibraryFolders(source?.debateId ?? null);
+  const queued = useQueuedWrites(userId);
+  const realId = currentSourceId(queued, id);
+  const local = isLocalSourceId(realId);
+  // What shows: a waiting note from the queue, or the row read with the queued changes on top.
+  const view: Source | null | undefined = local ? queuedSource(queued, realId) : source && withQueuedWrite(queued, source);
+  const waiting = view ? waitingSourceIds(queued).has(view.id) : false;
+  const { offline } = useOfflineStatus();
+  const { folders } = useLibraryFolders(view?.debateId ?? null);
+
+  // A write anywhere, a queued change syncing or one the server refused reads the row again,
+  // so the view ends on what the server holds, never on an edit that did not save.
+  const [reloads, setReloads] = useState(0);
+  useEffect(() => subscribeSourcesChanged(() => setReloads((count) => count + 1)), []);
 
   // The same read as the source sheet. Leaving the screen drops the saved copy it is showing.
+  // A note that waits has no row to read yet.
   useFocusEffect(
     useCallback(() => {
-      if (!userId) return;
+      if (!userId || local) return;
       let active = true;
       setFailed(false);
-      fetchSource(userId, id, copies.mark())
+      fetchSource(userId, realId, copies.mark())
         .then((next) => {
           if (!active) return;
           setSource(next);
@@ -77,51 +98,61 @@ export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: ()
         active = false;
         copies.release();
       };
-    }, [userId, id, copies]),
+      // eslint-disable-next-line react-hooks/exhaustive-deps -- `reloads` only asks for the read again.
+    }, [userId, realId, local, copies, reloads]),
   );
 
-  const url = webUrl(source?.origin ?? null);
+  const url = webUrl(view?.origin ?? null);
 
   const toggle = async (isActive: boolean) => {
-    if (!source) return;
-    setSource({ ...source, isActive });
-    if (!(await actions.setActive([source], isActive))) setSource((current) => current && { ...current, isActive: source.isActive });
+    if (!view) return;
+    const before = view.isActive;
+    setSource((current) => current && { ...current, isActive });
+    if (!(await actions.setActive([view], isActive))) setSource((current) => current && { ...current, isActive: before });
   };
   const move = async (folder: string) => {
-    if (!source) return;
-    setSource({ ...source, folder });
-    if (!(await actions.move(source, folder))) setSource((current) => current && { ...current, folder: source.folder });
+    if (!view) return;
+    const before = view.folder;
+    setSource((current) => current && { ...current, folder });
+    if (!(await actions.move(view, folder))) setSource((current) => current && { ...current, folder: before });
   };
   const remove = async () => {
-    if (!source) return;
-    if (await actions.remove(source)) (onRemoved ?? onDone)?.();
+    if (!view) return;
+    if (await actions.remove(view)) (onRemoved ?? onDone)?.();
   };
 
   const edit = () => {
-    if (!source) return;
+    if (!view) return;
     setSaved(false);
     setSaveError('');
-    setDraft({ title: source.title, content: source.content, type: source.type, origin: source.origin ?? '' });
+    setDraft({ title: view.title, content: view.content, type: view.type, origin: view.origin ?? '' });
   };
   const save = async () => {
-    if (!source || !draft || !userId || !source.debateId || saving) return;
+    if (!view || !draft || !userId || !view.debateId || saving) return;
     if (!draft.title.trim() || !draft.content.trim()) return;
     // Only what was edited is written, so a switch flipped meanwhile is kept.
-    const patch: SourcePatch = {};
-    if (draft.title.trim() !== source.title) patch.title = draft.title;
-    if (draft.content.trim() !== source.content) patch.content = draft.content;
-    if (draft.type !== source.type) patch.type = draft.type;
-    if (draft.origin.trim() !== (source.origin ?? '')) patch.origin = draft.origin;
+    const patch: QueuedPatch = {};
+    if (draft.title.trim() !== view.title) patch.title = draft.title;
+    if (draft.content.trim() !== view.content) patch.content = draft.content;
+    if (draft.type !== view.type) patch.type = draft.type;
+    if (draft.origin.trim() !== (view.origin ?? '')) patch.origin = draft.origin;
     setSaving(true);
     setSaveError('');
     try {
-      await updateSource(userId, source.debateId, source.id, patch);
-      setSource({ ...source, title: draft.title.trim(), content: draft.content.trim(), type: draft.type, origin: draft.origin.trim() || null });
+      // Offline the edit waits on the phone; the marker below says so instead of the mint confirmation.
+      const status = await queueUpdateSource(userId, view.debateId, view.id, patch);
+      // A saved edit shows at once; a queued one shows through the queue until it syncs or is refused.
+      if (status === 'saved') {
+        setSource((current) => current && { ...current, title: draft.title.trim(), content: draft.content.trim(), type: draft.type, origin: draft.origin.trim() || null });
+      }
       setDraft(null);
-      setSaved(true);
-      haptics.success();
-      // A sheet sits above the toast, so the sheet says it here; the iPad pane gets the toast too.
-      if (!onDone) toast({ tone: 'success', title: t('libraryPage.sourceUpdated'), message: t('libraryPage.sourceUpdatedDesc') });
+      setSaved(status === 'saved');
+      if (status === 'queued') haptics.tap();
+      else {
+        haptics.success();
+        // A sheet sits above the toast, so the sheet says it here; the iPad pane gets the toast too.
+        if (!onDone) toast({ tone: 'success', title: t('libraryPage.sourceUpdated'), message: t('libraryPage.sourceUpdatedDesc') });
+      }
     } catch (cause) {
       console.warn('Could not save the source:', cause instanceof Error ? cause.message : cause);
       haptics.warning();
@@ -131,25 +162,25 @@ export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: ()
     }
   };
 
-  const semantic = source?.metadata?.semantic;
-  const words = source ? source.content.trim().split(/\s+/).filter(Boolean).length : 0;
+  const semantic = view?.metadata?.semantic;
+  const words = view ? view.content.trim().split(/\s+/).filter(Boolean).length : 0;
 
   return (
     <>
       <View style={styles.header}>
         <View style={styles.headerText}>
-          {source ? (
+          {view ? (
             <View style={styles.kind}>
-              <IconTile name={SOURCE_ICONS[source.type]} size={30} />
+              <IconTile name={SOURCE_ICONS[view.type]} size={30} />
               <Text tone="faint" style={styles.meta} numberOfLines={2}>
-                {sourceMeta(t, source)}
+                {sourceMeta(t, view)}
               </Text>
             </View>
           ) : null}
         </View>
         {draft ? (
           <TextButton label={t('common.cancel')} onPress={() => setDraft(null)} disabled={saving} />
-        ) : source ? (
+        ) : view ? (
           <TextButton label={t('mobile.library.edit')} onPress={edit} />
         ) : null}
         {onDone && !draft ? <TextButton label={t('mobile.common.done')} onPress={onDone} /> : null}
@@ -159,9 +190,9 @@ export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: ()
         <Text tone="secondary" style={styles.body}>
           {t('mobile.library.loadFailed')}
         </Text>
-      ) : source === undefined ? (
+      ) : view === undefined ? (
         <ActivityIndicator style={styles.loading} accessibilityRole="progressbar" />
-      ) : source === null ? (
+      ) : view === null ? (
         <Text tone="secondary" style={styles.body}>
           {t('mobile.library.sourceMissing')}
         </Text>
@@ -206,16 +237,21 @@ export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: ()
       ) : (
         <>
           <Text accessibilityRole="header" weight="display" style={styles.title} selectable>
-            {source.title || t('libraryPage.untitledSource')}
+            {view.title || t('libraryPage.untitledSource')}
           </Text>
           <Text tone="faint" style={styles.meta}>
-            {[folderLabel(t, source.folder), formatRelativeDate(source.createdAt), t('libraryPage.wordCount', { count: words, formatted: words.toLocaleString(i18n.language) })].join(' · ')}
+            {[folderLabel(t, view.folder), formatRelativeDate(view.createdAt), t('libraryPage.wordCount', { count: words, formatted: words.toLocaleString(i18n.language) })].join(' · ')}
           </Text>
-          {saved ? (
+          {waiting ? (
+            <View style={styles.waiting}>
+              <WaitingToSync />
+              <Text tone="faint" style={styles.waitingText}>
+                {offline ? t('mobile.offlineQueue.syncsWhenOnline') : t('mobile.offlineQueue.syncingSoon')}
+              </Text>
+            </View>
+          ) : saved ? (
             <View accessibilityRole="alert" style={[styles.saved, { backgroundColor: colors.successTint, borderColor: colors.successFill }]}>
-              <View style={[styles.check, { backgroundColor: colors.successFill }]}>
-                <Icon name="check" color="#FFFFFF" size={13} />
-              </View>
+              <SuccessCheck size={20} haptic={false} />
               <Text weight="semibold" style={[styles.savedText, { color: colors.success }]}>
                 {t('libraryPage.sourceUpdatedDesc')}
               </Text>
@@ -233,9 +269,9 @@ export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: ()
               </Text>
               <Icon name="externalLink" color={colors.primary} size={17} />
             </Pressable>
-          ) : source.origin ? (
+          ) : view.origin ? (
             <Text tone="faint" style={styles.meta}>
-              {source.origin}
+              {view.origin}
             </Text>
           ) : null}
           {semantic ? (
@@ -257,22 +293,22 @@ export function SourceView({ id, onDone, onRemoved }: { id: string; onDone?: ()
               first
               label={t('libraryPage.useForGrounding')}
               description={t('libraryPage.useForGroundingDesc')}
-              value={source.isActive}
+              value={view.isActive}
               onChange={(value) => void toggle(value)}
             />
           </FormGroup>
-          <FolderSelect folders={folders} value={source.folder} onChange={(folder) => void move(folder)} />
+          <FolderSelect folders={folders} value={view.folder} onChange={(folder) => void move(folder)} />
           <View style={styles.actions}>
             <View style={styles.action}>
-              <SecondaryButton icon="copy" label={t('common.copy')} onPress={() => void actions.copy(source)} />
+              <SecondaryButton icon="copy" label={t('common.copy')} onPress={() => void actions.copy(view)} />
             </View>
             <View style={styles.action}>
-              <SecondaryButton icon="share" label={t('mobile.library.share')} onPress={() => actions.share(source)} />
+              <SecondaryButton icon="share" label={t('mobile.library.share')} onPress={() => actions.share(view)} />
             </View>
           </View>
           <Card>
             <Text style={styles.text} selectable>
-              {source.content}
+              {view.content}
             </Text>
           </Card>
           <Pressable
@@ -309,6 +345,8 @@ const styles = StyleSheet.create({
   qualityText: { fontSize: 14, lineHeight: 19 },
   actions: { flexDirection: 'row', gap: 10 },
   action: { flex: 1 },
+  waiting: { gap: 4, alignItems: 'flex-start' },
+  waitingText: { fontSize: 13.5, lineHeight: 18 },
   saved: { flexDirection: 'row', alignItems: 'center', gap: 9, borderWidth: 2, borderRadius: radius.field, paddingVertical: 9, paddingHorizontal: 12 },
   check: { width: 20, height: 20, borderRadius: 10, alignItems: 'center', justifyContent: 'center' },
   savedText: { flex: 1, fontSize: 14.5 },
diff --git a/apps/mobile/src/components/sparring-views.tsx b/apps/mobile/src/components/sparring-views.tsx
index c1461e4fd..e19428aea 100644
--- a/apps/mobile/src/components/sparring-views.tsx
+++ b/apps/mobile/src/components/sparring-views.tsx
@@ -5,8 +5,10 @@ import type { TFunction } from 'i18next';
 import { useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { StyleSheet, View } from 'react-native';
+import Animated, { useAnimatedStyle, useSharedValue, withDelay, withSpring } from 'react-native-reanimated';
 
 import { PrimaryButton, SecondaryButton } from './buttons';
+import { PopIn } from './celebration';
 import { Bullets, DocSection, DocumentScreen, Paragraph } from './document';
 import { DocumentHeader } from './document-header';
 import { Text } from './text';
@@ -17,6 +19,7 @@ import { confirmDestructive } from '@/lib/confirm';
 import { shareText } from '@/lib/export';
 import { deleteSparringRound } from '@/lib/sparring';
 import { radius } from '@/theme/colors';
+import { SPRING, staggerDelay, useReduceMotion } from '@/theme/motion';
 import { useTheme } from '@/theme/use-theme';
 
 const CATEGORY_MAX = 25;
@@ -50,12 +53,15 @@ export function SparringScorecardScreen({
   notice,
   onRestart,
   onDeleted,
+  holdEntrance,
 }: {
   session: SparringSession & { scorecard: SparringScorecard };
   from: string | undefined;
   notice?: string;
   onRestart: () => void;
   onDeleted: () => void;
+  /** The cards and bars wait while a celebration covers them, and arrive as it goes. */
+  holdEntrance?: boolean;
 }) {
   const { t } = useTranslation();
   const { session: auth } = useAuth();
@@ -113,7 +119,7 @@ export function SparringScorecardScreen({
           <PrimaryButton label={t('sparring.scorecard.restart')} onPress={onRestart} floating testID="sparring-restart" />
         </>
       }>
-      <SparringScorecardView session={session} scorecard={session.scorecard} transcriptOpen={transcriptOpen} />
+      <SparringScorecardView session={session} scorecard={session.scorecard} transcriptOpen={transcriptOpen} holdEntrance={holdEntrance} />
     </DocumentScreen>
   );
 }
@@ -122,9 +128,21 @@ export function SparringScorecardScreen({
  * The round review from mock 06: both totals, the four categories as bars
  * instead of the website's radar chart, and the judge's verdict. Below them
  * come the website's category notes, key moments, what to work on next and
- * the overall feedback, and the transcript when Replay opens it.
+ * the overall feedback, and the transcript when Replay opens it. The totals and
+ * cards pop in one after another and the bars fill on a spring, once
+ * `holdEntrance` is off.
  */
-export function SparringScorecardView({ session, scorecard, transcriptOpen }: { session: SparringSession; scorecard: SparringScorecard; transcriptOpen: boolean }) {
+export function SparringScorecardView({
+  session,
+  scorecard,
+  transcriptOpen,
+  holdEntrance = false,
+}: {
+  session: SparringSession;
+  scorecard: SparringScorecard;
+  transcriptOpen: boolean;
+  holdEntrance?: boolean;
+}) {
   const { t } = useTranslation();
   const { colors } = useTheme();
   return (
@@ -141,66 +159,72 @@ export function SparringScorecardView({ session, scorecard, transcriptOpen }: {
         </Text>
       </View>
 
-      <View style={styles.totals}>
-        <View
-          style={[styles.total, styles.totalOwn, { backgroundColor: colors.primaryFill, borderBottomColor: colors.primaryLedge }]}
-          accessible
-          accessibilityLabel={`${t('sparring.scorecard.yourScore')}: ${scorecard.userScore}`}>
-          <Text style={[styles.totalLabel, styles.onGradient]}>{t('sparring.scorecard.yourScore')}</Text>
-          <Text weight="bold" style={[styles.totalValue, styles.onGradient]} testID="sparring-user-score">
-            {scorecard.userScore}
-          </Text>
+      <PopIn index={0} hold={holdEntrance}>
+        <View style={styles.totals}>
+          <View
+            style={[styles.total, styles.totalOwn, { backgroundColor: colors.primaryFill, borderBottomColor: colors.primaryLedge }]}
+            accessible
+            accessibilityLabel={`${t('sparring.scorecard.yourScore')}: ${scorecard.userScore}`}>
+            <Text style={[styles.totalLabel, styles.onGradient]}>{t('sparring.scorecard.yourScore')}</Text>
+            <Text weight="bold" style={[styles.totalValue, styles.onGradient]} testID="sparring-user-score">
+              {scorecard.userScore}
+            </Text>
+          </View>
+          <View style={[styles.total, { backgroundColor: colors.card, borderColor: colors.border }, styles.totalBorder]} accessible accessibilityLabel={`${t('sparring.scorecard.opponentScore')}: ${scorecard.aiScore}`}>
+            <Text tone="faint" style={styles.totalLabel}>
+              {t('sparring.scorecard.opponentScore')}
+            </Text>
+            <Text weight="bold" tone="secondary" style={styles.totalValue}>
+              {scorecard.aiScore}
+            </Text>
+          </View>
         </View>
-        <View style={[styles.total, { backgroundColor: colors.card, borderColor: colors.border }, styles.totalBorder]} accessible accessibilityLabel={`${t('sparring.scorecard.opponentScore')}: ${scorecard.aiScore}`}>
-          <Text tone="faint" style={styles.totalLabel}>
-            {t('sparring.scorecard.opponentScore')}
-          </Text>
-          <Text weight="bold" tone="secondary" style={styles.totalValue}>
-            {scorecard.aiScore}
-          </Text>
+      </PopIn>
+
+      <PopIn index={1} hold={holdEntrance}>
+        <View style={[styles.card, { backgroundColor: colors.card, borderColor: colors.border }]} testID="sparring-categories">
+          <View style={styles.cardHead}>
+            <Text accessibilityRole="header" weight="bold" style={styles.cardTitle}>
+              {t('sparring.scorecard.categoryBalance')}
+            </Text>
+            <Text tone="faint" style={styles.cardDescription}>
+              {t('sparring.scorecard.categoryDescription')}
+            </Text>
+          </View>
+          {scorecard.categories.map((category, index) => (
+            <View
+              key={category.name}
+              style={styles.category}
+              accessible
+              accessibilityLabel={`${t(`sparring.category.${category.name}`)}. ${t('sparring.scorecard.accessibleCategoryScore', { user: category.userScore, opponent: category.aiScore })}`}>
+              <View style={styles.categoryLine}>
+                <Text weight="semibold" style={styles.categoryName}>
+                  {t(`sparring.category.${category.name}`)}
+                </Text>
+                <Text tone="faint" style={styles.categoryScores}>
+                  {t('mobile.sparring.versus', { user: category.userScore, opponent: category.aiScore })}
+                </Text>
+              </View>
+              <View style={[styles.track, { backgroundColor: colors.line }]}>
+                <CategoryFill share={category.userScore / CATEGORY_MAX} index={index} hold={holdEntrance} color={colors.primaryFill} />
+                {/* The opponent's score is the tick on the same bar. */}
+                <View style={[styles.tick, { left: `${(category.aiScore / CATEGORY_MAX) * 100}%`, backgroundColor: colors.secondary }]} />
+              </View>
+            </View>
+          ))}
         </View>
-      </View>
+      </PopIn>
 
-      <View style={[styles.card, { backgroundColor: colors.card, borderColor: colors.border }]} testID="sparring-categories">
-        <View style={styles.cardHead}>
-          <Text weight="bold" style={styles.cardTitle}>
-            {t('sparring.scorecard.categoryBalance')}
+      <PopIn index={2} hold={holdEntrance}>
+        <View style={[styles.card, { backgroundColor: colors.card, borderColor: colors.border }]} testID="sparring-verdict">
+          <Text accessibilityRole="header" weight="bold" style={styles.cardTitle}>
+            {t('sparring.scorecard.verdict')}
           </Text>
-          <Text tone="faint" style={styles.cardDescription}>
-            {t('sparring.scorecard.categoryDescription')}
+          <Text tone="secondary" style={styles.verdict} selectable>
+            {scorecard.verdict}
           </Text>
         </View>
-        {scorecard.categories.map((category) => (
-          <View
-            key={category.name}
-            style={styles.category}
-            accessible
-            accessibilityLabel={`${t(`sparring.category.${category.name}`)}. ${t('sparring.scorecard.accessibleCategoryScore', { user: category.userScore, opponent: category.aiScore })}`}>
-            <View style={styles.categoryLine}>
-              <Text weight="semibold" style={styles.categoryName}>
-                {t(`sparring.category.${category.name}`)}
-              </Text>
-              <Text tone="faint" style={styles.categoryScores}>
-                {t('mobile.sparring.versus', { user: category.userScore, opponent: category.aiScore })}
-              </Text>
-            </View>
-            <View style={[styles.track, { backgroundColor: colors.line }]}>
-              <View style={[styles.fill, { width: `${(category.userScore / CATEGORY_MAX) * 100}%`, backgroundColor: colors.primaryFill }]} />
-              {/* The opponent's score is the tick on the same bar. */}
-              <View style={[styles.tick, { left: `${(category.aiScore / CATEGORY_MAX) * 100}%`, backgroundColor: colors.secondary }]} />
-            </View>
-          </View>
-        ))}
-      </View>
-
-      <View style={[styles.card, { backgroundColor: colors.card, borderColor: colors.border }]} testID="sparring-verdict">
-        <Text weight="bold" style={styles.cardTitle}>
-          {t('sparring.scorecard.verdict')}
-        </Text>
-        <Text tone="secondary" style={styles.verdict} selectable>
-          {scorecard.verdict}
-        </Text>
-      </View>
+      </PopIn>
 
       <DocSection title={t('sparring.scorecard.categoryNotes')} description={t('sparring.scorecard.categoryNotesDescription')}>
         {scorecard.categories.map((category) => (
@@ -242,6 +266,24 @@ export function SparringScorecardView({ session, scorecard, transcriptOpen }: {
   );
 }
 
+/**
+ * A category's bar, grown from empty on a spring after the cards arrive, one bar after another.
+ * The spring's overshoot never runs past the end of the track. Under Reduce Motion it is full at once.
+ */
+function CategoryFill({ share, index, hold, color }: { share: number; index: number; hold: boolean; color: string }) {
+  const reduce = useReduceMotion();
+  const grow = useSharedValue(reduce ? 1 : 0);
+  useEffect(() => {
+    if (reduce) {
+      grow.set(1);
+      return;
+    }
+    if (!hold) grow.set(withDelay(120 + staggerDelay(index) * 2, withSpring(1, SPRING.settle)));
+  }, [grow, hold, index, reduce]);
+  const style = useAnimatedStyle(() => ({ width: `${Math.min(1, Math.max(0, share * grow.value)) * 100}%` }));
+  return <Animated.View style={[styles.fill, { backgroundColor: color }, style]} />;
+}
+
 /** Every speech of a round, who gave it, and the time it took, as the website's transcript. */
 export function SparringTranscript({ speeches }: { speeches: SparringSpeech[] }) {
   const { t } = useTranslation();
diff --git a/apps/mobile/src/components/success-check.tsx b/apps/mobile/src/components/success-check.tsx
new file mode 100644
index 000000000..eee1557d7
--- /dev/null
+++ b/apps/mobile/src/components/success-check.tsx
@@ -0,0 +1,72 @@
+import { useEffect } from 'react';
+import { StyleSheet } from 'react-native';
+import Animated, {
+  useAnimatedProps,
+  useAnimatedStyle,
+  useSharedValue,
+  withDelay,
+  withSequence,
+  withTiming,
+} from 'react-native-reanimated';
+import Svg, { Path } from 'react-native-svg';
+
+import { haptics } from '@/lib/haptics';
+import { EASE, useReduceMotion } from '@/theme/motion';
+import { useTheme } from '@/theme/use-theme';
+
+const AnimatedPath = Animated.createAnimatedComponent(Path);
+// The check's path is about 23 units long, as the website's lucide Check.
+const CHECK_LENGTH = 24;
+
+/**
+ * Success, always mint with a check mark: the badge pops on the overshoot curve and the tick
+ * draws itself in (the website's .success-pop and check-draw), with a success tap. `delay`
+ * staggers it after something else arrives; `haptic={false}` where the caller already tapped.
+ * Under Reduce Motion it is simply there.
+ */
+export function SuccessCheck({ size = 22, delay = 0, haptic = true }: { size?: number; delay?: number; haptic?: boolean }) {
+  const { colors } = useTheme();
+  const reduce = useReduceMotion();
+  const pop = useSharedValue(reduce ? 1 : 0);
+  const draw = useSharedValue(reduce ? 1 : 0);
+
+  useEffect(() => {
+    if (haptic) haptics.success();
+    if (reduce) {
+      pop.set(1);
+      draw.set(1);
+      return;
+    }
+    // 0.4 → 1.14 → 1 over 420 ms, then the tick draws over 360 ms from 140 ms in.
+    pop.set(withDelay(delay, withSequence(withTiming(1.14, { duration: 250, easing: EASE.decelerate }), withTiming(1, { duration: 170, easing: EASE.standard }))));
+    draw.set(withDelay(delay + 140, withTiming(1, { duration: 360, easing: EASE.decelerate })));
+    // One pop per mount: a re-render must not replay it.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const badge = useAnimatedStyle(() => ({
+    opacity: Math.min(1, pop.value * 1.6),
+    transform: [{ scale: 0.4 + 0.6 * pop.value }],
+  }));
+  const tick = useAnimatedProps(() => ({ strokeDashoffset: CHECK_LENGTH * (1 - draw.value) }));
+
+  return (
+    <Animated.View style={[styles.badge, { width: size, height: size, borderRadius: size / 2, backgroundColor: colors.successFill }, badge]}>
+      <Svg width={size * 0.64} height={size * 0.64} viewBox="0 0 24 24" fill="none">
+        <AnimatedPath
+          d="M20 6 9 17l-5-5"
+          stroke="#FFFFFF"
+          strokeWidth={3.2}
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          strokeDasharray={CHECK_LENGTH}
+          animatedProps={tick}
+        />
+      </Svg>
+    </Animated.View>
+  );
+}
+
+const styles = StyleSheet.create({
+  badge: { alignItems: 'center', justifyContent: 'center' },
+});
diff --git a/apps/mobile/src/components/text.tsx b/apps/mobile/src/components/text.tsx
index b814f78fd..45a8d7c14 100644
--- a/apps/mobile/src/components/text.tsx
+++ b/apps/mobile/src/components/text.tsx
@@ -1,13 +1,28 @@
-import { Text as NativeText, type TextProps } from 'react-native';
+import { Text as NativeText, StyleSheet, type StyleProp, type TextProps, type TextStyle } from 'react-native';
 
 import { fontFamily, type FontWeight } from '@/theme/fonts';
+import { webFontScale } from '@/theme/font-scale';
 import { useTheme } from '@/theme/use-theme';
 
 type Props = TextProps & { weight?: FontWeight; tone?: 'foreground' | 'heading' | 'secondary' | 'faint' };
 
+/**
+ * Sizes for a text size the web preview draws (font-scale.web.ts); on iOS the
+ * system scales text and this returns the style unchanged. A cap set with
+ * maxFontSizeMultiplier applies, as on iOS.
+ */
+export function scaledForPreview<T extends TextStyle>(style: StyleProp<T>, maxFontSizeMultiplier?: number | null): StyleProp<T> {
+  const scale = webFontScale();
+  if (scale === 1) return style;
+  const factor = maxFontSizeMultiplier && maxFontSizeMultiplier >= 1 ? Math.min(scale, maxFontSizeMultiplier) : scale;
+  const flat = StyleSheet.flatten(style) as T | undefined;
+  const fontSize = flat?.fontSize ?? 14;
+  return [style, { fontSize: fontSize * factor, ...(flat?.lineHeight ? { lineHeight: flat.lineHeight * factor } : {}) } as T];
+}
+
 /** Body text in Nunito; a display weight (Fredoka) is a heading and takes the heading navy unless a tone is given. */
 export function Text({ weight = 'regular', tone, style, ...props }: Props) {
   const { colors } = useTheme();
   const color = colors[tone ?? (weight.startsWith('display') ? 'heading' : 'foreground')];
-  return <NativeText {...props} style={[{ color, fontFamily: fontFamily[weight] }, style]} />;
+  return <NativeText {...props} style={scaledForPreview([{ color, fontFamily: fontFamily[weight] }, style], props.maxFontSizeMultiplier)} />;
 }
diff --git a/apps/mobile/src/components/toast.tsx b/apps/mobile/src/components/toast.tsx
index b9314bfab..ed3c19c98 100644
--- a/apps/mobile/src/components/toast.tsx
+++ b/apps/mobile/src/components/toast.tsx
@@ -3,9 +3,11 @@ import { AccessibilityInfo, Pressable, StyleSheet, View } from 'react-native';
 import Animated, { FadeInDown, FadeOutDown } from 'react-native-reanimated';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
+import { SuccessCheck } from './success-check';
 import { Icon } from './icon';
 import { Text } from './text';
 
+import { motionSetting, useReduceMotion } from '@/theme/motion';
 import { haptics } from '@/lib/haptics';
 import { radius } from '@/theme/colors';
 import { useTheme } from '@/theme/use-theme';
@@ -80,21 +82,20 @@ export function ToastHost() {
 
 function ToastView({ toast, onClose }: { toast: ShownToast; onClose: () => void }) {
   const { colors, scheme } = useTheme();
+  const reduce = useReduceMotion();
   const insets = useSafeAreaInsets();
   const face = scheme === 'dark' ? colors.card : colors.heading;
   const text = scheme === 'dark' ? colors.foreground : '#FFFFFF';
   return (
     <View pointerEvents="box-none" style={[styles.layer, { bottom: insets.bottom + TAB_BAR }]}>
       <Animated.View
-        entering={FadeInDown.duration(180)}
-        exiting={FadeOutDown.duration(160)}
+        entering={FadeInDown.duration(180).reduceMotion(motionSetting(reduce))}
+        exiting={FadeOutDown.duration(160).reduceMotion(motionSetting(reduce))}
         accessibilityLiveRegion="polite"
         testID="toast"
         style={[styles.toast, { backgroundColor: face, borderColor: scheme === 'dark' ? colors.border : face }]}>
         {toast.tone === 'success' ? (
-          <View style={[styles.badge, { backgroundColor: colors.successFill }]}>
-            <Icon name="check" color="#FFFFFF" size={15} />
-          </View>
+          <SuccessCheck size={22} delay={120} haptic={false} />
         ) : toast.tone === 'error' ? (
           <Icon name="alert" color={scheme === 'dark' ? colors.destructive : '#FF9FA2'} size={20} />
         ) : null}
diff --git a/apps/mobile/src/components/trial-banner.tsx b/apps/mobile/src/components/trial-banner.tsx
new file mode 100644
index 000000000..7c2b46d63
--- /dev/null
+++ b/apps/mobile/src/components/trial-banner.tsx
@@ -0,0 +1,110 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { trialDaysLeft } from '@debatelab/core/trial';
+import { useFocusEffect, useRouter } from 'expo-router';
+import { useCallback, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Pressable, StyleSheet, View, type ViewStyle } from 'react-native';
+
+import { Icon } from './icon';
+import { Text } from './text';
+
+import { useAuth } from '@/lib/auth';
+import { fetchSubscription } from '@/lib/subscription';
+import { radius } from '@/theme/colors';
+import { useTheme } from '@/theme/use-theme';
+
+const dismissedKey = (userId: string, endsAt: string) => `debatelab:trial-banner-dismissed:${userId}:${endsAt}`;
+
+/** The trial's end date while a trial runs and the student has not hidden its reminder; read again on focus. */
+function useTrialEnd(userId: string | null): { endsAt: string | null; dismiss: () => void } {
+  const [endsAt, setEndsAt] = useState<string | null>(null);
+  const [dismissed, setDismissed] = useState<string | null>(null);
+
+  useFocusEffect(
+    useCallback(() => {
+      if (!userId) return;
+      let live = true;
+      fetchSubscription(userId)
+        .then(async (subscription) => {
+          const end = subscription.billingState === 'trial' && subscription.billingDateKind === 'ends' ? subscription.billingDate : null;
+          const hidden = end ? (await AsyncStorage.getItem(dismissedKey(userId, end))) === '1' : false;
+          if (!live) return;
+          setEndsAt(end);
+          if (hidden && end) setDismissed(dismissedKey(userId, end));
+        })
+        // Offline or refused: no reminder, as when no trial runs.
+        .catch(() => undefined);
+      return () => {
+        live = false;
+      };
+    }, [userId]),
+  );
+
+  // Another account's trial never shows under this one.
+  useEffect(() => setEndsAt(null), [userId]);
+
+  const key = userId && endsAt ? dismissedKey(userId, endsAt) : null;
+  return {
+    endsAt: key && dismissed !== key ? endsAt : null,
+    dismiss: () => {
+      if (!key) return;
+      setDismissed(key);
+      AsyncStorage.setItem(key, '1').catch(() => undefined);
+    },
+  };
+}
+
+/**
+ * The website's TrialBanner: "Free trial: 2 days left." while a trial runs.
+ * Hiding it hides it for this trial on this device; a new end date shows it
+ * again. Its next step is the plan in You, since upgrading waits for in-app purchase.
+ */
+export function TrialBanner({ style }: { style?: ViewStyle }) {
+  const { t } = useTranslation();
+  const { colors } = useTheme();
+  const router = useRouter();
+  const { session } = useAuth();
+  const { endsAt, dismiss } = useTrialEnd(session?.user.id ?? null);
+  const daysLeft = endsAt ? trialDaysLeft(endsAt) : null;
+  if (daysLeft === null) return null;
+  const message = daysLeft === 0 ? t('trialBanner.endsToday') : t('trialBanner.daysLeft', { count: daysLeft });
+
+  return (
+    <View
+      accessibilityLabel={t('settings.tierTrial')}
+      testID="trial-banner"
+      style={[styles.banner, { backgroundColor: colors.tile, borderColor: colors.tileBorder }, style]}>
+      <Icon name="timer" color={colors.primary} size={18} />
+      <Text weight="medium" style={[styles.message, { color: colors.tileText }]}>
+        {message}
+      </Text>
+      <Pressable
+        accessibilityRole="button"
+        onPress={() => router.navigate('/you')}
+        hitSlop={6}
+        style={({ pressed }) => [styles.action, pressed && styles.pressed]}>
+        <Text weight="semibold" style={[styles.actionText, { color: colors.primary }]}>
+          {t('mobile.trialBanner.seePlan')}
+        </Text>
+      </Pressable>
+      <Pressable
+        accessibilityRole="button"
+        accessibilityLabel={t('trialBanner.dismiss')}
+        onPress={dismiss}
+        hitSlop={8}
+        testID="trial-banner-dismiss"
+        style={({ pressed }) => [styles.dismiss, pressed && styles.pressed]}>
+        <Icon name="x" color={colors.tabInactive} size={18} />
+      </Pressable>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  banner: { flexDirection: 'row', alignItems: 'center', flexWrap: 'wrap', gap: 10, borderWidth: 2, borderRadius: radius.card, paddingVertical: 8, paddingLeft: 14, paddingRight: 6 },
+  message: { flex: 1, minWidth: 160, fontSize: 15, lineHeight: 20, paddingVertical: 4 },
+  action: { minHeight: 44, justifyContent: 'center', paddingHorizontal: 6 },
+  actionText: { fontSize: 15 },
+  dismiss: { width: 44, height: 44, alignItems: 'center', justifyContent: 'center' },
+  pressed: { opacity: 0.6 },
+});
diff --git a/apps/mobile/src/components/work-row.tsx b/apps/mobile/src/components/work-row.tsx
index bf2effa8f..061111d9d 100644
--- a/apps/mobile/src/components/work-row.tsx
+++ b/apps/mobile/src/components/work-row.tsx
@@ -1,8 +1,9 @@
 import { Link, useRouter, type Href } from 'expo-router';
 import { useTranslation } from 'react-i18next';
 import { Pressable, StyleSheet, View } from 'react-native';
+import Animated from 'react-native-reanimated';
 
-import { IconTile } from './card';
+import { IconTile, usePressScale } from './card';
 import { Icon } from './icon';
 import type { IconName } from './icon-paths';
 import { Text } from './text';
@@ -72,6 +73,7 @@ export function WorkRow({
   const { colors } = useTheme();
   const router = useRouter();
   const actions = useWorkActions();
+  const press = usePressScale();
   const title = item.title || t(`debate.kinds.${item.kind}`);
   const href = from ? workHref(item, from) : null;
   // Practice work opens the Practice tab, which has nothing to preview, so it is a plain row that navigates itself.
@@ -81,11 +83,13 @@ export function WorkRow({
       accessibilityRole="button"
       accessibilityLabel={t('mobile.common.openItem', { title })}
       onPress={linked ? onPress : onPress ?? (href ? () => router.navigate(href) : undefined)}
+      onPressIn={press.onPressIn}
+      onPressOut={press.onPressOut}
       testID="work-row"
       // One flat style object: inside a Link's slot the web preview hands it to the DOM as is.
       style={StyleSheet.flatten([!first && { borderTopWidth: 1, borderTopColor: colors.line }, { backgroundColor: colors.card }])}>
       {({ pressed }) => (
-        <View style={[styles.row, pressed && styles.pressed]}>
+        <Animated.View style={[styles.row, pressed && styles.pressed, press.style]}>
           <IconTile name={KIND_ICONS[item.kind]} size={42} />
           <View style={styles.rowText}>
             <Text weight="semibold" style={styles.rowTitle} numberOfLines={2}>
@@ -96,7 +100,7 @@ export function WorkRow({
             </Text>
           </View>
           <Icon name="chevronRight" color={colors.tabInactive} size={20} />
-        </View>
+        </Animated.View>
       )}
     </Pressable>
   );
diff --git a/apps/mobile/src/lib/a11y.test.ts b/apps/mobile/src/lib/a11y.test.ts
new file mode 100644
index 000000000..da7debbbd
--- /dev/null
+++ b/apps/mobile/src/lib/a11y.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('react-native', () => ({ AccessibilityInfo: { announceForAccessibility: vi.fn() } }));
+vi.mock('./i18n', () => ({ default: { t: (key: string) => key } }));
+
+import { spokenText } from './a11y';
+
+describe('spokenText', () => {
+  it('reads an answer without Markdown marks, link targets or citation numbers', () => {
+    expect(spokenText('## Short answer\n\n**Yes.** Free buses [cut traffic](https://example.org) by 9% [2].\n\n- first\n- second'))
+      .toBe('Short answer Yes. Free buses cut traffic by 9%. first second');
+  });
+
+  it('stops a long answer at a sentence, so VoiceOver never reads the whole page', () => {
+    const answer = `${'Free buses cut traffic. '.repeat(30)}`;
+    const spoken = spokenText(answer, 100);
+    expect(spoken.length).toBeLessThanOrEqual(101);
+    expect(spoken.endsWith('traffic.')).toBe(true);
+  });
+});
diff --git a/apps/mobile/src/lib/a11y.ts b/apps/mobile/src/lib/a11y.ts
new file mode 100644
index 000000000..d7790dca7
--- /dev/null
+++ b/apps/mobile/src/lib/a11y.ts
@@ -0,0 +1,38 @@
+import { AccessibilityInfo } from 'react-native';
+
+import i18n from './i18n';
+
+/** How much of an answer VoiceOver reads on its own; the rest is a swipe away on screen. */
+const SPOKEN_LIMIT = 400;
+
+/** An answer as speech: Markdown marks and citation numbers out, whitespace folded, cut at a sentence. */
+export function spokenText(markdown: string, limit = SPOKEN_LIMIT): string {
+  const plain = markdown
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/!\[[^\]]*\]\([^)]*\)/g, ' ')
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+    .replace(/\s*\[\d+\]/g, '')
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/[*_`>~]+/g, '')
+    .replace(/^\s*[-•]\s+/gm, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (plain.length <= limit) return plain;
+  const cut = plain.slice(0, limit);
+  const sentence = cut.lastIndexOf('. ');
+  return sentence > limit / 2 ? cut.slice(0, sentence + 1) : `${cut.trimEnd()}…`;
+}
+
+/**
+ * VoiceOver hears an AI answer once it is finished, never token by token:
+ * "Answer ready" and its first sentences. Streamed text itself is not a live region.
+ */
+export function announceAnswer(markdown: string) {
+  const text = spokenText(markdown);
+  AccessibilityInfo.announceForAccessibility(text ? `${i18n.t('mobile.a11y.answerReady')}. ${text}` : i18n.t('mobile.a11y.answerReady'));
+}
+
+/** A tool's result is ready to read: its title, so the student knows what opened. */
+export function announceResult(title: string) {
+  AccessibilityInfo.announceForAccessibility(i18n.t('mobile.a11y.resultReady', { title }));
+}
diff --git a/apps/mobile/src/lib/auth.tsx b/apps/mobile/src/lib/auth.tsx
index e186eab8a..99f67e2a6 100644
--- a/apps/mobile/src/lib/auth.tsx
+++ b/apps/mobile/src/lib/auth.tsx
@@ -4,6 +4,7 @@ import { createContext, useCallback, useContext, useEffect, useMemo, useRef, use
 import { getInstallId, sessionStorage } from './device-storage';
 import { setCacheOwner } from './offline-cache';
 import { forgetPushOnSignOut } from './push';
+import { clearSessionExpired, sessionExpired as isSessionExpired, signingOutOnPurpose, subscribeSessionExpired } from './session-expiry';
 import { setSessionOwner } from './session-memory';
 import { supabase } from './supabase';
 import { sessionStorageKey } from './supabase-config';
@@ -18,6 +19,9 @@ type AuthContextValue = {
   verifyEmailOtp: (email: string, token: string) => Promise<void>;
   signInWithDemoCode: (code: string) => Promise<void>;
   signOut: () => Promise<void>;
+  /** The server ended the session (refresh refused), not the student: the sign-in screen says so, as the website's does. */
+  sessionExpired: boolean;
+  clearSessionExpired: () => void;
 };
 
 const AuthContext = createContext<AuthContextValue | null>(null);
@@ -89,6 +93,9 @@ export function AuthProvider({ children }: { children: ReactNode }) {
   }, []);
   const [loading, setLoading] = useState(true);
   const [settled, setSettled] = useState(false);
+  // Set by the session storage when supabase-js removes a session nobody signed out of (session-expiry.ts).
+  const [sessionExpired, setSessionExpired] = useState(isSessionExpired);
+  useEffect(() => subscribeSessionExpired(setSessionExpired), []);
   // Counts auth changes, so a storage read that lands after a newer change is dropped.
   const generation = useRef(0);
 
@@ -145,29 +152,33 @@ export function AuthProvider({ children }: { children: ReactNode }) {
       });
       if (verificationError) throw verificationError;
     },
-    signOut: async () => {
-      // While the session still works, so the next person on this phone gets none of this account's notifications.
-      if (session) await forgetPushOnSignOut(session.user.id, session.access_token);
-      // supabase-js loads the session before signing out. Offline with an
-      // expired access token that refresh fails, and it returns the error
-      // without removing the stored session. Signing out must still sign out
-      // here, so the stored session is removed whatever the server said.
-      const globalError = await signOutError('global');
-      if (globalError) {
-        console.warn('Sign-out on the server failed; signing out on this device only:', globalError);
-        const localError = await signOutError('local');
-        if (localError) console.warn('Local sign-out failed:', localError);
-      }
-      try {
-        await sessionStorage.removeItem(sessionStorageKey);
-      } catch (cause) {
-        console.warn('Could not remove the stored session:', cause);
-      }
-      generation.current += 1;
-      setSession(null);
-      setLoading(false);
-    },
-  }), [session, loading, settled, setSession]);
+    signOut: () =>
+      // The removals below are the student's own, not an expired session.
+      signingOutOnPurpose(async () => {
+        // While the session still works, so the next person on this phone gets none of this account's notifications.
+        if (session) await forgetPushOnSignOut(session.user.id, session.access_token);
+        // supabase-js loads the session before signing out. Offline with an
+        // expired access token that refresh fails, and it returns the error
+        // without removing the stored session. Signing out must still sign out
+        // here, so the stored session is removed whatever the server said.
+        const globalError = await signOutError('global');
+        if (globalError) {
+          console.warn('Sign-out on the server failed; signing out on this device only:', globalError);
+          const localError = await signOutError('local');
+          if (localError) console.warn('Local sign-out failed:', localError);
+        }
+        try {
+          await sessionStorage.removeItem(sessionStorageKey);
+        } catch (cause) {
+          console.warn('Could not remove the stored session:', cause);
+        }
+        generation.current += 1;
+        setSession(null);
+        setLoading(false);
+      }),
+    sessionExpired,
+    clearSessionExpired,
+  }), [session, loading, settled, setSession, sessionExpired]);
 
   return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
 }
diff --git a/apps/mobile/src/lib/back-label.ts b/apps/mobile/src/lib/back-label.ts
index bf6d6f584..c2156703d 100644
--- a/apps/mobile/src/lib/back-label.ts
+++ b/apps/mobile/src/lib/back-label.ts
@@ -4,6 +4,7 @@ import type { TFunction } from 'i18next';
 export function backLabel(t: TFunction, from: string | undefined, fallback: 'debate' | 'prepare' | 'practice'): string {
   if (from === 'history') return t('historyPage.title');
   if (from === 'you') return t('mobile.tabs.you');
+  if (from === 'library') return t('mobile.tabs.library');
   const tab = from === 'debate' || from === 'prepare' || from === 'practice' ? from : from ? null : fallback;
   return tab ? t(`mobile.tabs.${tab}`) : t('common.back');
 }
diff --git a/apps/mobile/src/lib/debate-context.tsx b/apps/mobile/src/lib/debate-context.tsx
index 9488d9274..c98705114 100644
--- a/apps/mobile/src/lib/debate-context.tsx
+++ b/apps/mobile/src/lib/debate-context.tsx
@@ -1,6 +1,8 @@
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
 import { AppState } from 'react-native';
 
+import { publishCurrentDebate } from './debate-widget';
+import { clearSpotlight } from './spotlight';
 import { useAuth } from './auth';
 import {
   continueDebate,
@@ -94,6 +96,16 @@ export function DebateProvider({ children }: { children: ReactNode }) {
     return () => subscription.remove();
   }, [userId, refresh]);
 
+  // The Home Screen widget shows the Current Debate (a no-op in Expo Go); the Debate tab adds its counts.
+  const currentMotion = debates.find((debate) => debate.id === currentId)?.motion ?? null;
+  // Signed out, nothing of the account stays searchable in Spotlight.
+  useEffect(() => {
+    if (!userId) void clearSpotlight();
+  }, [userId]);
+  useEffect(() => {
+    publishCurrentDebate(userId && currentId && currentMotion ? { debateId: currentId, motion: currentMotion, counts: null } : null);
+  }, [userId, currentId, currentMotion]);
+
   const value = useMemo<DebateContextValue>(() => {
     const current = debates.find((debate) => debate.id === currentId) ?? null;
     return {
diff --git a/apps/mobile/src/lib/debate-widget.ts b/apps/mobile/src/lib/debate-widget.ts
new file mode 100644
index 000000000..15c9f1d09
--- /dev/null
+++ b/apps/mobile/src/lib/debate-widget.ts
@@ -0,0 +1,166 @@
+import { requireOptionalNativeModule } from 'expo';
+import { File } from 'expo-file-system';
+import { Image } from 'react-native';
+
+import { palette } from '@/theme/colors';
+import type { CurrentDebateWidgetProps, WidgetColors } from '@/widgets/current-debate';
+
+import type { DebateCounts } from './debates';
+import i18n from './i18n';
+import { nativeCapabilities } from './native-capabilities';
+
+/**
+ * What the Current Debate's Home Screen widget shows: the motion and the
+ * Debate tab's counts, or null when there is no Current Debate (signed out
+ * or none started; one-off mode keeps it, as the Debate tab does). Counts
+ * are null when the caller does not have them (the debate context); the last
+ * counts published for the same debate are kept then, so the context and the
+ * Debate tab can both publish.
+ */
+export type CurrentDebateSnapshot = { debateId?: string; motion: string; counts: DebateCounts | null } | null;
+
+type WidgetsModule = { widgetsDirectory?: string | null };
+type CurrentDebateWidget = { updateSnapshot: (props: CurrentDebateWidgetProps) => void };
+
+const OWL_FILE = 'owl-mark.png';
+const MARK = require('@/assets/owl/mark.png');
+
+let enabled: boolean | undefined;
+let widget: Promise<CurrentDebateWidget | null> | undefined;
+let owl: Promise<string | null> | undefined;
+let latest: CurrentDebateSnapshot | undefined;
+let known: { debateId?: string; motion: string; counts: DebateCounts } | null = null;
+let written: string | null = null;
+let watchingLanguage = false;
+
+/**
+ * Gives the widget the Current Debate. Call it whenever the Current Debate,
+ * its motion or its counts change, with null on sign-out. A no-op in Expo Go,
+ * on the web, and in a development build without the App Group: only a build
+ * with the widget extension has somewhere to write. Identical data is not
+ * written again, because every write reloads the widget's timeline, which
+ * iOS budgets. The labels follow the app's language and are written again
+ * when it changes.
+ */
+export function publishCurrentDebate(snapshot: CurrentDebateSnapshot): void {
+  enabled ??= nativeCapabilities().widgets;
+  if (!enabled) return;
+  if (snapshot?.counts) {
+    known = { debateId: snapshot.debateId, motion: snapshot.motion, counts: snapshot.counts };
+  } else if (snapshot && known && sameDebate(snapshot, known)) {
+    snapshot = { ...snapshot, counts: known.counts };
+  }
+  latest = snapshot;
+  if (!watchingLanguage) {
+    watchingLanguage = true;
+    i18n.on('languageChanged', () => {
+      if (latest !== undefined) void write(latest);
+    });
+  }
+  void write(snapshot);
+}
+
+// By id when both sides have one, otherwise by motion.
+function sameDebate(a: { debateId?: string; motion: string }, b: { debateId?: string; motion: string }): boolean {
+  return a.debateId && b.debateId ? a.debateId === b.debateId : a.motion === b.motion;
+}
+
+async function write(snapshot: CurrentDebateSnapshot): Promise<void> {
+  try {
+    widget ??= loadWidget();
+    owl ??= copyOwl();
+    const [target, owlUri] = await Promise.all([widget, owl]);
+    // A newer publish landed while this one waited; it writes instead.
+    if (!target || snapshot !== latest) return;
+    const props = widgetProps(snapshot, owlUri);
+    const serialized = JSON.stringify(props);
+    if (serialized === written) return;
+    written = serialized;
+    target.updateSnapshot(props);
+  } catch (cause) {
+    written = null;
+    console.warn('Could not update the Current Debate widget:', cause instanceof Error ? cause.message : cause);
+  }
+}
+
+// Only loaded once the build is known to have the widget module: creating the widget needs it.
+async function loadWidget(): Promise<CurrentDebateWidget | null> {
+  try {
+    return (await import('@/widgets/current-debate')).default;
+  } catch (cause) {
+    console.warn('The Current Debate widget is not available:', cause instanceof Error ? cause.message : cause);
+    return null;
+  }
+}
+
+/**
+ * The widget extension cannot read the app's bundle, so the owl mark is
+ * copied into the App Group folder once. Without it the widget shows a symbol.
+ */
+async function copyOwl(): Promise<string | null> {
+  try {
+    const directory = requireOptionalNativeModule<WidgetsModule>('ExpoWidgets')?.widgetsDirectory;
+    if (!directory) return null;
+    const target = new File(directory, OWL_FILE);
+    if (target.exists) return target.uri;
+    const source = Image.resolveAssetSource(MARK)?.uri;
+    if (!source) return null;
+    // A development build serves assets from Metro; a release build has them on disk.
+    if (/^https?:/i.test(source)) {
+      await File.downloadFileAsync(source, target, { idempotent: true });
+    } else {
+      new File(source).copy(target);
+    }
+    return target.uri;
+  } catch (cause) {
+    console.warn('Could not give the widget the owl mark:', cause instanceof Error ? cause.message : cause);
+    return null;
+  }
+}
+
+function colorsFor(scheme: 'light' | 'dark'): WidgetColors {
+  const colors = palette[scheme];
+  return {
+    background: colors.background,
+    heading: colors.heading,
+    secondary: colors.secondary,
+    primary: colors.primary,
+    primaryFill: colors.primaryFill,
+    onPrimary: colors.onPrimary,
+  };
+}
+
+/** The widget's props in the app's current language. */
+function widgetProps(snapshot: CurrentDebateSnapshot, owlUri: string | null): CurrentDebateWidgetProps {
+  const t = i18n.t.bind(i18n);
+  const counts = snapshot?.counts ?? null;
+  const sources = counts ? { value: counts.sources, label: t('mobile.debate.statSources', { count: counts.sources }) } : null;
+  const rounds = counts ? { value: counts.rounds, label: t('mobile.debate.statRounds', { count: counts.rounds }) } : null;
+  return {
+    motion: snapshot?.motion ?? null,
+    title: t('nav.currentDebate'),
+    // The Debate tab opens on In favor, so its results figure is that side's.
+    stats:
+      counts && sources && rounds
+        ? [sources, { value: counts.results.pro, label: t('mobile.debate.statResults', { count: counts.results.pro }) }, rounds]
+        : [],
+    wideStats:
+      counts && sources && rounds
+        ? [
+            sources,
+            { value: counts.results.pro, label: t('debate.side.pro') },
+            { value: counts.results.con, label: t('debate.side.con') },
+            rounds,
+          ]
+        : [],
+    spar: t('mobile.widget.spar'),
+    emptyTitle: t('debate.noCurrentTitle'),
+    emptyAction: t('debate.startNew'),
+    openUrl: 'debatelab://',
+    sparUrl: 'debatelab://sparring',
+    newDebateUrl: 'debatelab://new-debate',
+    owl: owlUri,
+    light: colorsFor('light'),
+    dark: colorsFor('dark'),
+  };
+}
diff --git a/apps/mobile/src/lib/debate-widget.web.ts b/apps/mobile/src/lib/debate-widget.web.ts
new file mode 100644
index 000000000..0df4cbd4e
--- /dev/null
+++ b/apps/mobile/src/lib/debate-widget.web.ts
@@ -0,0 +1,6 @@
+import type { DebateCounts } from './debates';
+
+/** The web preview has no Home Screen widget. Same signature as debate-widget.ts. */
+export type CurrentDebateSnapshot = { debateId?: string; motion: string; counts: DebateCounts | null } | null;
+
+export function publishCurrentDebate(_snapshot: CurrentDebateSnapshot): void {}
diff --git a/apps/mobile/src/lib/deep-links.test.ts b/apps/mobile/src/lib/deep-links.test.ts
new file mode 100644
index 000000000..d0fb42281
--- /dev/null
+++ b/apps/mobile/src/lib/deep-links.test.ts
@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+
+import { appPathForUrl, isShareCode } from './deep-links';
+
+describe('appPathForUrl', () => {
+  it('opens a share link on either host', () => {
+    expect(appPathForUrl('https://debateowl.com/share/Ab3dEf7hIj9kLm0n')).toBe('/share/Ab3dEf7hIj9kLm0n');
+    expect(appPathForUrl('https://www.debateowl.com/share/Ab3dEf7hIj9kLm0n/')).toBe('/share/Ab3dEf7hIj9kLm0n');
+    expect(appPathForUrl('HTTPS://DebateOwl.com/share/abc?lang=hu#top')).toBe('/share/abc');
+  });
+
+  it('maps the website app pages to app routes', () => {
+    expect(appPathForUrl('https://debateowl.com/app')).toBe('/');
+    expect(appPathForUrl('https://debateowl.com/app/')).toBe('/');
+    expect(appPathForUrl('https://debateowl.com/app/debate')).toBe('/');
+    expect(appPathForUrl('https://debateowl.com/app/generate')).toBe('/generate');
+    expect(appPathForUrl('https://debateowl.com/app/Library/')).toBe('/library');
+    expect(appPathForUrl('https://debateowl.com/app/settings?checkout=success')).toBe('/you');
+    expect(appPathForUrl('https://debateowl.com/app/billing')).toBe('/you');
+    expect(appPathForUrl('https://debateowl.com/app/history?tab=cases')).toBe('/history');
+  });
+
+  it('opens the Debate tab for app pages the app does not have', () => {
+    expect(appPathForUrl('https://debateowl.com/app/admin')).toBe('/');
+    expect(appPathForUrl('https://debateowl.com/app/workspaces/123')).toBe('/');
+    expect(appPathForUrl('https://debateowl.com/app/constructor')).toBe('/');
+    expect(appPathForUrl('https://debateowl.com/app/__proto__')).toBe('/');
+    expect(appPathForUrl('https://debateowl.com/app/%67enerate')).toBe('/');
+  });
+
+  it('honours only https on debateowl.com and www', () => {
+    expect(appPathForUrl('http://debateowl.com/share/abc')).toBeNull();
+    expect(appPathForUrl('https://evil.com/share/abc')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com.evil.com/share/abc')).toBeNull();
+    expect(appPathForUrl('https://evil.debateowl.com/share/abc')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com@evil.com/share/abc')).toBeNull();
+    expect(appPathForUrl('https://user@debateowl.com/share/abc')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com:8443/share/abc')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com./share/abc')).toBeNull();
+    expect(appPathForUrl('https:/debateowl.com/share/abc')).toBeNull();
+    expect(appPathForUrl('//debateowl.com/share/abc')).toBeNull();
+    expect(appPathForUrl('debatelab://share/abc')).toBeNull();
+  });
+
+  it('rejects script and odd inputs', () => {
+    expect(appPathForUrl('javascript:alert(1)//debateowl.com/share/abc')).toBeNull();
+    expect(appPathForUrl(' https://debateowl.com/share/abc')).toBeNull();
+    expect(appPathForUrl('')).toBeNull();
+    expect(appPathForUrl(null)).toBeNull();
+    expect(appPathForUrl(42)).toBeNull();
+    expect(appPathForUrl(`https://debateowl.com/app/${'a'.repeat(3000)}`)).toBeNull();
+  });
+
+  it('rejects share links without exactly one valid code', () => {
+    expect(appPathForUrl('https://debateowl.com/share')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com/share/')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com/share/abc/extra')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com/share//abc')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com/share/ab%2Fcd')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com/share/..')).toBeNull();
+    expect(appPathForUrl(`https://debateowl.com/share/${'a'.repeat(65)}`)).toBeNull();
+    expect(appPathForUrl(`https://debateowl.com/share/${'a'.repeat(64)}`)).toBe(`/share/${'a'.repeat(64)}`);
+  });
+
+  it('ignores other website pages', () => {
+    expect(appPathForUrl('https://debateowl.com/')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com/privacy')).toBeNull();
+    expect(appPathForUrl('https://debateowl.com/application')).toBeNull();
+  });
+});
+
+describe('isShareCode', () => {
+  it('accepts the codes the share function makes and nothing looser', () => {
+    expect(isShareCode('Ab3dEf7hIj9kLm0n')).toBe(true);
+    expect(isShareCode('')).toBe(false);
+    expect(isShareCode('a b')).toBe(false);
+    expect(isShareCode('abc/../x')).toBe(false);
+    expect(isShareCode(['abc'])).toBe(false);
+    expect(isShareCode(undefined)).toBe(false);
+  });
+});
diff --git a/apps/mobile/src/lib/deep-links.ts b/apps/mobile/src/lib/deep-links.ts
new file mode 100644
index 000000000..c23ba49aa
--- /dev/null
+++ b/apps/mobile/src/lib/deep-links.ts
@@ -0,0 +1,68 @@
+/**
+ * Website links that open in the app (universal links): https://debateowl.com/share/<code>
+ * and https://debateowl.com/app/<page>, also on www. Anything else, including http,
+ * other hosts, a user name or port in the address, or an encoded segment, is not
+ * ours. This file has no React Native or Expo imports, so it is unit-tested in Node,
+ * and it parses by hand instead of with `URL`, which React Native only polyfills once
+ * the Supabase client loads.
+ */
+
+const HOSTS = new Set(['debateowl.com', 'www.debateowl.com']);
+/** The share function makes 16 letters and digits; older or future codes get some room, never unbounded. */
+const SHARE_CODE = /^[A-Za-z0-9_-]{1,64}$/;
+const MAX_URL_LENGTH = 2048;
+
+/** The website's /app pages (src/App.tsx) and the app route each opens. Missing pages open the Debate tab. */
+const APP_PAGES: Record<string, string> = {
+  '': '/',
+  debate: '/',
+  generate: '/generate',
+  attack: '/attack',
+  brainstorm: '/brainstorm',
+  factoids: '/factoids',
+  ask: '/ask',
+  crossfire: '/crossfire',
+  sparring: '/sparring',
+  flowchart: '/flowchart',
+  timer: '/timer',
+  library: '/library',
+  history: '/history',
+  settings: '/you',
+  billing: '/you',
+};
+
+/** A share code as the share screen accepts it, from a universal link or the app's own scheme. */
+export function isShareCode(code: unknown): code is string {
+  return typeof code === 'string' && SHARE_CODE.test(code);
+}
+
+/**
+ * The app route for a website link, or null when the link is not one of ours.
+ * Query and fragment (such as ?lang=) are dropped.
+ */
+export function appPathForUrl(url: unknown): string | null {
+  if (typeof url !== 'string' || url.length > MAX_URL_LENGTH) return null;
+  const match = /^https:\/\/([^/?#]*)([^?#]*)/i.exec(url);
+  if (!match) return null;
+  const [, authority, rawPath] = match;
+  // No user info, port or trailing dot: only the two exact host names.
+  if (!HOSTS.has(authority.toLowerCase())) return null;
+
+  // One trailing slash is the same page; empty segments elsewhere are not a website route.
+  const path = rawPath.length > 1 && rawPath.endsWith('/') ? rawPath.slice(0, -1) : rawPath;
+  const segments = path === '' || path === '/' ? [] : path.slice(1).split('/');
+  if (segments.some((segment) => segment === '')) return null;
+
+  const [first, ...rest] = segments;
+  if (first?.toLowerCase() === 'share') {
+    const [code] = rest;
+    return rest.length === 1 && isShareCode(code) ? `/share/${code}` : null;
+  }
+  if (first?.toLowerCase() === 'app') {
+    // Every website /app page has one segment at most, with no ids; anything deeper opens the Debate tab.
+    if (rest.length > 1) return '/';
+    const page = (rest[0] ?? '').toLowerCase();
+    return Object.prototype.hasOwnProperty.call(APP_PAGES, page) ? APP_PAGES[page] : '/';
+  }
+  return null;
+}
diff --git a/apps/mobile/src/lib/export-docx-content.ts b/apps/mobile/src/lib/export-docx-content.ts
new file mode 100644
index 000000000..3113582d6
--- /dev/null
+++ b/apps/mobile/src/lib/export-docx-content.ts
@@ -0,0 +1,60 @@
+import type { AttackOutput } from '@debatelab/core/ai/schemas/attack';
+import type { BrainstormOutput } from '@debatelab/core/ai/schemas/brainstorm';
+import type { FactoidsOutput } from '@debatelab/core/ai/schemas/factoids';
+import type { GenerateOutput } from '@debatelab/core/ai/schemas/generate';
+import {
+  buildAttackDocx,
+  buildBrainstormDocx,
+  buildCaseDocx,
+  buildFactoidsDocx,
+  type BuiltDocx,
+  type DocxContext,
+  type DocxModule,
+} from '@debatelab/core/export/docx';
+import { isAppLanguage, toIntlLocale } from '@debatelab/core/languages';
+
+import i18n from './i18n';
+
+/**
+ * The Word documents the website downloads, built by the shared builders in
+ * @debatelab/core. export-docx.ts shares them; export-docx.web.ts keeps them
+ * for the screenshot preview. Both take one of these builds.
+ */
+export type DocxBuild = (docx: DocxModule) => BuiltDocx;
+
+type Translate = DocxContext['t'];
+
+// The website's formatEuropeanDate and formatEuropeanDateTime ("27 Oct 2026",
+// "27 Oct 2026, 14:30"), so the file reads the same on both. dates.ts keeps
+// the app's numeric day format for screens.
+function dateFormat(withTime: boolean): Intl.DateTimeFormat {
+  const language = isAppLanguage(i18n.resolvedLanguage) ? i18n.resolvedLanguage : 'en';
+  return new Intl.DateTimeFormat(toIntlLocale(language), {
+    day: 'numeric',
+    month: 'short',
+    year: 'numeric',
+    ...(withTime ? { hour: '2-digit', minute: '2-digit', hour12: false } : {}),
+  });
+}
+
+function docxContext(t: Translate): DocxContext {
+  const format = (date: Date, withTime: boolean) =>
+    Number.isNaN(date.getTime()) ? t('common.notAvailable') : dateFormat(withTime).format(date);
+  return {
+    t,
+    formatDate: (date) => format(date, false),
+    formatDateTime: (date) => format(date, true),
+  };
+}
+
+export const caseDocx = (result: GenerateOutput, t: Translate): DocxBuild =>
+  (docx) => buildCaseDocx(docx, result, docxContext(t));
+
+export const attackDocx = (result: AttackOutput, t: Translate): DocxBuild =>
+  (docx) => buildAttackDocx(docx, result, docxContext(t));
+
+export const brainstormDocx = (result: BrainstormOutput, t: Translate): DocxBuild =>
+  (docx) => buildBrainstormDocx(docx, result, docxContext(t));
+
+export const factoidsDocx = (result: FactoidsOutput, t: Translate): DocxBuild =>
+  (docx) => buildFactoidsDocx(docx, result, docxContext(t));
diff --git a/apps/mobile/src/lib/export-docx.ts b/apps/mobile/src/lib/export-docx.ts
new file mode 100644
index 000000000..6c4924c01
--- /dev/null
+++ b/apps/mobile/src/lib/export-docx.ts
@@ -0,0 +1,44 @@
+import type { AttackOutput } from '@debatelab/core/ai/schemas/attack';
+import type { BrainstormOutput } from '@debatelab/core/ai/schemas/brainstorm';
+import type { FactoidsOutput } from '@debatelab/core/ai/schemas/factoids';
+import type { GenerateOutput } from '@debatelab/core/ai/schemas/generate';
+import { File, Paths } from 'expo-file-system';
+import * as Sharing from 'expo-sharing';
+
+import { attackDocx, brainstormDocx, caseDocx, factoidsDocx, type DocxBuild } from './export-docx-content';
+
+type Translate = (key: string, options?: Record<string, unknown>) => string;
+
+const DOCX_MIME = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+const DOCX_UTI = 'org.openxmlformats.wordprocessingml.document';
+
+/**
+ * The website's Word document on the phone: `docx` (loaded only when asked
+ * for, it is large) packs it to base64, which is written to the cache under
+ * the website's file name and handed to the share sheet.
+ */
+export async function shareDocx(build: DocxBuild, dialogTitle: string): Promise<void> {
+  const docx = await import('docx');
+  const { doc, fileName } = build(docx);
+  const base64 = await docx.Packer.toBase64String(doc);
+  const target = new File(Paths.cache, fileName);
+  target.create({ overwrite: true });
+  target.write(base64, { encoding: 'base64' });
+  await Sharing.shareAsync(target.uri, { mimeType: DOCX_MIME, UTI: DOCX_UTI, dialogTitle });
+}
+
+export function shareCaseDocx(result: GenerateOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(caseDocx(result, t), dialogTitle);
+}
+
+export function shareAttackDocx(result: AttackOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(attackDocx(result, t), dialogTitle);
+}
+
+export function shareBrainstormDocx(result: BrainstormOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(brainstormDocx(result, t), dialogTitle);
+}
+
+export function shareFactoidsDocx(result: FactoidsOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(factoidsDocx(result, t), dialogTitle);
+}
diff --git a/apps/mobile/src/lib/export-docx.web.ts b/apps/mobile/src/lib/export-docx.web.ts
new file mode 100644
index 000000000..506eec0f1
--- /dev/null
+++ b/apps/mobile/src/lib/export-docx.web.ts
@@ -0,0 +1,40 @@
+import type { AttackOutput } from '@debatelab/core/ai/schemas/attack';
+import type { BrainstormOutput } from '@debatelab/core/ai/schemas/brainstorm';
+import type { FactoidsOutput } from '@debatelab/core/ai/schemas/factoids';
+import type { GenerateOutput } from '@debatelab/core/ai/schemas/generate';
+
+import { attackDocx, brainstormDocx, caseDocx, factoidsDocx, type DocxBuild } from './export-docx-content';
+
+type Translate = (key: string, options?: Record<string, unknown>) => string;
+
+/**
+ * The web preview has no share sheet or file system. It builds the same Word
+ * document and keeps its name and base64 on window, so the screenshot script
+ * can check it.
+ */
+type ExportProbe = { __debatelabExport?: { docx?: { fileName: string; base64: string } } };
+
+export async function shareDocx(build: DocxBuild, _dialogTitle: string): Promise<void> {
+  const docx = await import('docx');
+  const { doc, fileName } = build(docx);
+  const base64 = await docx.Packer.toBase64String(doc);
+  const target = window as unknown as ExportProbe;
+  target.__debatelabExport ??= {};
+  target.__debatelabExport.docx = { fileName, base64 };
+}
+
+export function shareCaseDocx(result: GenerateOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(caseDocx(result, t), dialogTitle);
+}
+
+export function shareAttackDocx(result: AttackOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(attackDocx(result, t), dialogTitle);
+}
+
+export function shareBrainstormDocx(result: BrainstormOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(brainstormDocx(result, t), dialogTitle);
+}
+
+export function shareFactoidsDocx(result: FactoidsOutput, t: Translate, dialogTitle: string): Promise<void> {
+  return shareDocx(factoidsDocx(result, t), dialogTitle);
+}
diff --git a/apps/mobile/src/lib/export-html.ts b/apps/mobile/src/lib/export-html.ts
index 92a36dd74..8f0b97415 100644
--- a/apps/mobile/src/lib/export-html.ts
+++ b/apps/mobile/src/lib/export-html.ts
@@ -1,3 +1,4 @@
+import { readCase, sourceLine } from '@debatelab/core/ai/case-view';
 import type { AttackOutput } from '@debatelab/core/ai/schemas/attack';
 import type { BrainstormOutput } from '@debatelab/core/ai/schemas/brainstorm';
 import type { FactoidsOutput } from '@debatelab/core/ai/schemas/factoids';
@@ -37,6 +38,8 @@ const STYLE = `
   li { margin-bottom: 3px; }
   .tag { display: inline-block; border: 1px solid #CDD7E4; border-radius: 6px; padding: 0 6px; font-size: 9pt; font-weight: 700; margin-right: 4px; }
   .critical { color: #D23239; border-color: #D23239; }
+  .hook { font-style: italic; }
+  .closing { font-weight: 600; }
   .major { color: #A15C06; border-color: #A15C06; }
   .minor { color: #0556D6; border-color: #0556D6; }
   footer { margin-top: 26px; color: #8494AB; font-size: 9pt; text-align: center; }
@@ -64,35 +67,52 @@ export function caseExportHtml(result: GenerateOutput, t: Translate): string {
   const title = result.metadata?.motion || t('export.debateCase');
   const parts: string[] = [];
 
-  parts.push(`<div class="framing"><p><span class="label">${escape(t('export.thesis'))}:</span> ${escape(result.caseStructure?.thesis || t('export.noThesis'))}</p>${
-    result.caseStructure?.framework ? `<p><span class="label">${escape(t('export.framework'))}:</span> ${escape(result.caseStructure.framework)}</p>` : ''
-  }</div>`);
-  if (result.exordio && (result.exordio.hook || result.exordio.transition)) {
-    parts.push(`<h2>${escape(t('export.exordio'))}</h2>`);
-    if (result.exordio.hook) parts.push(paragraph(t('export.hook'), result.exordio.hook));
-    if (result.exordio.transition) parts.push(paragraph(t('export.transition'), result.exordio.transition));
+  const view = readCase(result);
+  const label = (key: string) => escape(t(key));
+
+  // Opening: hook, an unclear term when there is one, and the roadmap; older cases add their framework, burden and definitions.
+  parts.push(`<h2>${label('export.opening')}</h2>`);
+  if (view.opening.hook) parts.push(`<p class="hook">${escape(view.opening.hook)}</p>`);
+  if (view.opening.definition) parts.push(paragraph(t('export.definition'), view.opening.definition));
+  parts.push(paragraph(t('export.roadmap'), view.opening.roadmap || t('export.untitledCase')));
+  if (view.legacy.framework) parts.push(paragraph(t('export.legacyJudgeBy'), view.legacy.framework));
+  if (view.legacy.burdenOfProof) parts.push(paragraph(t('export.legacyMustShow'), view.legacy.burdenOfProof));
+  if (view.legacy.definitions.length) parts.push(`<h3>${label('export.legacyDefinitions')}</h3>${bullets(view.legacy.definitions)}`);
+
+  if (view.arguments.length) {
+    parts.push(`<h2>${label('export.arguments')}</h2>`);
+    view.arguments.forEach((argument, i) => {
+      parts.push(`<div class="block"><h3><span class="number">${escape(t('export.argumentNumber', { number: i + 1 }))}</span>${escape(argument.title ?? argument.point)}</h3>${
+        argument.title && argument.point ? paragraph(t('export.point'), argument.point) : ''
+      }${argument.explanation ? paragraph(t('export.explanation'), argument.explanation) : ''}${
+        argument.evidence ? paragraph(t('export.evidence'), argument.evidence) : ''
+      }${argument.whyItMatters ? paragraph(t('export.whyItMatters'), argument.whyItMatters) : ''}</div>`);
+    });
   }
-  if (result.caseStructure?.burdenOfProof) parts.push(paragraph(t('export.burdenOfProof'), result.caseStructure.burdenOfProof));
-  if (result.caseStructure?.keyDefinitions?.length) parts.push(`<h3>${escape(t('export.keyDefinitions'))}</h3>${bullets(result.caseStructure.keyDefinitions)}`);
-
-  parts.push(`<h2>${escape(t('export.arguments'))}</h2>`);
-  if (!result.contentions?.length) parts.push(`<p>${escape(t('export.noArguments'))}</p>`);
-  result.contentions?.forEach((c, i) => {
-    parts.push(`<div class="block"><h3><span class="number">${escape(t('export.contentionNumber', { number: i + 1 }))}</span>${escape(c.claim)}</h3>${
-      c.reasoning ? paragraph(t('export.reasoning'), c.reasoning) : ''
-    }${c.evidence ? paragraph(t('export.evidence'), c.evidence) : ''}${c.impact ? paragraph(t('export.impact'), c.impact) : ''}</div>`);
-  });
 
-  parts.push(`<h2>${escape(t('export.predictedOpponent'))}</h2>`);
-  parts.push(result.predictedOpponentCase?.likelyArguments?.length ? bullets(result.predictedOpponentCase.likelyArguments) : `<p>${escape(t('export.noOpponentArgs'))}</p>`);
+  // R2: the team's earlier arguments, backed up, instead of new ones.
+  if (view.reinforce.length) {
+    parts.push(`<h2>${label('export.reinforce')}</h2>`);
+    view.reinforce.forEach((item) => parts.push(`<div class="block">${item.argument ? `<h3>${escape(item.argument)}</h3>` : ''}<p>${escape(item.text)}</p></div>`));
+  }
 
-  parts.push(`<h2>${escape(t('export.counters'))}</h2>`);
-  if (!result.counters?.length) parts.push(`<p>${escape(t('export.noCounters'))}</p>`);
-  result.counters?.forEach((c) => {
-    parts.push(`<div class="block"><h3>${escape(t('export.target'))}: ${escape(c.targetArgument)}</h3>${
-      c.counterpoint ? paragraph(t('export.counter'), c.counterpoint) : ''
-    }${c.rebuttal ? paragraph(t('export.rebuttal'), c.rebuttal) : ''}</div>`);
-  });
+  // Conclusor: the reasons we win replace new arguments.
+  if (view.whyWeWin.length) {
+    parts.push(`<h2>${label('export.whyWeWin')}</h2><ol>${view.whyWeWin.map((reason) => `<li>${escape(reason)}</li>`).join('')}</ol>`);
+  }
+
+  if (view.ifTheySay.length || view.legacy.likelyArguments.length) {
+    parts.push(`<h2>${label('export.ifTheySay')}</h2>`);
+    view.ifTheySay.forEach((answer) => {
+      parts.push(`<div class="block"><h3>${label('export.theySay')}: ${escape(answer.theySay)}</h3>${
+        answer.weAnswer ? paragraph(t('export.weAnswer'), answer.weAnswer) : ''
+      }${answer.inRound ? paragraph(t('export.legacySayItLike'), answer.inRound) : ''}${answer.source ? paragraph(t('export.source'), answer.source) : ''}</div>`);
+    });
+    if (view.legacy.likelyArguments.length) parts.push(`<h3>${label('export.legacyAlsoSay')}</h3>${bullets(view.legacy.likelyArguments)}`);
+  }
+
+  if (view.closingLine) parts.push(`<h2>${label('export.closingLine')}</h2><p class="closing">${escape(view.closingLine)}</p>`);
+  if (view.sources.length) parts.push(`<h2>${label('export.sources')}</h2>${bullets(view.sources.map(sourceLine))}`);
 
   return page(title, `${side} • ${format} ${t('export.format')}`, parts.join(''), t);
 }
diff --git a/apps/mobile/src/lib/export.ts b/apps/mobile/src/lib/export.ts
index fb901f9d7..a87827cc5 100644
--- a/apps/mobile/src/lib/export.ts
+++ b/apps/mobile/src/lib/export.ts
@@ -2,7 +2,7 @@ import * as Clipboard from 'expo-clipboard';
 import { File, Paths } from 'expo-file-system';
 import * as Print from 'expo-print';
 import * as Sharing from 'expo-sharing';
-import { Share } from 'react-native';
+import { Platform, Share } from 'react-native';
 
 /**
  * Export on the phone: expo-print renders the document's HTML to a PDF,
@@ -32,3 +32,8 @@ export async function copyText(text: string): Promise<void> {
 export async function shareText(title: string, text: string): Promise<void> {
   await Share.share({ title, message: text });
 }
+
+/** A link through the iOS share sheet, which has its own Copy. Rejects only when the sheet cannot open. */
+export async function shareUrl(title: string, url: string): Promise<void> {
+  await Share.share(Platform.OS === 'ios' ? { title, url } : { title, message: url });
+}
diff --git a/apps/mobile/src/lib/export.web.ts b/apps/mobile/src/lib/export.web.ts
index 852277d0d..4c179b7c5 100644
--- a/apps/mobile/src/lib/export.web.ts
+++ b/apps/mobile/src/lib/export.web.ts
@@ -5,7 +5,7 @@ import * as Clipboard from 'expo-clipboard';
  * exist there. It keeps the HTML it would print and the text it copied on
  * window, so the screenshot script can show and check them.
  */
-type ExportProbe = { __debatelabExport?: { html?: string; fileName?: string; copied?: string; shared?: string; json?: string } };
+type ExportProbe = { __debatelabExport?: { html?: string; fileName?: string; copied?: string; shared?: string; sharedUrl?: string; json?: string } };
 
 function probe() {
   const target = window as unknown as ExportProbe;
@@ -32,3 +32,8 @@ export function shareText(_title: string, text: string): Promise<void> {
   probe().shared = text;
   return Promise.resolve();
 }
+
+export function shareUrl(_title: string, url: string): Promise<void> {
+  probe().sharedUrl = url;
+  return Promise.resolve();
+}
diff --git a/apps/mobile/src/lib/first-run.ts b/apps/mobile/src/lib/first-run.ts
new file mode 100644
index 000000000..e2867ed01
--- /dev/null
+++ b/apps/mobile/src/lib/first-run.ts
@@ -0,0 +1,43 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+// The website's keys (src/lib/debateowl-intro.ts, src/hooks/use-onboarding.ts):
+// the welcome opens once per device, the tour once per account on the device.
+const INTRO_SEEN_KEY = 'debateowl_intro_seen_v1';
+const TOUR_DONE_KEY = 'debateowl.tour.completedUserIds';
+
+export interface FirstRunPlan {
+  showIntro: boolean;
+  tourDone: boolean;
+}
+
+async function tourDoneIds(): Promise<string[]> {
+  const value: unknown = JSON.parse((await AsyncStorage.getItem(TOUR_DONE_KEY)) ?? '[]');
+  return Array.isArray(value) ? value.filter((id): id is string => typeof id === 'string') : [];
+}
+
+/**
+ * What the first run shows for this account on this phone. Storage that cannot
+ * be read keeps both closed, as on the website: a flag that cannot be saved
+ * would reopen them on every launch.
+ */
+export async function firstRunPlan(userId: string): Promise<FirstRunPlan> {
+  try {
+    const [intro, done] = await Promise.all([AsyncStorage.getItem(INTRO_SEEN_KEY), tourDoneIds()]);
+    return { showIntro: intro === null, tourDone: done.includes(userId) };
+  } catch {
+    return { showIntro: false, tourDone: true };
+  }
+}
+
+export async function markIntroSeen(now = new Date()): Promise<void> {
+  await AsyncStorage.setItem(INTRO_SEEN_KEY, now.toISOString()).catch(() => undefined);
+}
+
+export async function markTourDone(userId: string): Promise<void> {
+  try {
+    const done = await tourDoneIds();
+    if (!done.includes(userId)) await AsyncStorage.setItem(TOUR_DONE_KEY, JSON.stringify([...done, userId]));
+  } catch {
+    // Not saved: the tour opens once more on the next launch.
+  }
+}
diff --git a/apps/mobile/src/lib/first-run.web.ts b/apps/mobile/src/lib/first-run.web.ts
new file mode 100644
index 000000000..d99a65372
--- /dev/null
+++ b/apps/mobile/src/lib/first-run.web.ts
@@ -0,0 +1,16 @@
+// The web preview exists for screenshots, so the first run opens only when the
+// URL asks, as the website's ?intro=show does: `?intro=show` opens the welcome
+// and then the tour, `?intro=tour` the tour alone.
+export interface FirstRunPlan {
+  showIntro: boolean;
+  tourDone: boolean;
+}
+
+export async function firstRunPlan(_userId: string): Promise<FirstRunPlan> {
+  const requested = new URLSearchParams(window.location.search).get('intro');
+  return { showIntro: requested === 'show', tourDone: requested !== 'show' && requested !== 'tour' };
+}
+
+export async function markIntroSeen(): Promise<void> {}
+
+export async function markTourDone(_userId: string): Promise<void> {}
diff --git a/apps/mobile/src/lib/key-commands.ts b/apps/mobile/src/lib/key-commands.ts
new file mode 100644
index 000000000..56768c26f
--- /dev/null
+++ b/apps/mobile/src/lib/key-commands.ts
@@ -0,0 +1,10 @@
+/**
+ * iPad hardware-keyboard shortcuts (⌘N, ⌘K, ⌘↩) need UIKeyCommand, which
+ * neither React Native nor Expo Go exposes. Until the development build
+ * carries a key-command module, the native app registers nothing and the
+ * shortcuts work in the web preview only (key-commands.web.ts).
+ * TODO(key-commands): wire a dev-build module here behind nativeCapabilities().
+ */
+export type KeyCombo = 'cmd+n' | 'cmd+k' | 'cmd+enter';
+
+export function useKeyCommand(_combo: KeyCombo, _handler: () => void, _enabled = true): void {}
diff --git a/apps/mobile/src/lib/key-commands.web.ts b/apps/mobile/src/lib/key-commands.web.ts
new file mode 100644
index 000000000..2413b1e78
--- /dev/null
+++ b/apps/mobile/src/lib/key-commands.web.ts
@@ -0,0 +1,25 @@
+import { useEffect, useRef } from 'react';
+
+export type KeyCombo = 'cmd+n' | 'cmd+k' | 'cmd+enter';
+
+function matches(event: KeyboardEvent, combo: KeyCombo): boolean {
+  if (!(event.metaKey || event.ctrlKey) || event.altKey || event.shiftKey) return false;
+  if (combo === 'cmd+enter') return event.key === 'Enter';
+  return event.key.toLowerCase() === combo.slice(-1);
+}
+
+/** The iPad's ⌘ shortcuts in the web preview, from the same hook the native app calls (key-commands.ts). */
+export function useKeyCommand(combo: KeyCombo, handler: () => void, enabled = true): void {
+  const latest = useRef(handler);
+  latest.current = handler;
+  useEffect(() => {
+    if (!enabled) return;
+    const onKey = (event: KeyboardEvent) => {
+      if (!matches(event, combo)) return;
+      event.preventDefault();
+      latest.current();
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [combo, enabled]);
+}
diff --git a/apps/mobile/src/lib/layout.test.ts b/apps/mobile/src/lib/layout.test.ts
index 889f51de8..ccd770124 100644
--- a/apps/mobile/src/lib/layout.test.ts
+++ b/apps/mobile/src/lib/layout.test.ts
@@ -4,13 +4,14 @@ const platform = vi.hoisted(() => ({ OS: 'ios' as string, isPad: false }));
 
 vi.mock('react-native', () => ({
   Platform: platform,
+  Dimensions: { get: () => ({ width: 0, height: 0, scale: 1, fontScale: 1 }) },
   useWindowDimensions: () => ({ width: 0, height: 0, scale: 1, fontScale: 1 }),
 }));
 vi.mock('react-native-safe-area-context', () => ({
   useSafeAreaInsets: () => ({ top: 0, right: 0, bottom: 0, left: 0 }),
 }));
 
-import { layoutClassFor } from './layout';
+import { SIDEBAR_WIDTH, layoutClassFor, sidebarWidthFor } from './layout';
 
 describe('layoutClassFor', () => {
   beforeEach(() => {
@@ -44,3 +45,30 @@ describe('layoutClassFor', () => {
     expect(layoutClassFor(1366, false)).toBe('wide');
   });
 });
+
+describe('sidebarWidthFor', () => {
+  beforeEach(() => {
+    platform.OS = 'ios';
+    platform.isPad = true;
+  });
+
+  it('shows the sidebar in a full-screen iPad window from the regular width', () => {
+    expect(sidebarWidthFor({ width: 820, fontScale: 1 }, true, 820)).toBe(SIDEBAR_WIDTH.regular);
+    expect(sidebarWidthFor({ width: 1180, fontScale: 1 }, true, 1180)).toBe(SIDEBAR_WIDTH.wide);
+  });
+
+  it('keeps the tab bar in Split View, Slide Over and Stage Manager windows, however wide', () => {
+    expect(sidebarWidthFor({ width: 980, fontScale: 1 }, true, 1366)).toBe(0);
+    expect(sidebarWidthFor({ width: 507, fontScale: 1 }, true, 1180)).toBe(0);
+  });
+
+  it('keeps the tab bar on iPhone and in a narrow iPad window', () => {
+    expect(sidebarWidthFor({ width: 932, fontScale: 1 }, false, 932)).toBe(0);
+    expect(sidebarWidthFor({ width: 690, fontScale: 1 }, true, 690)).toBe(0);
+  });
+
+  it('grows with Dynamic Type up to its cap', () => {
+    expect(sidebarWidthFor({ width: 820, fontScale: 1.2 }, true, 820)).toBe(Math.round(SIDEBAR_WIDTH.regular * 1.2));
+    expect(sidebarWidthFor({ width: 820, fontScale: 3.1 }, true, 820)).toBe(Math.round(SIDEBAR_WIDTH.regular * 1.35));
+  });
+});
diff --git a/apps/mobile/src/lib/layout.ts b/apps/mobile/src/lib/layout.ts
index c4c7007f8..51959232c 100644
--- a/apps/mobile/src/lib/layout.ts
+++ b/apps/mobile/src/lib/layout.ts
@@ -1,4 +1,5 @@
-import { Platform, useWindowDimensions } from 'react-native';
+import { createContext, useContext } from 'react';
+import { Dimensions, Platform, useWindowDimensions } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
 /**
@@ -23,8 +24,14 @@ export const LIST_WIDTH = { library: 340, libraryRoomy: 380, ask: 320 } as const
 /** The Library list widens once the window has this much room. */
 export const LIBRARY_ROOMY_WIDTH = 960;
 
-/** The sidebar the web preview draws in the wide layout; iPadOS draws its own. */
-export const SIDEBAR_WIDTH = 300;
+/**
+ * The app's own iPad sidebar (components/app-sidebar.tsx), which lists every
+ * tool. It shows in a full-screen iPad window from the regular width; Split
+ * View, Slide Over and narrower windows keep the tab bar.
+ */
+export const SIDEBAR_WIDTH = { regular: 260, wide: 300 } as const;
+/** The sidebar is fixed chrome: it grows with Dynamic Type up to this much. */
+export const SIDEBAR_MAX_FONT_SCALE = 1.35;
 
 /** The Debate home splits into two columns from this content width. */
 export const HOME_COLUMNS_WIDTH = 760;
@@ -42,10 +49,43 @@ export function layoutClassFor(width: number, isPad: boolean): LayoutClass {
   return 'phone';
 }
 
-/** The layout class for the current window; it changes with rotation and Split View. */
-export function useLayoutClass(): LayoutClass {
+/**
+ * The sidebar's width for a window, or 0 when the window keeps the tab bar.
+ * On iPad the window must fill the screen: in Split View, Slide Over or a
+ * Stage Manager window the system's width class is compact or the room is
+ * shared, so the tab bar stays. The web preview has no Split View.
+ */
+export function sidebarWidthFor(window: { width: number; fontScale: number }, isPad: boolean, screenWidth: number): number {
+  if (Platform.OS === 'ios' && (!isPad || window.width < screenWidth - 1)) return 0;
+  if (Platform.OS !== 'ios' && Platform.OS !== 'web') return 0;
+  const layout = layoutClassFor(window.width, isPad);
+  if (layout === 'phone') return 0;
+  const scale = Math.min(Math.max(window.fontScale, 1), SIDEBAR_MAX_FONT_SCALE);
+  return Math.round(SIDEBAR_WIDTH[layout] * scale);
+}
+
+/** The width the sidebar takes from the window right now; 0 when it is hidden. */
+export function useSidebarWidth(): number {
+  const window = useWindowDimensions();
+  return sidebarWidthFor(window, Platform.OS === 'ios' && Platform.isPad, Dimensions.get('screen').width);
+}
+
+/**
+ * How much of the window's width the root layout gives to the sidebar.
+ * Screens beside it lay out for the rest; sheets and full-screen modals, which
+ * cover the sidebar, provide 0 again.
+ */
+export const ReservedWidth = createContext(0);
+
+/** The width a screen lays out in: the window, less the sidebar beside it. */
+export function useContentWidth(): number {
   const { width } = useWindowDimensions();
-  return layoutClassFor(width, Platform.OS === 'ios' && Platform.isPad);
+  return width - useContext(ReservedWidth);
+}
+
+/** The layout class for the room a screen has; it changes with rotation, Split View and the sidebar. */
+export function useLayoutClass(): LayoutClass {
+  return layoutClassFor(useContentWidth(), Platform.OS === 'ios' && Platform.isPad);
 }
 
 /** The height of iOS's navigation bar under the status bar. */
diff --git a/apps/mobile/src/lib/native-capabilities.test.ts b/apps/mobile/src/lib/native-capabilities.test.ts
index 5e9d1432c..41f42bb8a 100644
--- a/apps/mobile/src/lib/native-capabilities.test.ts
+++ b/apps/mobile/src/lib/native-capabilities.test.ts
@@ -26,26 +26,55 @@ describe('nativeCapabilities', () => {
   it('reports nothing in Expo Go and never looks a native module up', () => {
     env.executionEnvironment = 'storeClient';
     // Even if a lookup would succeed, Expo Go must not be asked.
-    env.modules = { ExpoSpeechRecognition: {}, ExpoWidgets: { widgetsDirectory: 'file:///group/ExpoWidgets/' } };
-    expect(nativeCapabilities()).toEqual({ speechRecognition: false, liveActivity: false });
+    env.modules = {
+      ExpoSpeechRecognition: {},
+      ExpoWidgets: { widgetsDirectory: 'file:///group/ExpoWidgets/' },
+      ExpoQuickActions: {},
+      ExpoCoreSpotlight: {},
+    };
+    expect(nativeCapabilities()).toEqual({ speechRecognition: false, liveActivity: false, widgets: false, quickActions: false, spotlight: false });
     expect(requireOptionalNativeModule).not.toHaveBeenCalled();
   });
 
-  it('reports speech but no Live Activity in a development build without an App Group', () => {
+  it('reports speech but no Live Activity or widget in a development build without an App Group', () => {
     env.executionEnvironment = 'bare';
     env.modules = { ExpoSpeechRecognition: {}, ExpoWidgets: { widgetsDirectory: null } };
-    expect(nativeCapabilities()).toEqual({ speechRecognition: true, liveActivity: false });
+    expect(nativeCapabilities()).toEqual({
+      speechRecognition: true,
+      liveActivity: false,
+      widgets: false,
+      quickActions: false,
+      spotlight: false,
+    });
   });
 
-  it('reports both when the build has the speech module and the App Group container', () => {
+  it('reports the widgets when the build has the App Group container', () => {
     env.executionEnvironment = 'bare';
     env.modules = { ExpoSpeechRecognition: {}, ExpoWidgets: { widgetsDirectory: 'file:///group/ExpoWidgets/' } };
-    expect(nativeCapabilities()).toEqual({ speechRecognition: true, liveActivity: true });
+    expect(nativeCapabilities()).toEqual({
+      speechRecognition: true,
+      liveActivity: true,
+      widgets: true,
+      quickActions: false,
+      spotlight: false,
+    });
+  });
+
+  it('reports quick actions and Spotlight once their modules are linked', () => {
+    env.executionEnvironment = 'bare';
+    env.modules = { ExpoQuickActions: {}, ExpoCoreSpotlight: {} };
+    expect(nativeCapabilities()).toEqual({
+      speechRecognition: false,
+      liveActivity: false,
+      widgets: false,
+      quickActions: true,
+      spotlight: true,
+    });
   });
 
   it('reports nothing where the modules are missing, as in the web preview', () => {
     env.executionEnvironment = 'bare';
     env.modules = {};
-    expect(nativeCapabilities()).toEqual({ speechRecognition: false, liveActivity: false });
+    expect(nativeCapabilities()).toEqual({ speechRecognition: false, liveActivity: false, widgets: false, quickActions: false, spotlight: false });
   });
 });
diff --git a/apps/mobile/src/lib/native-capabilities.ts b/apps/mobile/src/lib/native-capabilities.ts
index b18c92622..6519bee62 100644
--- a/apps/mobile/src/lib/native-capabilities.ts
+++ b/apps/mobile/src/lib/native-capabilities.ts
@@ -4,27 +4,39 @@ import Constants, { ExecutionEnvironment } from 'expo-constants';
 // What the running binary can do beyond Expo Go. Autolinking puts these
 // modules into every native build; DEBATELAB_BUILD=dev in app.config.ts adds
 // what they need to work (the speech prompts, and with an App Group the
-// widget extension). Expo Go never has them, so it is not even asked: no
-// import of a module that is missing, no crash.
+// widget extension). Quick actions and Spotlight need packages that are not
+// installed yet; until they are, their modules are simply missing. Expo Go
+// never has them, so it is not even asked: no import of a module that is
+// missing, no crash.
 
 export type NativeCapabilities = {
   /** expo-speech-recognition is linked. */
   speechRecognition: boolean;
   /** expo-widgets is linked and its App Group container exists, so a Live Activity can start. */
   liveActivity: boolean;
+  /** The same container, so the Current Debate's Home Screen widget can be given its data (src/lib/debate-widget.ts). */
+  widgets: boolean;
+  /** expo-quick-actions is linked, so a Home Screen quick action reaches the app (src/lib/quick-actions.ts). */
+  quickActions: boolean;
+  /** expo-core-spotlight is linked, so debates and saved cases can be indexed (src/lib/spotlight.ts). */
+  spotlight: boolean;
 };
 
 type WidgetsModule = { widgetsDirectory?: string | null };
 
 export function nativeCapabilities(): NativeCapabilities {
   if (Constants.executionEnvironment === ExecutionEnvironment.StoreClient) {
-    return { speechRecognition: false, liveActivity: false };
+    return { speechRecognition: false, liveActivity: false, widgets: false, quickActions: false, spotlight: false };
   }
   // expo-widgets links into every development build, but without the App
   // Group (DEBATELAB_APP_GROUP) it has no extension and no container.
   const widgets = requireOptionalNativeModule<WidgetsModule>('ExpoWidgets');
+  const widgetContainer = !!widgets?.widgetsDirectory;
   return {
     speechRecognition: requireOptionalNativeModule('ExpoSpeechRecognition') != null,
-    liveActivity: !!widgets?.widgetsDirectory,
+    liveActivity: widgetContainer,
+    widgets: widgetContainer,
+    quickActions: requireOptionalNativeModule('ExpoQuickActions') != null,
+    spotlight: requireOptionalNativeModule('ExpoCoreSpotlight') != null,
   };
 }
diff --git a/apps/mobile/src/lib/offline-cache.test.ts b/apps/mobile/src/lib/offline-cache.test.ts
index 1eb1a2a12..9bda6a687 100644
--- a/apps/mobile/src/lib/offline-cache.test.ts
+++ b/apps/mobile/src/lib/offline-cache.test.ts
@@ -312,6 +312,15 @@ describe('after a write', () => {
     await expect(cache.cachedRead('user-a', 'sources', 'debate-2', offlineFailure)).resolves.toEqual([{ id: 'source-2' }]);
   });
 
+  it('tells the offline queue a source write that got no answer from one the server refused', async () => {
+    const cache = await load();
+    cache.setCacheOwner('user-a');
+    supabase.results.push({ data: null, error: { message: 'TypeError: Network request failed' }, status: 0 });
+    await expect(cache.updateSource('user-a', 'debate-1', 'source-1', { title: 'Offline' })).rejects.toMatchObject({ unreachable: true });
+    supabase.results.push({ data: null, error: { message: 'new row violates row-level security policy' }, status: 403 });
+    await expect(cache.setSourcesActive('user-a', 'debate-1', ['source-1'], false)).rejects.toMatchObject({ unreachable: false });
+  });
+
   it('a delete whose row was already gone still drops every list and count that may hold it', async () => {
     const cache = await load();
     cache.setCacheOwner('user-a');
diff --git a/apps/mobile/src/lib/offline-cache.ts b/apps/mobile/src/lib/offline-cache.ts
index 58dd6dea9..c48713d4d 100644
--- a/apps/mobile/src/lib/offline-cache.ts
+++ b/apps/mobile/src/lib/offline-cache.ts
@@ -395,6 +395,11 @@ export function afterWrite(userId: string, scopes: CopyScope[]) {
  * replacement, or undefined to drop it. Reads that started before this call
  * cannot save over it.
  */
+/** Resolves once every copy update asked for so far has run, so a caller can read what they saw. */
+export function copiesWritten(): Promise<void> {
+  return queue(async () => undefined).catch(() => undefined);
+}
+
 export function updateCopy<T>(userId: string, group: CacheGroup, key: string, update: (copy: T | undefined) => T | undefined) {
   const storageKey = entryKey(userId, group, key);
   const gen = generation;
diff --git a/apps/mobile/src/lib/offline-queue.test.ts b/apps/mobile/src/lib/offline-queue.test.ts
new file mode 100644
index 000000000..8be61f453
--- /dev/null
+++ b/apps/mobile/src/lib/offline-queue.test.ts
@@ -0,0 +1,438 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { Source } from './sources';
+
+const storage = vi.hoisted(() => new Map<string, string>());
+const net = vi.hoisted(() => ({ offline: false, user: 'user-a' as string | null, uuids: 0, failGet: 0, failSet: 0, holdSet: null as Promise<void> | null }));
+// supabase-js answers a request that never reached the server with status 0; readFailed marks it unreachable.
+// The saved copies, kept in memory so a test can see what an offline relaunch would show.
+const copies = vi.hoisted(() => new Map<string, unknown>());
+const pending = vi.hoisted(() => ({ chain: Promise.resolve() as Promise<void> }));
+const cache = vi.hoisted(() => ({
+  ReadError: class ReadError extends Error {
+    constructor(message: string, readonly unreachable: boolean) {
+      super(message);
+    }
+  },
+  // Copy updates run later, one at a time, as the real cache's do.
+  updateCopy: (_userId: string, group: string, key: string, update: (copy: unknown) => unknown) => {
+    pending.chain = pending.chain.then(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 2));
+      copies.set(`${group}:${key}`, update(copies.get(`${group}:${key}`)));
+    });
+  },
+  copiesWritten: () => pending.chain,
+}));
+const sources = vi.hoisted(() => ({
+  addSource: vi.fn(),
+  updateSource: vi.fn(),
+  setSourcesActive: vi.fn(),
+  fetchSource: vi.fn(),
+  fetchSources: vi.fn(),
+  notifySourcesChanged: vi.fn(),
+  DuplicateSourceError: class DuplicateSourceError extends Error {},
+}));
+
+vi.mock('@react-native-async-storage/async-storage', () => ({
+  default: {
+    getItem: async (key: string) => {
+      if (net.failGet > 0 && key.includes('user-')) {
+        net.failGet -= 1;
+        throw new Error('storage unavailable');
+      }
+      return storage.get(key) ?? null;
+    },
+    setItem: async (key: string, value: string) => {
+      if (net.holdSet) await net.holdSet;
+      if (net.failSet > 0) {
+        net.failSet -= 1;
+        throw new Error('storage full');
+      }
+      storage.set(key, value);
+    },
+    removeItem: async (key: string) => void storage.delete(key),
+    getAllKeys: async () => [...storage.keys()],
+    multiRemove: async (keys: string[]) => keys.forEach((key) => storage.delete(key)),
+  },
+}));
+vi.mock('expo-crypto', () => ({ randomUUID: () => `uuid-${++net.uuids}` }));
+vi.mock('./network-status', () => ({ isKnownOffline: () => net.offline }));
+vi.mock('./offline-cache', () => cache);
+vi.mock('./sources', () => sources);
+vi.mock('./supabase', () => ({
+  supabase: { auth: { getSession: async () => ({ data: { session: net.user ? { user: { id: net.user } } : null } }) } },
+}));
+
+const noAnswer = () => new cache.ReadError('TypeError: Network request failed', true);
+const refused = () => new cache.ReadError('new row violates row-level security policy', false);
+
+function row(id: string, input: { title: string; content: string; debateId: string }): Source {
+  return { id, title: input.title, content: input.content, type: 'text', origin: null, createdAt: 1, useCount: 0, folder: 'General', isActive: true, debateId: input.debateId, metadata: null };
+}
+
+// A fresh module per test: the owner and the queue are module state, as in the app.
+async function load(owner: string | null = 'user-a') {
+  vi.resetModules();
+  const queue = await import('./offline-queue');
+  if (owner !== undefined) queue.setQueueOwner(owner);
+  return queue;
+}
+
+/** What reached the server, in order. */
+function sent(): string[] {
+  const calls: [number, string][] = [
+    ...sources.addSource.mock.calls.map((call, i) => [sources.addSource.mock.invocationCallOrder[i], `add ${call[1].id} ${call[1].title}`] as [number, string]),
+    ...sources.updateSource.mock.calls.map((call, i) => [sources.updateSource.mock.invocationCallOrder[i], `edit ${call[2]} ${JSON.stringify(call[3])}`] as [number, string]),
+    ...sources.setSourcesActive.mock.calls.map((call, i) => [sources.setSourcesActive.mock.invocationCallOrder[i], `active ${call[2].join(',')} ${call[3]}`] as [number, string]),
+  ];
+  return calls.sort((a, b) => a[0] - b[0]).map(([, call]) => call);
+}
+
+beforeEach(async () => {
+  // Copy updates a previous test started finish before this one begins.
+  await pending.chain;
+  pending.chain = Promise.resolve();
+  storage.clear();
+  copies.clear();
+  net.offline = false;
+  net.user = 'user-a';
+  net.uuids = 0;
+  net.failGet = 0;
+  net.failSet = 0;
+  net.holdSet = null;
+  vi.clearAllMocks();
+  sources.addSource.mockImplementation(async (_userId: string, input: { id: string; title: string; content: string; debateId: string }) => row(input.id, input));
+  sources.updateSource.mockResolvedValue(undefined);
+  sources.setSourcesActive.mockResolvedValue(undefined);
+  sources.fetchSources.mockResolvedValue([]);
+  sources.fetchSource.mockResolvedValue(null);
+});
+
+describe('offline queue', () => {
+  it('keeps writes made offline and sends them in order once the connection is back', async () => {
+    const queue = await load();
+    const reports: unknown[] = [];
+    queue.subscribeQueueReports((report) => reports.push(report));
+    net.offline = true;
+    const note = await queue.queueAddSource('user-a', { title: 'Note', content: 'Text', type: 'text', debateId: 'd1' });
+    await expect(queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Renamed' })).resolves.toBe('queued');
+    await expect(queue.queueSetSourcesActive('user-a', 'd1', ['s2'], false)).resolves.toBe('queued');
+    expect(note.status).toBe('queued');
+    expect(sent()).toEqual([]);
+    expect(queue.waitingCount(queue.getQueueSnapshot())).toBe(3);
+
+    net.offline = false;
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual(['add uuid-1 Note', 'edit s1 {"title":"Renamed"}', 'active s2 false']);
+    expect(queue.getQueueSnapshot().items).toEqual([]);
+    expect(reports).toEqual([{ synced: 3, dropped: [] }]);
+  });
+
+  it('sends only the last switch of a source and one merged edit, without reordering other sources', async () => {
+    const queue = await load();
+    net.offline = true;
+    await queue.queueSetSourcesActive('user-a', 'd1', ['a', 'b'], false);
+    await queue.queueSetSourcesActive('user-a', 'd1', ['c'], false);
+    await queue.queueUpdateSource('user-a', 'd1', 'a', { title: 'First' });
+    await queue.queueSetSourcesActive('user-a', 'd1', ['a'], true);
+    await queue.queueUpdateSource('user-a', 'd1', 'a', { title: 'Second', content: 'Body' });
+    await queue.queueSetSourcesActive('user-a', 'd1', ['c'], true);
+
+    net.offline = false;
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual(['active b false', 'edit a {"title":"Second","content":"Body"}', 'active a true', 'active c true']);
+  });
+
+  it('keeps a write that got no answer, and drops one the server refused with the error to the caller', async () => {
+    const queue = await load();
+    const reports: unknown[] = [];
+    queue.subscribeQueueReports((report) => reports.push(report));
+    sources.updateSource.mockRejectedValueOnce(noAnswer());
+    await expect(queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Kept' })).resolves.toBe('queued');
+    expect(queue.waitingSourceIds(queue.getQueueSnapshot())).toEqual(new Set(['s1']));
+
+    sources.setSourcesActive.mockRejectedValueOnce(refused());
+    // Behind a waiting write, a new one waits too and is reported once a replay drops it.
+    await expect(queue.queueSetSourcesActive('user-a', 'd1', ['s2'], false)).resolves.toBe('queued');
+    await queue.replayOfflineQueue();
+    expect(reports).toEqual([{ synced: 1, dropped: [{ kind: 'active' }] }]);
+    expect(queue.getQueueSnapshot().items).toEqual([]);
+    expect(sources.notifySourcesChanged).toHaveBeenCalled();
+    // The saved copies that showed the refused switch are read back from the server, so a relaunch offline never shows it.
+    expect(sources.fetchSources).toHaveBeenCalledWith('user-a', 'd1');
+    expect(sources.fetchSource).toHaveBeenCalledWith('user-a', 's2');
+
+    // Online with nothing waiting, a refusal reaches the caller and nothing stays queued.
+    sources.updateSource.mockRejectedValueOnce(refused());
+    await expect(queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Refused' })).rejects.toThrow('row-level security');
+    expect(queue.getQueueSnapshot().items).toEqual([]);
+  });
+
+  it('drops the writes queued for a debate once Clear all succeeds, and keeps them when it fails', 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' });
+    // A clear the server refuses keeps everything queued.
+    await expect(queue.clearQueuedDebate('user-a', 'd1', async () => { throw new Error('clear failed'); })).rejects.toThrow('clear failed');
+    expect(queue.getQueueSnapshot().items).toHaveLength(2);
+    net.offline = true;
+    await queue.clearQueuedDebate('user-a', 'd1', async () => undefined);
+    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('keeps a change it could not store and says so, but sends nothing and takes no new write until it can', async () => {
+    const queue = await load();
+    const troubles: number[] = [];
+    queue.subscribeStorageTrouble(() => troubles.push(1));
+    net.offline = true;
+    // Every save fails while this lasts: the note stays queued in memory.
+    net.failSet = 1000;
+    await expect(queue.queueAddSource('user-a', { title: 'Kept in memory', content: 'Text', type: 'text', debateId: 'd1' })).resolves.toMatchObject({ status: 'queued' });
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(troubles).toHaveLength(1);
+    expect(queue.getQueueSnapshot().items).toHaveLength(1);
+
+    // A sent change could not be retired, so nothing is sent, and a new change is refused.
+    net.offline = false;
+    await queue.replayOfflineQueue();
+    expect(sources.addSource).not.toHaveBeenCalled();
+    await expect(queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Newer' })).rejects.toThrow('cannot be saved on this phone');
+    expect(sources.updateSource).not.toHaveBeenCalled();    net.failSet = 0;
+  });
+
+  it('never tells a caller a change is kept when the account changed before its save ran', async () => {
+    const queue = await load();
+    net.offline = true;
+    let release: () => void = () => undefined;
+    net.holdSet = new Promise<void>((resolve) => { release = resolve; });
+    // The first save waits in storage; the second is queued behind it.
+    const first = queue.queueAddSource('user-a', { title: 'First', content: 'Text', type: 'text', debateId: 'd1' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    const second = queue.queueAddSource('user-a', { title: 'Second', content: 'Text', type: 'text', debateId: 'd1' });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    queue.setQueueOwner('user-b');
+    net.holdSet = null;
+    release();
+    // The second save never ran for its account, so it is not reported as kept.
+    await expect(second).rejects.toThrow('account changed');
+    await first.catch(() => undefined);
+  });
+
+  it('sends a change once when the save that retires it fails, however often replay is asked', async () => {
+    const queue = await load();
+    net.offline = true;
+    await queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'One' });
+    await queue.queueUpdateSource('user-a', 'd1', 's2', { title: 'Two' });
+    // Back online, every save fails: "One" is sent, the save that retires it fails, and replay stops.
+    net.failSet = 1000;
+    net.offline = false;
+    await Promise.all([queue.replayOfflineQueue(), queue.replayOfflineQueue()]);
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual(['edit s1 {"title":"One"}']);
+    expect(queue.getQueueSnapshot().items.map((item) => (item.kind === 'edit' ? item.sourceId : ''))).toEqual(['s2']);
+    net.failSet = 0;
+  });
+
+  it('never writes over a stored queue it could not read, and keeps it once a read works', async () => {
+    let queue = await load();
+    net.offline = true;
+    await queue.queueAddSource('user-a', { title: 'From last week', content: 'Text', type: 'text', debateId: 'd1' });
+    const stored = [...storage.values()].join('');
+    expect(stored).toContain('From last week');
+
+    // A relaunch whose reads keep failing (at launch and again before the write, each with its retry):
+    // an offline write is refused and the store is untouched.
+    net.failGet = 4;
+    queue = await load();
+    await expect(queue.queueAddSource('user-a', { title: 'Today', content: 'Text', type: 'text', debateId: 'd1' })).rejects.toThrow();
+    expect([...storage.values()].join('')).toContain('From last week');
+    // Online writes wait too, so none goes ahead of last week's unread change.
+    net.failGet = 2;
+    net.offline = false;
+    await expect(queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Newer' })).rejects.toThrow('could not be read');
+    expect(sources.updateSource).not.toHaveBeenCalled();
+    net.offline = true;
+
+    // The next write reads the store again, keeps last week's note first and adds today's.
+    await queue.queueAddSource('user-a', { title: 'Today again', content: 'Text', type: 'text', debateId: 'd1' });
+    const titles = queue.getQueueSnapshot().items.map((item) => (item.kind === 'add' ? item.input.title : ''));
+    expect(titles).toEqual(['From last week', 'Today again']);
+  });
+
+  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' })]);
+    copies.set('source:s1', row('s1', { title: 'Old', content: 'Text', debateId: 'd1' }));
+    net.offline = true;
+    await queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'New' });
+    await cache.copiesWritten();
+    expect((copies.get('sources:d1') as Source[])[0].title).toBe('New');
+
+    // Back online the server refuses it, and the connection goes again before it can be read back.
+    sources.updateSource.mockRejectedValueOnce(refused());
+    sources.fetchSources.mockRejectedValueOnce(noAnswer());
+    sources.fetchSource.mockRejectedValueOnce(noAnswer());
+    net.offline = false;
+    await queue.replayOfflineQueue();
+    await cache.copiesWritten();
+    expect((copies.get('sources:d1') as Source[])[0].title).toBe('Old');
+    expect((copies.get('source:s1') as Source).title).toBe('Old');
+  });
+
+  it('puts back the old value even when the refusal comes before the copies have updated', async () => {
+    const queue = await load();
+    copies.set('sources:d1', [row('s1', { title: 'Old', content: 'Text', debateId: 'd1' })]);
+    copies.set('source:s1', row('s1', { title: 'Old', content: 'Text', debateId: 'd1' }));
+    // Online: the server refuses at once, while the copy update that notes "Old" is still waiting.
+    sources.updateSource.mockRejectedValueOnce(refused());
+    sources.fetchSources.mockRejectedValueOnce(noAnswer());
+    sources.fetchSource.mockRejectedValueOnce(noAnswer());
+    await expect(queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'New' })).rejects.toThrow('row-level security');
+    // The caller hears the refusal first; the copies are put back right after.
+    await queue.replayOfflineQueue();
+    await cache.copiesWritten();
+    expect((copies.get('sources:d1') as Source[])[0].title).toBe('Old');
+    expect((copies.get('source:s1') as Source).title).toBe('Old');
+  });
+
+  it('puts back the last saved value, not the first, when a later change to the same field is refused', async () => {
+    const queue = await load();
+    copies.set('sources:d1', [row('s1', { title: 'Old', content: 'Text', debateId: 'd1' })]);
+    copies.set('source:s1', row('s1', { title: 'Old', content: 'Text', debateId: 'd1' }));
+    let saveFirst: () => void = () => undefined;
+    sources.updateSource.mockImplementationOnce(() => new Promise<void>((resolve) => { saveFirst = resolve; }));
+    const first = queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'First' });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Queued while "First" is on its way, so it is a write of its own.
+    sources.updateSource.mockRejectedValueOnce(refused());
+    sources.fetchSources.mockRejectedValueOnce(noAnswer());
+    sources.fetchSource.mockRejectedValueOnce(noAnswer());
+    const second = queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Second' });
+    saveFirst();
+    await expect(first).resolves.toBe('saved');
+    await expect(second).rejects.toThrow('row-level security');
+    await queue.replayOfflineQueue();
+    await cache.copiesWritten();
+    expect((copies.get('sources:d1') as Source[])[0].title).toBe('First');
+  });
+
+  it('saves a waiting note with its later edits and switch, under the id after its temporary prefix', async () => {
+    const queue = await load();
+    net.offline = true;
+    const { source } = await queue.queueAddSource('user-a', { title: 'Draft', content: 'Text', type: 'text', debateId: 'd1' });
+    expect(queue.isLocalSourceId(source.id)).toBe(true);
+    await queue.queueUpdateSource('user-a', 'd1', source.id, { title: 'Final' });
+    await queue.queueSetSourcesActive('user-a', 'd1', [source.id], false);
+    expect(queue.withQueuedWrites(queue.getQueueSnapshot(), 'd1', [])).toMatchObject([{ id: source.id, title: 'Final', isActive: false }]);
+
+    net.offline = false;
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual(['add uuid-1 Final']);
+    expect(sources.addSource.mock.calls[0][1]).toMatchObject({ id: 'uuid-1', isActive: false });
+    expect(queue.currentSourceId(queue.getQueueSnapshot(), source.id)).toBe('uuid-1');
+  });
+
+  it('saves changes folded into a note whose insert landed but whose answer was lost', async () => {
+    const queue = await load();
+    copies.set('sources:d1', []);
+    net.offline = true;
+    const { source } = await queue.queueAddSource('user-a', { title: 'Draft', content: 'Text', type: 'text', debateId: 'd1' });
+    await queue.queueUpdateSource('user-a', 'd1', source.id, { title: 'Final' });
+    await queue.queueSetSourcesActive('user-a', 'd1', [source.id], false);
+    // The first insert reached the server as "Draft"; this replay's insert is refused as a duplicate.
+    sources.addSource.mockRejectedValueOnce(new sources.DuplicateSourceError('duplicate key'));
+    sources.fetchSource.mockResolvedValueOnce(row('uuid-1', { title: 'Draft', content: 'Text', debateId: 'd1' }));
+
+    net.offline = false;
+    await queue.replayOfflineQueue();
+    expect(sources.updateSource).toHaveBeenCalledWith('user-a', 'd1', 'uuid-1', { title: 'Final', isActive: false });
+    expect(queue.getQueueSnapshot().items).toHaveLength(0);
+    // No refresh follows this path, so the saved copies take the row: the note opens offline after a restart.
+    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 () => {
+    const queue = await load();
+    let answer!: () => void;
+    sources.addSource.mockImplementationOnce(
+      (_userId: string, input: { id: string; title: string; content: string; debateId: string }) =>
+        new Promise((resolve) => {
+          answer = () => resolve(row('row-1', input));
+        }),
+    );
+    const adding = queue.queueAddSource('user-a', { title: 'Note', content: 'Text', type: 'text', debateId: 'd1' });
+    await vi.waitFor(() => expect(sources.addSource).toHaveBeenCalled());
+    const editing = queue.queueUpdateSource('user-a', 'd1', 'local:uuid-1', { content: 'More' });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    answer();
+    await expect(adding).resolves.toMatchObject({ status: 'saved', source: { id: 'row-1' } });
+    await expect(editing).resolves.toBe('saved');
+    expect(sent()).toEqual(['add uuid-1 Note', 'edit row-1 {"content":"More"}']);
+  });
+
+  it('drops the changes to a note the server refused', async () => {
+    const queue = await load();
+    net.offline = true;
+    const { source } = await queue.queueAddSource('user-a', { title: 'Refused note', content: 'Text', type: 'text', debateId: 'd1' });
+    await queue.queueSetSourcesActive('user-a', 'd1', [source.id, 's9'], false);
+    sources.addSource.mockRejectedValueOnce(refused());
+    net.offline = false;
+    const reports: unknown[] = [];
+    queue.subscribeQueueReports((report) => reports.push(report));
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual(['add uuid-1 Refused note', 'active s9 false']);
+    expect(reports).toEqual([{ synced: 1, dropped: [{ kind: 'add', title: 'Refused note' }] }]);
+    await expect(queue.queueUpdateSource('user-a', 'd1', source.id, { title: 'Too late' })).rejects.toThrow();
+    expect(sources.updateSource).not.toHaveBeenCalled();
+  });
+
+  it('belongs to one account: a restart keeps it, another account removes it and never sends it', async () => {
+    let queue = await load('user-a');
+    net.offline = true;
+    await queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'A only' });
+    await vi.waitFor(() => expect([...storage.keys()]).toEqual(['debatelab.writes.v1:user-a']));
+
+    // Same account after a restart: sent once online.
+    queue = await load('user-a');
+    net.offline = false;
+    sources.updateSource.mockRejectedValueOnce(noAnswer());
+    await queue.replayOfflineQueue();
+    expect(queue.waitingCount(queue.getQueueSnapshot())).toBe(1);
+
+    // Another account signs in on the same phone.
+    vi.clearAllMocks();
+    queue = await load('user-b');
+    net.user = 'user-b';
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual([]);
+    expect([...storage.keys()]).toEqual([]);
+    await expect(queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Stale screen' })).rejects.toThrow('another account');
+  });
+
+  it('waits while the session belongs to no one or another account', async () => {
+    const queue = await load('user-a');
+    net.offline = true;
+    await queue.queueUpdateSource('user-a', 'd1', 's1', { title: 'Later' });
+    net.offline = false;
+    net.user = null;
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual([]);
+    net.user = 'user-a';
+    await queue.replayOfflineQueue();
+    expect(sent()).toEqual(['edit s1 {"title":"Later"}']);
+  });
+});
diff --git a/apps/mobile/src/lib/offline-queue.ts b/apps/mobile/src/lib/offline-queue.ts
new file mode 100644
index 000000000..54cd0e10e
--- /dev/null
+++ b/apps/mobile/src/lib/offline-queue.ts
@@ -0,0 +1,890 @@
+import { normalizeFolder } from '@debatelab/core/library';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as Crypto from 'expo-crypto';
+
+import { isKnownOffline } from './network-status';
+import { copiesWritten, ReadError, updateCopy } from './offline-cache';
+import { createSerialQueue } from './serial-queue';
+import {
+  addSource,
+  DuplicateSourceError,
+  fetchSource,
+  fetchSources,
+  notifySourcesChanged,
+  setSourcesActive,
+  updateSource,
+  type Source,
+  type SourcePatch,
+  type SourceType,
+} from './sources';
+import { supabase } from './supabase';
+
+/**
+ * The writes that wait for the connection: new notes, source edits (title,
+ * type, origin, text, folder) and Active switches. Every one of them goes
+ * through this queue, online too, so they reach the server one at a time in
+ * the order the student made them. A write that gets no answer from the
+ * server (supabase-js status 0, or the device is offline) stays queued and is
+ * sent again when the connection returns, when the app comes to the
+ * foreground, or on launch. A write the server refuses (a policy, an expired
+ * session, a bad request) is dropped: the caller still waiting gets the error,
+ * and a replay nobody waits for is reported once (`subscribeQueueReports`).
+ *
+ * The queue belongs to one account, as the saved copies do: it is stored under
+ * the user id, and every other account's queue is removed when the owner
+ * changes, including signing out. Deletes, AI and every other write stay
+ * online-only.
+ */
+
+/** A new note gets this id until it reaches the server; the row is then inserted with the id after the prefix. */
+const LOCAL_PREFIX = 'local:';
+
+export const isLocalSourceId = (id: string) => id.startsWith(LOCAL_PREFIX);
+
+const PREFIX = 'debatelab.writes.v1';
+const storageKey = (userId: string) => `${PREFIX}:${userId}`;
+
+export type WriteStatus = 'saved' | 'queued';
+
+/** What an offline note can carry; the Library's note sheet sets only some of it. */
+export interface QueuedNoteInput {
+  title: string;
+  content: string;
+  type: SourceType;
+  origin?: string | null;
+  debateId: string;
+  folder?: string;
+  isActive?: boolean;
+}
+
+/** Edits never carry the Active switch: that has its own writes, in their own order. */
+export type QueuedPatch = Omit<SourcePatch, 'isActive'>;
+
+interface Base {
+  key: string;
+  at: number;
+  /** Got no answer once, or was made while others waited: the student sees it as waiting to sync. */
+  waiting: boolean;
+}
+export interface QueuedAdd extends Base {
+  kind: 'add';
+  tempId: string;
+  input: Required<Omit<QueuedNoteInput, 'origin'>> & { origin: string | null };
+}
+export interface QueuedEdit extends Base {
+  kind: 'edit';
+  debateId: string;
+  sourceId: string;
+  patch: QueuedPatch;
+}
+export interface QueuedActive extends Base {
+  kind: 'active';
+  debateId: string;
+  ids: string[];
+  isActive: boolean;
+}
+export type QueuedWrite = QueuedAdd | QueuedEdit | QueuedActive;
+
+/** What screens draw from: the queue of one account and the notes that reached the server this session. */
+export interface QueueSnapshot {
+  owner: string | null | undefined;
+  items: readonly QueuedWrite[];
+  /** A synced note's temporary id, and the row the server saved. */
+  synced: ReadonlyMap<string, Source>;
+}
+
+/** After a replay that nobody was waiting for: how many writes reached the server, and the ones it refused. */
+export interface QueueReport {
+  synced: number;
+  dropped: { kind: QueuedWrite['kind']; title?: string }[];
+}
+
+interface Waiter {
+  resolve: (status: WriteStatus) => void;
+  reject: (cause: unknown) => void;
+}
+
+const storage = createSerialQueue();
+// undefined until the first account is named, by the root layout or by a first write.
+let owner: string | null | undefined;
+let generation = 0;
+let ready: Promise<void> = Promise.resolve();
+let items: QueuedWrite[] = [];
+/**
+ * What the saved copies showed before the changes still queued for each source, field by
+ * field (the earliest value only). A refused change puts these back with no network needed;
+ * a saved one forgets them. Kept on the phone with the queue.
+ */
+type Restorable = Partial<Pick<Source, 'title' | 'content' | 'type' | 'origin' | 'folder' | 'isActive'>>;
+type RestorableField = keyof Restorable;
+let before: Record<string, Restorable> = {};
+let synced = new Map<string, Source>();
+let waiters = new Map<string, Waiter[]>();
+let inFlight: string | null = null;
+let snapshot: QueueSnapshot = { owner, items, synced };
+let running: Promise<void> | null = null;
+// While Clear all asks the server, nothing replays: a queued note must not land in a Library being cleared.
+let paused = 0;
+// Whether this account's stored queue has been read. Until it has, nothing is written over it.
+let hydrated = false;
+// Writes that wait for the connection, told "queued" once the save holding them has been tried.
+let awaitingSave: { key: string; waiter: Waiter }[] = [];
+// Saving the queue failed and has not worked since: the student has been told once.
+let storageTroubled = false;
+let retrySave: ReturnType<typeof setTimeout> | undefined;
+const storageListeners = new Set<() => void>();
+
+/** Called once when the queue could not be saved on the phone: changes then last only while the app is open. */
+export function subscribeStorageTrouble(listener: () => void): () => void {
+  storageListeners.add(listener);
+  return () => {
+    storageListeners.delete(listener);
+  };
+}
+let again = false;
+let keys = 0;
+
+const listeners = new Set<() => void>();
+const reportListeners = new Set<(report: QueueReport) => void>();
+
+function warn(what: string) {
+  return (cause: unknown) => console.warn(`${what}:`, cause instanceof Error ? cause.message : cause);
+}
+
+function emit() {
+  snapshot = { owner, items, synced };
+  listeners.forEach((listener) => listener());
+}
+
+export function subscribeQueue(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function getQueueSnapshot(): QueueSnapshot {
+  return snapshot;
+}
+
+export function subscribeQueueReports(listener: (report: QueueReport) => void): () => void {
+  reportListeners.add(listener);
+  return () => {
+    reportListeners.delete(listener);
+  };
+}
+
+/** Saves the queue; resolves whether the phone kept it. */
+function persist(): Promise<boolean> {
+  const userId = owner;
+  const gen = generation;
+  const saved = items.map((item) => ({ ...item }));
+  const savedBefore = { ...before };
+  const confirming = awaitingSave;
+  awaitingSave = [];
+  if (!userId) return Promise.resolve(true);
+  return storage(async () => {
+    // The account changed before this save ran: nothing is written, so nothing may count as kept.
+    if (gen !== generation) return false;
+    // A stored queue that could not be read is never written over: it may hold unsynced work.
+    if (!hydrated) throw new Error('The offline changes on this phone could not be read.');
+    const write = () =>
+      saved.length === 0
+        ? AsyncStorage.removeItem(storageKey(userId))
+        : AsyncStorage.setItem(storageKey(userId), JSON.stringify({ userId, items: saved, before: savedBefore }));
+    // One retry for a passing storage error before anyone hears the change was not kept.
+    await write().catch(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      await write();
+    });
+    return true;
+  }).then(
+    (wrote) => {
+      if (!wrote) {
+        // The changes belonged to the account that was replaced; it removed them, as a sign-out does.
+        const error = new Error('The account changed before this change was saved.');
+        confirming.forEach(({ waiter }) => waiter.reject(error));
+        return false;
+      }
+      const recovered = storageTroubled;
+      storageTroubled = false;
+      confirming.forEach(({ waiter }) => waiter.resolve('queued'));
+      // Sending waited while the queue could not be stored; it can go on now.
+      if (recovered && gen === generation) void replayOfflineQueue();
+      return true;
+    },
+    (cause: unknown) => {
+      warn('Could not keep the offline changes')(cause);
+      // The changes stay queued and still sync once the phone can store them; until then nothing is
+      // sent (a sent change could not be retired) and new writes are refused (adopt).
+      confirming.forEach(({ waiter }) => waiter.resolve('queued'));
+      if (gen !== generation || !hydrated) return false;
+      // Told after the caller's own "saved on this phone" message, and for every change made meanwhile.
+      if (!storageTroubled || confirming.length > 0) setTimeout(() => storageListeners.forEach((listener) => listener()), 0);
+      storageTroubled = true;
+      clearTimeout(retrySave);
+      retrySave = setTimeout(() => {
+        if (gen === generation) void persist();
+      }, 5000);
+      return false;
+    },
+  );
+}
+
+function parse(raw: string | null, userId: string): { items: QueuedWrite[]; before: Record<string, Restorable> } {
+  const none = { items: [], before: {} };
+  if (!raw) return none;
+  try {
+    const parsed = JSON.parse(raw) as { userId?: unknown; items?: unknown; before?: unknown };
+    if (parsed.userId !== userId || !Array.isArray(parsed.items)) return none;
+    return {
+      items: (parsed.items as QueuedWrite[]).filter((item) => item && (item.kind === 'add' || item.kind === 'edit' || item.kind === 'active')),
+      before: parsed.before && typeof parsed.before === 'object' && !Array.isArray(parsed.before) ? (parsed.before as Record<string, Restorable>) : {},
+    };
+  } catch {
+    return none;
+  }
+}
+
+/**
+ * Reads the account's stored queue, once more after a passing failure. Writes from an earlier
+ * launch go ahead of any made since; until a read succeeds nothing is written over the store.
+ */
+async function hydrate(userId: string, gen: number) {
+  let raw: string | null;
+  try {
+    raw = await AsyncStorage.getItem(storageKey(userId)).catch(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      return AsyncStorage.getItem(storageKey(userId));
+    });
+  } catch (cause) {
+    warn('Could not read the offline changes')(cause);
+    return;
+  }
+  if (gen !== generation) return;
+  const loaded = parse(raw, userId);
+  hydrated = true;
+  if (loaded.items.length === 0) return;
+  // Nobody waits for writes from an earlier launch: they show as waiting until they sync.
+  const known = new Set(items.map((item) => item.key));
+  items = [...loaded.items.filter((item) => !known.has(item.key)).map((item) => ({ ...item, waiting: true })), ...items];
+  before = { ...loaded.before, ...before };
+  emit();
+}
+
+/**
+ * Called with the signed-in account once auth has settled. Another account's
+ * queue, or one left with no account, is removed; the same account after a
+ * restart keeps its queue and sends it again.
+ */
+export function setQueueOwner(userId: string | null) {
+  if (userId === owner) return;
+  owner = userId;
+  generation += 1;
+  const gen = generation;
+  const orphaned = waiters;
+  waiters = new Map();
+  orphaned.forEach((list) => list.forEach((waiter) => waiter.reject(new Error('The account changed before this change was saved.'))));
+  items = [];
+  before = {};
+  synced = new Map();
+  inFlight = null;
+  emit();
+  hydrated = false;
+  awaitingSave = [];
+  storageTroubled = false;
+  clearTimeout(retrySave);
+  ready = storage(async () => {
+    const stale = (await AsyncStorage.getAllKeys()).filter((key) => key.startsWith(`${PREFIX}:`) && (userId === null || key !== storageKey(userId)));
+    if (stale.length > 0) await AsyncStorage.multiRemove(stale);
+    if (!userId) return;
+    await hydrate(userId, gen);
+  }).catch(warn('Could not read the offline changes'));
+}
+
+/** A first write before the root layout named the owner adopts its account; a write for another account is refused. */
+async function adopt(userId: string) {
+  if (owner === undefined) setQueueOwner(userId);
+  else if (owner !== userId) throw new Error('This change belongs to another account.');
+  await ready;
+  if (owner !== userId) throw new Error('This change belongs to another account.');
+  // The stored queue could not be read at launch: read it again before any write, online ones too,
+  // so nothing goes ahead of older unsynced work and nothing is written over it.
+  if (!hydrated) {
+    const gen = generation;
+    ready = storage(() => hydrate(userId, gen)).catch(warn('Could not read the offline changes'));
+    await ready;
+    if (owner !== userId) throw new Error('This change belongs to another account.');
+    if (!hydrated) throw new Error('The changes saved on this phone could not be read. Try again.');
+  }
+  // The phone cannot store the queue right now: a new change could not be kept, nor a sent one retired.
+  if (storageTroubled) throw new Error('Changes cannot be saved on this phone right now. Try again.');
+}
+
+const isWaitingForNetwork = () => isKnownOffline() || items.some((item) => item.waiting);
+
+function attach(key: string, waiter: Waiter, waiting: boolean) {
+  if (waiting) {
+    // Told "queued" once the queue holding it is saved (persist), never before.
+    awaitingSave.push({ key, waiter });
+    return;
+  }
+  waiters.set(key, [...(waiters.get(key) ?? []), waiter]);
+}
+
+function takeWaiters(key: string): Waiter[] {
+  const list = waiters.get(key) ?? [];
+  waiters.delete(key);
+  return list;
+}
+
+/** Every write still queued waits for the connection; whoever waited for one hears that it is kept. */
+function parkAll() {
+  if (items.length === 0) return;
+  items = items.map((item) => (item.waiting ? item : { ...item, waiting: true }));
+  const parked = waiters;
+  waiters = new Map();
+  parked.forEach((list, key) => list.forEach((waiter) => awaitingSave.push({ key, waiter })));
+  persist();
+  emit();
+}
+
+function commit(next: QueuedWrite[]) {
+  items = next;
+  persist();
+  emit();
+  void replayOfflineQueue();
+}
+
+const newKey = () => `${Date.now().toString(36)}-${++keys}`;
+const pendingAdd = (id: string) => items.find((item): item is QueuedAdd => item.kind === 'add' && item.tempId === id && item.key !== inFlight);
+/** A synced note's temporary id names its row from then on. */
+const realIdOf = (id: string) => synced.get(id)?.id ?? id;
+/** A temporary id with no note behind it any more (deleted or refused) never reaches a query. */
+const isGone = (id: string) => isLocalSourceId(id) && !items.some((item) => item.kind === 'add' && item.tempId === id);
+const goneError = () => new Error('This note was not saved.');
+
+/** The note as the Library shows it while it waits. */
+function sourceOfAdd(item: QueuedAdd): Source {
+  return {
+    id: item.tempId,
+    title: item.input.title,
+    content: item.input.content,
+    type: item.input.type,
+    origin: item.input.origin,
+    createdAt: item.at,
+    useCount: 0,
+    folder: item.input.folder,
+    isActive: item.input.isActive,
+    debateId: item.input.debateId,
+    metadata: null,
+  };
+}
+
+/** A patch applied the way updateSource writes it: blank title or text is ignored. */
+function applyPatch<T extends Pick<Source, 'title' | 'content' | 'type' | 'origin' | 'folder'>>(source: T, patch: QueuedPatch): T {
+  const next = { ...source };
+  if (patch.title !== undefined && patch.title.trim()) next.title = patch.title.trim();
+  if (patch.content !== undefined && patch.content.trim()) next.content = patch.content.trim();
+  if (patch.type !== undefined) next.type = patch.type;
+  if (patch.origin !== undefined) next.origin = patch.origin?.trim() || null;
+  if (patch.folder !== undefined) next.folder = normalizeFolder(patch.folder);
+  return next;
+}
+
+/** The offline copies show a queued change after a restart too. */
+function updateSourceCopies(userId: string, debateId: string, ids: string[], change: (source: Source) => Source, remember: RestorableField[] = []) {
+  const gen = generation;
+  // The copy as it was, for each field not yet remembered for that source (see `before`).
+  const keep = (source: Source) => {
+    if (remember.length === 0 || isLocalSourceId(source.id) || gen !== generation) return source;
+    const held: Restorable = { ...before[source.id] };
+    let added = false;
+    for (const field of remember) {
+      if (field in held) continue;
+      (held as Record<string, unknown>)[field] = source[field];
+      added = true;
+    }
+    if (added) {
+      before = { ...before, [source.id]: held };
+      persist();
+    }
+    return source;
+  };
+  updateCopy<Source[]>(userId, 'sources', debateId, (list) => list?.map((source) => (ids.includes(source.id) ? change(keep(source)) : source)));
+  for (const id of ids) {
+    if (isLocalSourceId(id)) continue;
+    // A saved null (a row that was gone) stays as it is.
+    updateCopy<Source | null>(userId, 'source', id, (copy) => (copy ? change(keep(copy)) : copy === null ? null : undefined));
+  }
+}
+
+/** The values a write saved for one source, as the server stores them (updateSource and setSourcesActive). */
+function savedValues(item: QueuedWrite, id: string): Restorable {
+  if (item.kind === 'active') return item.ids.includes(id) ? { isActive: item.isActive } : {};
+  if (item.kind !== 'edit' || item.sourceId !== id) return {};
+  const values: Restorable = {};
+  const { title, content, type, origin, folder } = item.patch;
+  if (title !== undefined && title.trim()) values.title = title.trim();
+  if (content !== undefined && content.trim()) values.content = content.trim();
+  if (type !== undefined) values.type = type;
+  if (origin !== undefined) values.origin = origin?.trim() || null;
+  if (folder !== undefined) values.folder = normalizeFolder(folder);
+  return values;
+}
+
+/** The fields a write changes for each source it names. */
+function touched(item: QueuedWrite): { id: string; fields: RestorableField[] }[] {
+  if (item.kind === 'edit') return [{ id: item.sourceId, fields: Object.keys(item.patch) as RestorableField[] }];
+  if (item.kind === 'active') return item.ids.map((id) => ({ id, fields: ['isActive'] }));
+  return [];
+}
+
+/**
+ * Settles what `before` holds for a write that left the queue: a refused one puts those
+ * values back into the copies, unless a write still queued changes the same field (that
+ * newer value is what shows); either way the fields no queued write touches are forgotten.
+ */
+function settleBefore(userId: string, item: QueuedWrite, refused: boolean) {
+  const debateId = item.kind === 'add' ? item.input.debateId : item.debateId;
+  let next = before;
+  for (const { id, fields } of touched(item)) {
+    const held = next[id];
+    if (!held) continue;
+    const stillQueued = new Set(items.flatMap((other) => touched(other).filter((one) => one.id === id).flatMap((one) => one.fields)));
+    if (!refused) {
+      // A saved write is the server's value now: a newer queued write that is refused goes back to it.
+      const saved = savedValues(item, id);
+      const advanced: Restorable = { ...held };
+      for (const field of fields) if (stillQueued.has(field) && field in saved) (advanced as Record<string, unknown>)[field] = saved[field];
+      next = { ...next, [id]: advanced };
+    }
+    const free = fields.filter((field) => field in held && !stillQueued.has(field));
+    if (free.length === 0) continue;
+    if (refused) {
+      const restore = Object.fromEntries(free.map((field) => [field, held[field]])) as Restorable;
+      updateSourceCopies(userId, debateId, [id], (source) => ({ ...source, ...restore }));
+    }
+    const current = next[id] ?? held;
+    const left = Object.fromEntries(Object.entries(current).filter(([field]) => !free.includes(field as RestorableField))) as Restorable;
+    next = { ...next };
+    if (Object.keys(left).length > 0) next[id] = left;
+    else delete next[id];
+  }
+  before = next;
+}
+
+/**
+ * Saves a note to a debate, as addSource does. It shows at once; offline, or
+ * when the server gives no answer, it waits under a temporary id and the row
+ * is added once the connection is back.
+ */
+export async function queueAddSource(userId: string, input: QueuedNoteInput): Promise<{ status: WriteStatus; source: Source }> {
+  await adopt(userId);
+  const item: QueuedAdd = {
+    kind: 'add',
+    key: newKey(),
+    at: Date.now(),
+    waiting: isWaitingForNetwork(),
+    tempId: `${LOCAL_PREFIX}${Crypto.randomUUID()}`,
+    input: {
+      title: input.title,
+      content: input.content,
+      type: input.type,
+      origin: input.origin || null,
+      debateId: input.debateId,
+      folder: normalizeFolder(input.folder),
+      isActive: input.isActive ?? true,
+    },
+  };
+  const pending = sourceOfAdd(item);
+  updateCopy<Source[]>(userId, 'sources', input.debateId, (list) => list && [pending, ...list.filter((source) => source.id !== pending.id)]);
+  const status = new Promise<WriteStatus>((resolve, reject) => attach(item.key, { resolve, reject }, item.waiting));
+  commit([...items, item]);
+  const result = await status;
+  return { status: result, source: (result === 'saved' && synced.get(item.tempId)) || pending };
+}
+
+/**
+ * Saves the fields the student edited, as updateSource does. Several edits of
+ * one source that have not been sent yet become one; an edit of a note that is
+ * still waiting goes into the note itself.
+ */
+export async function queueUpdateSource(userId: string, debateId: string, sourceId: string, patch: QueuedPatch): Promise<WriteStatus> {
+  const fields: QueuedPatch = {};
+  for (const field of ['title', 'content', 'type', 'origin', 'folder'] as const) {
+    if (patch[field] !== undefined) (fields as Record<string, unknown>)[field] = patch[field];
+  }
+  if (Object.keys(fields).length === 0) return 'saved';
+  await adopt(userId);
+  const id = realIdOf(sourceId);
+  if (isGone(id)) throw goneError();
+  updateSourceCopies(userId, debateId, [id], (source) => applyPatch(source, fields), Object.keys(fields) as RestorableField[]);
+  return new Promise<WriteStatus>((resolve, reject) => {
+    const waiter = { resolve, reject };
+    const add = pendingAdd(id);
+    if (add) {
+      const input = applyPatch({ ...add.input }, fields);
+      attach(add.key, waiter, add.waiting);
+      commit(items.map((item) => (item === add ? { ...add, input } : item)));
+      return;
+    }
+    const earlier = items.find((item): item is QueuedEdit => item.kind === 'edit' && item.sourceId === id && item.key !== inFlight);
+    if (earlier) {
+      attach(earlier.key, waiter, earlier.waiting);
+      commit(items.map((item) => (item === earlier ? { ...earlier, patch: { ...earlier.patch, ...fields } } : item)));
+      return;
+    }
+    const edit: QueuedEdit = { kind: 'edit', key: newKey(), at: Date.now(), waiting: isWaitingForNetwork(), debateId, sourceId: id, patch: fields };
+    attach(edit.key, waiter, edit.waiting);
+    commit([...items, edit]);
+  });
+}
+
+/**
+ * Turns sources on or off, as setSourcesActive does. A newer switch of a
+ * source replaces the ones not sent yet; a note still waiting takes the value itself.
+ */
+export async function queueSetSourcesActive(userId: string, debateId: string, sourceIds: string[], isActive: boolean): Promise<WriteStatus> {
+  if (sourceIds.length === 0) return 'saved';
+  await adopt(userId);
+  const ids = Array.from(new Set(sourceIds.map(realIdOf))).filter((id) => !isGone(id));
+  if (ids.length === 0) throw goneError();
+  updateSourceCopies(userId, debateId, ids, (source) => ({ ...source, isActive }), ['isActive']);
+  return new Promise<WriteStatus>((resolve, reject) => {
+    const waiter = { resolve, reject };
+    const inherited: Waiter[] = [];
+    // Earlier switches of the same sources that are not on their way yet are replaced by this one.
+    let next = items.flatMap((item): QueuedWrite[] => {
+      if (item.kind !== 'active' || item.key === inFlight || !item.ids.some((id) => ids.includes(id))) return [item];
+      const left = item.ids.filter((id) => !ids.includes(id));
+      if (left.length > 0) return [{ ...item, ids: left }];
+      inherited.push(...takeWaiters(item.key));
+      return [];
+    });
+    // A note that has not been sent yet is saved with the value.
+    const folded: QueuedAdd[] = [];
+    next = next.map((item) => {
+      if (item.kind !== 'add' || item.key === inFlight || !ids.includes(item.tempId)) return item;
+      const changed = { ...item, input: { ...item.input, isActive } };
+      folded.push(changed);
+      return changed;
+    });
+    const rest = ids.filter((id) => !folded.some((add) => add.tempId === id));
+    items = next;
+    if (rest.length === 0) {
+      // Every source was a waiting note: the note's own write answers for the switch.
+      const add = folded[0];
+      for (const one of [waiter, ...inherited]) attach(add.key, one, add.waiting);
+      commit(items);
+      return;
+    }
+    const active: QueuedActive = { kind: 'active', key: newKey(), at: Date.now(), waiting: isWaitingForNetwork(), debateId, ids: rest, isActive };
+    for (const one of [waiter, ...inherited]) attach(active.key, one, active.waiting);
+    commit([...items, active]);
+  });
+}
+
+/**
+ * Clear all for a debate: lets a replay that is running finish and holds the queue while `clear`
+ * asks the server; only once it succeeds are the debate's queued writes (its waiting notes, edits
+ * and switches) dropped, so none comes back. A clear that fails keeps them, and the queue resumes.
+ */
+export async function clearQueuedDebate(userId: string, debateId: string, clear: () => Promise<void>): Promise<void> {
+  await adopt(userId);
+  paused += 1;
+  try {
+    if (running) await running.catch(() => undefined);
+    await clear();
+    if (owner === userId) dropDebateWrites(userId, debateId);
+  } finally {
+    paused -= 1;
+    void replayOfflineQueue();
+  }
+}
+
+function dropDebateWrites(userId: string, debateId: string) {
+  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.
+ */
+export function cancelQueuedSource(userId: string, tempId: string): boolean {
+  if (owner !== userId) return false;
+  const add = pendingAdd(tempId);
+  if (!add) return false;
+  const removed = dropWrites(tempId, add.key);
+  updateCopy<Source[]>(userId, 'sources', add.input.debateId, (list) => list?.filter((source) => source.id !== tempId));
+  removed.forEach((key) => takeWaiters(key).forEach((waiter) => waiter.reject(new Error('The note was deleted before it was saved.'))));
+  persist();
+  emit();
+  return true;
+}
+
+/** Drops a note's write and every queued change to it; returns the keys of the writes that went. */
+function dropWrites(tempId: string, addKey: string): string[] {
+  const removed: string[] = [addKey];
+  items = items.flatMap((item): QueuedWrite[] => {
+    if (item.key === addKey || (item.kind === 'edit' && item.sourceId === tempId)) {
+      if (item.key !== addKey) removed.push(item.key);
+      return [];
+    }
+    if (item.kind === 'active' && item.ids.includes(tempId)) {
+      const left = item.ids.filter((id) => id !== tempId);
+      if (left.length > 0) return [{ ...item, ids: left }];
+      removed.push(item.key);
+      return [];
+    }
+    return [item];
+  });
+  return removed;
+}
+
+/**
+ * Puts the server's version back into the saved copies a refused write changed when it was queued
+ * (updateSourceCopies). The list copy is read again rather than dropped, so notes still waiting stay
+ * visible offline (they show over it from the queue). A refused new note leaves the list copy.
+ */
+async function restoreRefused(userId: string, item: QueuedWrite): Promise<void> {
+  const debateId = item.kind === 'add' ? item.input.debateId : item.debateId;
+  if (item.kind === 'add') {
+    updateCopy<Source[]>(userId, 'sources', debateId, (list) => list?.filter((source) => source.id !== item.tempId));
+  }
+  const ids = (item.kind === 'edit' ? [item.sourceId] : item.kind === 'active' ? item.ids : []).filter((id) => !isLocalSourceId(id));
+  // A read that fails keeps the copy it had; the next read online replaces it.
+  await Promise.all([fetchSources(userId, debateId), ...ids.map((id) => fetchSource(userId, id))]).catch(() => undefined);
+}
+
+/** Whether no answer came back from the server: those writes stay queued. */
+function unanswered(cause: unknown): boolean {
+  return cause instanceof ReadError && cause.unreachable;
+}
+
+/** Sends one write through the function the online path uses. A note returns its saved row. */
+async function send(userId: string, item: QueuedWrite): Promise<Source | undefined> {
+  if (item.kind === 'edit') {
+    await updateSource(userId, item.debateId, item.sourceId, item.patch);
+    return undefined;
+  }
+  if (item.kind === 'active') {
+    await setSourcesActive(userId, item.debateId, item.ids, item.isActive);
+    return undefined;
+  }
+  const id = item.tempId.slice(LOCAL_PREFIX.length);
+  try {
+    // The row gets the id after the prefix, so a note whose answer was lost is not added twice.
+    return await addSource(userId, { ...item.input, id, createdAt: item.at });
+  } catch (cause) {
+    if (!(cause instanceof DuplicateSourceError)) throw cause;
+    const existing = await fetchSource(userId, id);
+    if (existing?.id !== id) throw cause;
+    // The insert reached the server but its answer did not. Changes made since were folded into this
+    // note, so the saved row may predate them: save the fields that differ before calling it synced.
+    const { input } = item;
+    const patch: SourcePatch = {};
+    if (existing.title !== input.title) patch.title = input.title;
+    if (existing.content !== input.content) patch.content = input.content;
+    if (existing.type !== input.type) patch.type = input.type;
+    if ((existing.origin ?? null) !== input.origin) patch.origin = input.origin;
+    if (existing.folder !== input.folder) patch.folder = input.folder;
+    if (existing.isActive !== input.isActive) patch.isActive = input.isActive;
+    let saved = existing;
+    if (Object.keys(patch).length > 0) {
+      await updateSource(userId, input.debateId, id, patch);
+      saved = { ...existing, ...patch };
+    }
+    // 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;
+  }
+}
+
+/** The account's session, refreshed when it has expired, so a replay never goes out with a stale token. */
+async function signedInAs(userId: string): Promise<boolean> {
+  try {
+    const { data } = await supabase.auth.getSession();
+    return data.session?.user.id === userId;
+  } catch {
+    return false;
+  }
+}
+
+function describe(item: QueuedWrite): QueueReport['dropped'][number] {
+  if (item.kind === 'add') return { kind: 'add', title: item.input.title };
+  if (item.kind === 'edit') return { kind: 'edit', title: item.patch.title };
+  return { kind: 'active' };
+}
+
+async function drain() {
+  const userId = owner;
+  const gen = generation;
+  if (!userId || paused > 0 || storageTroubled) return;
+  await ready;
+  if (gen !== generation || items.length === 0 || paused > 0 || storageTroubled) return;
+  if (isKnownOffline() || !(await signedInAs(userId))) {
+    if (gen === generation) parkAll();
+    return;
+  }
+  const report: QueueReport = { synced: 0, dropped: [] };
+  while (gen === generation && items.length > 0) {
+    if (isKnownOffline()) {
+      parkAll();
+      break;
+    }
+    const item = items[0];
+    inFlight = item.key;
+    let row: Source | undefined;
+    let failure: { cause: unknown } | null = null;
+    try {
+      row = await send(userId, item);
+    } catch (cause) {
+      failure = { cause };
+    }
+    if (gen !== generation) return;
+    inFlight = null;
+    if (failure && unanswered(failure.cause)) {
+      parkAll();
+      break;
+    }
+    const done = takeWaiters(item.key);
+    items = items.filter((other) => other.key !== item.key);
+    if (!failure) {
+      if (item.kind === 'add' && row) {
+        synced = new Map(synced).set(item.tempId, row);
+        const realId = row.id;
+        // Changes queued while the note was on its way now name its row.
+        items = items.map((other) => {
+          if (other.kind === 'edit' && other.sourceId === item.tempId) return { ...other, sourceId: realId };
+          if (other.kind === 'active' && other.ids.includes(item.tempId)) return { ...other, ids: other.ids.map((id) => (id === item.tempId ? realId : id)) };
+          return other;
+        });
+      }
+      persist();
+      emit();
+      done.forEach((waiter) => waiter.resolve('saved'));
+      if (done.length === 0) report.synced += 1;
+      // What a refused newer change goes back to is noted while the copies update, which may still be running.
+      await copiesWritten();
+      if (gen !== generation) break;
+      settleBefore(userId, item, false);
+      // A sent change the phone cannot retire would be sent again after a relaunch: stop until it can.
+      if (!(await persist())) break;
+    } else {
+      console.warn('The server refused an offline change:', failure.cause instanceof Error ? failure.cause.message : failure.cause);
+      const dependents = item.kind === 'add' ? dropWrites(item.tempId, item.key).slice(1) : [];
+      const all = [...done, ...dependents.flatMap(takeWaiters)];
+      persist();
+      emit();
+      all.forEach((waiter) => waiter.reject(failure.cause));
+      if (done.length === 0) report.dropped.push(describe(item));
+      // The saved copies still hold the refused change: put back what they showed before it,
+      // which needs no network, then read the server's version over that when it answers.
+      // Every other queued write stays visible; screens that showed the change read it again.
+      // The values to put back are noted while the copies update, which may still be running.
+      await copiesWritten();
+      if (gen !== generation) break;
+      settleBefore(userId, item, true);
+      persist();
+      await restoreRefused(userId, item);
+      notifySourcesChanged();
+    }
+  }
+  if (gen === generation && (report.synced > 0 || report.dropped.length > 0)) reportListeners.forEach((listener) => listener(report));
+}
+
+/**
+ * Sends the queued writes, one at a time and in order. Called when the
+ * connection returns, the app comes to the foreground, the account is known
+ * at launch, and after every new write; a call while a replay runs makes it go round once more.
+ */
+export function replayOfflineQueue(): Promise<void> {
+  if (running) {
+    again = true;
+    return running;
+  }
+  running = (async () => {
+    try {
+      do {
+        again = false;
+        await drain().catch(warn('Could not send the offline changes'));
+        // A trigger that came in meanwhile (the connection is back, a new write) gets one more pass.
+      } while (again);
+    } finally {
+      // In the same tick as the last check of `again`, so no trigger falls between them.
+      running = null;
+    }
+  })();
+  return running;
+}
+
+/** One debate's sources with the queued changes on top: waiting notes first, then edits and switches in order. */
+export function withQueuedWrites(state: QueueSnapshot, debateId: string, sources: Source[]): Source[] {
+  if (state.items.length === 0) return sources;
+  let next = sources;
+  for (const item of state.items) {
+    if (item.kind === 'add') {
+      if (item.input.debateId !== debateId || next.some((source) => source.id === item.tempId || source.id === state.synced.get(item.tempId)?.id)) continue;
+      next = [sourceOfAdd(item), ...next];
+    } else if (item.debateId === debateId) {
+      next = next.map((source) => applyItem(item, source));
+    }
+  }
+  return next;
+}
+
+function applyItem(item: QueuedEdit | QueuedActive, source: Source): Source {
+  if (item.kind === 'edit') return item.sourceId === source.id ? applyPatch(source, item.patch) : source;
+  return item.ids.includes(source.id) ? { ...source, isActive: item.isActive } : source;
+}
+
+/** One source with its queued changes on top. */
+export function withQueuedWrite(state: QueueSnapshot, source: Source): Source {
+  let next = source;
+  for (const item of state.items) if (item.kind !== 'add') next = applyItem(item, next);
+  return next;
+}
+
+/** A note that waits to be saved, with its queued changes, or null when it is gone. */
+export function queuedSource(state: QueueSnapshot, tempId: string): Source | null {
+  const add = state.items.find((item): item is QueuedAdd => item.kind === 'add' && item.tempId === tempId);
+  return add ? withQueuedWrite(state, sourceOfAdd(add)) : null;
+}
+
+/** The id that names a source now: a synced note's row id, otherwise the id itself. */
+export function currentSourceId(state: QueueSnapshot, id: string): string {
+  return state.synced.get(id)?.id ?? id;
+}
+
+/** The sources with a change that waits for the connection. */
+export function waitingSourceIds(state: QueueSnapshot): Set<string> {
+  const ids = new Set<string>();
+  for (const item of state.items) {
+    if (!item.waiting) continue;
+    if (item.kind === 'add') ids.add(item.tempId);
+    else if (item.kind === 'edit') ids.add(item.sourceId);
+    else item.ids.forEach((id) => ids.add(id));
+  }
+  return ids;
+}
+
+/** How many changes wait for the connection. */
+export function waitingCount(state: QueueSnapshot): number {
+  return state.items.filter((item) => item.waiting).length;
+}
diff --git a/apps/mobile/src/lib/open-results.ts b/apps/mobile/src/lib/open-results.ts
index 4f2fa5865..1a85fe523 100644
--- a/apps/mobile/src/lib/open-results.ts
+++ b/apps/mobile/src/lib/open-results.ts
@@ -1,5 +1,6 @@
 import type { DiscoveredSource } from '@debatelab/core/ai/discovered-sources';
 
+import { announceResult } from './a11y';
 import { haptics } from './haptics';
 import type { OutputFor, ResultKind } from './results';
 import { sessionSlot } from './session-memory';
@@ -29,6 +30,7 @@ let localId = 0;
 /** Keeps a result under its saved id, or a local key when it is not saved. Returns the key to open it with. A finished result taps success. */
 export function keepOpenResult<K extends ResultKind>(result: OpenResult<K>): string {
   haptics.success();
+  announceResult(result.title);
   const key = result.savedId ?? `local-${Date.now()}-${(localId += 1)}`;
   store.get().set(key, result as OpenResult);
   return key;
diff --git a/apps/mobile/src/lib/quick-actions.ts b/apps/mobile/src/lib/quick-actions.ts
new file mode 100644
index 000000000..ff2f9f126
--- /dev/null
+++ b/apps/mobile/src/lib/quick-actions.ts
@@ -0,0 +1,77 @@
+import { requireOptionalNativeModule } from 'expo';
+import { useRouter, type Href } from 'expo-router';
+import { useEffect, useState } from 'react';
+
+import { useAuth } from './auth';
+import { nativeCapabilities } from './native-capabilities';
+
+/**
+ * Home Screen quick actions (a long press on the app icon). The items are
+ * static, declared in Info.plist by app.config.ts (withRound4) with titles in the
+ * device language; expo-quick-actions hands the one the student picked to the
+ * app, at launch or while it runs. Each item's type is looked up here, never
+ * taken as a route. Expo Go and a build without expo-quick-actions have no
+ * module, so the hook does nothing there.
+ */
+export const QUICK_ACTION_ROUTES = {
+  'new-debate': '/new-debate',
+  timer: '/timer',
+  ask: '/ask',
+} as const satisfies Record<string, Href>;
+
+export type QuickActionType = keyof typeof QUICK_ACTION_ROUTES;
+
+// expo-quick-actions sends the item's type as `id`.
+type QuickAction = { id?: string | null };
+type QuickActionsModule = {
+  initial?: QuickAction | null;
+  addListener?: (event: 'onQuickAction', listener: (action: QuickAction) => void) => { remove: () => void };
+};
+
+let initialHandled = false;
+
+function routeFor(action: QuickAction | null | undefined): Href | null {
+  const id = action?.id;
+  if (typeof id !== 'string' || !Object.prototype.hasOwnProperty.call(QUICK_ACTION_ROUTES, id)) return null;
+  return QUICK_ACTION_ROUTES[id as QuickActionType];
+}
+
+/**
+ * Opens the screen of the quick action the app was launched or resumed with.
+ * Call it in the root layout's Root component, before its early return, with
+ * that component's `ready` (fonts, auth and settings loaded, so the stack is
+ * mounted). A picked action waits until then, and until someone is signed
+ * in: the stack only has these routes behind sign-in.
+ */
+export function useQuickActions(ready: boolean): void {
+  const router = useRouter();
+  const { session } = useAuth();
+  const [pending, setPending] = useState<Href | null>(null);
+
+  useEffect(() => {
+    if (!nativeCapabilities().quickActions) return;
+    const native = requireOptionalNativeModule<QuickActionsModule>('ExpoQuickActions');
+    if (!native) return;
+    if (!initialHandled) {
+      initialHandled = true;
+      const route = routeFor(native.initial);
+      if (route) setPending(route);
+    }
+    const subscription = native.addListener?.('onQuickAction', (action) => {
+      const route = routeFor(action);
+      if (route) setPending(route);
+    });
+    return () => subscription?.remove();
+  }, []);
+
+  const signedIn = session !== null;
+  useEffect(() => {
+    if (!pending || !ready || !signedIn) return;
+    // After the stack has committed its first screens, as expo-quick-actions' own router hook does.
+    const timer = setTimeout(() => {
+      setPending(null);
+      router.navigate(pending);
+    }, 0);
+    return () => clearTimeout(timer);
+  }, [pending, ready, signedIn, router]);
+}
diff --git a/apps/mobile/src/lib/result-text.ts b/apps/mobile/src/lib/result-text.ts
index 564c4000c..c6e5f2af4 100644
--- a/apps/mobile/src/lib/result-text.ts
+++ b/apps/mobile/src/lib/result-text.ts
@@ -2,28 +2,40 @@ import type { AttackOutput } from '@debatelab/core/ai/schemas/attack';
 import type { BrainstormOutput } from '@debatelab/core/ai/schemas/brainstorm';
 import type { FactoidsOutput } from '@debatelab/core/ai/schemas/factoids';
 import type { GenerateOutput } from '@debatelab/core/ai/schemas/generate';
+import { readCase, sourceLine } from '@debatelab/core/ai/case-view';
 
 type Translate = (key: string, options?: Record<string, unknown>) => string;
 
 /** A case as plain text, line for line as the website's Clipboard button copies it (GenerateResults). */
 export function caseToText(result: GenerateOutput): string {
+  const view = readCase(result);
   const lines: string[] = [];
-  lines.push(`THESIS: ${result.caseStructure?.thesis || ''}`);
-  lines.push(`FRAMEWORK: ${result.caseStructure?.framework || ''}`);
-  lines.push('');
-  result.contentions?.forEach((c, i) => {
-    lines.push(`CONTENTION #${i + 1}: ${c.claim}`);
-    lines.push(`  Reasoning: ${c.reasoning}`);
-    lines.push(`  Evidence: ${c.evidence}`);
-    lines.push(`  Impact: ${c.impact}`);
-    lines.push('');
+  const block = (title: string, body: string[]) => {
+    if (!body.length) return;
+    if (lines.length) lines.push('');
+    lines.push(title, ...body);
+  };
+  block('OPENING:', [
+    view.opening.hook,
+    view.opening.definition && `What we mean: ${view.opening.definition}`,
+    view.opening.roadmap,
+    view.legacy.framework && `How to judge this debate: ${view.legacy.framework}`,
+    view.legacy.burdenOfProof && `What we have to show: ${view.legacy.burdenOfProof}`,
+  ].filter((line): line is string => Boolean(line)).map((line) => `  ${line}`));
+  view.arguments.forEach((argument, i) => {
+    block(`ARGUMENT ${i + 1}: ${argument.title ?? argument.point}`, [
+      argument.title && argument.point && `  Point: ${argument.point}`,
+      argument.explanation && `  Explanation: ${argument.explanation}`,
+      argument.evidence && `  Evidence: ${argument.evidence}`,
+      argument.whyItMatters && `  Why it matters: ${argument.whyItMatters}`,
+    ].filter((line): line is string => Boolean(line)));
   });
-  if (result.counters?.length) {
-    lines.push('PREPARED COUNTERS:');
-    result.counters.forEach((c) => {
-      lines.push(`  vs "${c.targetArgument}": ${c.counterpoint}`);
-    });
-  }
+  view.reinforce.forEach((item, i) => block(`BACKING UP ${item.argument || `ARGUMENT ${i + 1}`}:`, [`  ${item.text}`]));
+  block('WHY WE WIN:', view.whyWeWin.map((reason, i) => `  ${i + 1}. ${reason}`));
+  block('IF THEY SAY...', view.ifTheySay.map((answer) =>
+    `  "${answer.theySay}" -> ${answer.weAnswer}${answer.inRound ? ` ${answer.inRound}` : ''}${answer.source ? ` (${answer.source})` : ''}`));
+  if (view.closingLine) block('CLOSING LINE:', [`  ${view.closingLine}`]);
+  block('SOURCES:', view.sources.map((source) => `  - ${sourceLine(source)}`));
   return lines.join('\n');
 }
 
@@ -76,7 +88,11 @@ export function discussCaseMessage(result: GenerateOutput): string {
     **Thesis:** ${result.caseStructure.thesis}
 
     **Arguments:**
-    ${result.contentions.map((c, i) => `${i + 1}. ${c.claim}`).join('\n')}
+    ${(result.contentions.length
+      ? result.contentions.map((c, i) => `${i + 1}. ${c.title ?? c.claim}`)
+      : result.reinforce?.length
+        ? result.reinforce.map((item, i) => `${i + 1}. ${item.argument || item.text}`)
+        : (result.whyWeWin ?? []).map((reason, i) => `${i + 1}. ${reason}`)).join('\n')}
 
     Can we refine this?`;
 }
diff --git a/apps/mobile/src/lib/results.test.ts b/apps/mobile/src/lib/results.test.ts
index d9eee394b..3b3461ef8 100644
--- a/apps/mobile/src/lib/results.test.ts
+++ b/apps/mobile/src/lib/results.test.ts
@@ -56,6 +56,11 @@ describe('reading Brainstorm and Factoids output', () => {
     expect(output).toBeNull();
   });
 
+  it('rejects shared brainstorm data the transform cannot read, instead of throwing', () => {
+    // A public share link can hold any JSON; this one breaks String() inside the transform.
+    expect(readBrainstorm({ topFive: [{ idea: { title: { toString: null } } }] })).toBeNull();
+  });
+
   it('rejects a saved factoids row whose factoid does not fit the schema', () => {
     const factoid = {
       id: 'f1',
diff --git a/apps/mobile/src/lib/results.ts b/apps/mobile/src/lib/results.ts
index 5015318e7..f42f69f55 100644
--- a/apps/mobile/src/lib/results.ts
+++ b/apps/mobile/src/lib/results.ts
@@ -8,7 +8,7 @@ import {
 import { transformBrainstormResponse } from '@debatelab/core/ai/brainstorm-output';
 import type { LiveGeneration } from '@debatelab/core/ai/live';
 import { factoidsRequestInput, selectVerifiedFactoids } from '@debatelab/core/ai/factoids-output';
-import { expectedContentionCount, transformGenerateResponse } from '@debatelab/core/ai/generate-output';
+import { hasExpectedArguments, transformGenerateResponse } from '@debatelab/core/ai/generate-output';
 import { AttackOutputSchema, type AttackInput, type AttackOutput } from '@debatelab/core/ai/schemas/attack';
 import { BrainstormOutputSchema, type BrainstormInput, type BrainstormOutput } from '@debatelab/core/ai/schemas/brainstorm';
 import { FactoidsOutputSchema, type FactoidsInput, type FactoidsOutput } from '@debatelab/core/ai/schemas/factoids';
@@ -86,7 +86,7 @@ export function generateCase(input: GenerateInput, options: RequestOptions): Pro
     const parsed = GenerateOutputSchema.safeParse(transformGenerateResponse(output as Record<string, unknown>));
     if (!parsed.success) throw new AIError('failed', 'AI response did not match the expected generate schema.');
     const result = parsed.data;
-    if (result.contentions.length !== expectedContentionCount(input.length)) {
+    if (!hasExpectedArguments(result, input)) {
       throw new AIError('failed', 'AI response did not contain the expected number of contentions.');
     }
     result.metadata.generatedAt = new Date().toISOString();
@@ -309,7 +309,7 @@ export async function deleteResult(userId: string, kind: ResultKind, id: string)
 /** The guard the website's results pages use: an old or broken row shows a notice instead of a crash. */
 export function isCompleteCase(output: unknown): output is GenerateOutput {
   const value = output as Partial<GenerateOutput> | null;
-  return Boolean(value?.caseStructure && Array.isArray(value.contentions) && value.predictedOpponentCase && Array.isArray(value.counters));
+  return Boolean(value?.caseStructure && Array.isArray(value.contentions) && Array.isArray(value.counters));
 }
 
 export function isCompleteAttack(output: unknown): output is AttackOutput {
@@ -324,7 +324,14 @@ export function isCompleteAttack(output: unknown): output is AttackOutput {
  */
 export function readBrainstorm(output: unknown): BrainstormOutput | null {
   if (!output || typeof output !== 'object' || Array.isArray(output)) return null;
-  const parsed = BrainstormOutputSchema.safeParse(transformBrainstormResponse(output as Record<string, unknown>));
+  let normalized: unknown;
+  try {
+    normalized = transformBrainstormResponse(output as Record<string, unknown>);
+  } catch {
+    // The transform reads fields before the schema checks them; data it cannot read is not a brainstorm.
+    return null;
+  }
+  const parsed = BrainstormOutputSchema.safeParse(normalized);
   return parsed.success ? parsed.data : null;
 }
 
diff --git a/apps/mobile/src/lib/session-expiry.test.ts b/apps/mobile/src/lib/session-expiry.test.ts
new file mode 100644
index 000000000..6af79d3ef
--- /dev/null
+++ b/apps/mobile/src/lib/session-expiry.test.ts
@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { clearSessionExpired, sessionExpired, signingOutOnPurpose, watchSessionRemoval } from './session-expiry';
+
+const KEY = 'sb-test-auth-token';
+
+function memoryStorage(initial: Record<string, string> = {}) {
+  const items = new Map(Object.entries(initial));
+  return {
+    getItem: async (key: string) => items.get(key) ?? null,
+    setItem: async (key: string, value: string) => void items.set(key, value),
+    removeItem: async (key: string) => void items.delete(key),
+  };
+}
+
+describe('watchSessionRemoval', () => {
+  beforeEach(() => clearSessionExpired());
+
+  it('marks the session expired when supabase-js removes a stored session by itself (a refused refresh)', async () => {
+    const storage = watchSessionRemoval(memoryStorage({ [KEY]: '{"refresh_token":"r"}' }), KEY);
+    await storage.removeItem(KEY);
+    expect(sessionExpired()).toBe(true);
+  });
+
+  it('says nothing on a signed-out launch, where supabase-js removes a key that holds no session', async () => {
+    const storage = watchSessionRemoval(memoryStorage(), KEY);
+    await storage.removeItem(KEY);
+    expect(sessionExpired()).toBe(false);
+  });
+
+  it('says nothing when the student signs out, and ignores other keys', async () => {
+    const storage = watchSessionRemoval(memoryStorage({ [KEY]: 'session', [`${KEY}-code-verifier`]: 'v' }), KEY);
+    await signingOutOnPurpose(async () => {
+      await storage.removeItem(KEY);
+    });
+    await storage.removeItem(`${KEY}-code-verifier`);
+    expect(sessionExpired()).toBe(false);
+  });
+
+  it('clears the notice when a new session is stored', async () => {
+    const storage = watchSessionRemoval(memoryStorage({ [KEY]: 'old' }), KEY);
+    await storage.removeItem(KEY);
+    await storage.setItem(KEY, 'new');
+    expect(sessionExpired()).toBe(false);
+  });
+});
diff --git a/apps/mobile/src/lib/session-expiry.ts b/apps/mobile/src/lib/session-expiry.ts
new file mode 100644
index 000000000..42097d0a6
--- /dev/null
+++ b/apps/mobile/src/lib/session-expiry.ts
@@ -0,0 +1,62 @@
+import type { SupportedStorage } from '@supabase/supabase-js';
+
+/**
+ * Tells a session the server ended from one the student signed out of, for
+ * the sign-in screen's "Your session expired" notice (the website's
+ * src/lib/supabase/session-expiry.ts). supabase-js removes the stored session
+ * itself when the server refuses its refresh token, and it can do that while
+ * the app is still loading, before any React code listens. So the notice is
+ * decided where the removal happens: in the storage the client writes to.
+ * A removal counts only when a session was stored, because supabase-js also
+ * removes the key on every launch that has none.
+ */
+
+let signingOut = 0;
+let expired = false;
+const listeners = new Set<(expired: boolean) => void>();
+
+function set(next: boolean) {
+  if (expired === next) return;
+  expired = next;
+  listeners.forEach((listener) => listener(next));
+}
+
+/** Wraps the session storage so a removal nobody asked for marks the session expired. */
+export function watchSessionRemoval(storage: SupportedStorage, sessionKey: string): SupportedStorage {
+  return {
+    getItem: (key) => storage.getItem(key),
+    setItem: async (key, value) => {
+      await storage.setItem(key, value);
+      // A new session (a sign-in) clears the notice.
+      if (key === sessionKey) set(false);
+    },
+    removeItem: async (key) => {
+      const had = key === sessionKey && signingOut === 0 ? (await storage.getItem(key)) !== null : false;
+      await storage.removeItem(key);
+      if (had) set(true);
+    },
+  };
+}
+
+/** Runs a sign-out the student asked for (or Delete account); its removal is not an expiry. */
+export async function signingOutOnPurpose<T>(work: () => Promise<T>): Promise<T> {
+  signingOut += 1;
+  try {
+    return await work();
+  } finally {
+    signingOut -= 1;
+  }
+}
+
+export function sessionExpired(): boolean {
+  return expired;
+}
+
+export function clearSessionExpired() {
+  set(false);
+}
+
+export function subscribeSessionExpired(listener: (expired: boolean) => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
diff --git a/apps/mobile/src/lib/share-links.ts b/apps/mobile/src/lib/share-links.ts
new file mode 100644
index 000000000..b391303a6
--- /dev/null
+++ b/apps/mobile/src/lib/share-links.ts
@@ -0,0 +1,150 @@
+import { fetch } from 'expo/fetch';
+
+import { payloadOf } from './ai-request';
+import { sessionSlot } from './session-memory';
+import { supabase } from './supabase';
+import { supabaseProject } from './supabase-config';
+
+/**
+ * Share links for saved results, through the `share` Edge Function: a POST
+ * with the signed-in user's token and { itemType, itemData, title } returns
+ * { shareCode, shareUrl, expiresAt }. Every POST makes a new link and counts
+ * against the daily share limit, and the function never returns an existing
+ * one, so the app reuses a link it made this session for the same saved row
+ * while the shared content is unchanged and the link has not expired.
+ * Anyone can read a link back with the `get_shared_item` RPC (`readSharedItem`).
+ */
+
+export type ShareKind = 'case' | 'attack' | 'brainstorm' | 'factoids';
+
+export type ShareFailure = 'signIn' | 'limit' | 'tooLarge' | 'timeout' | 'failed';
+
+export class ShareLinkError extends Error {
+  constructor(readonly failure: ShareFailure, message: string, readonly limit?: number) {
+    super(message);
+    this.name = 'ShareLinkError';
+  }
+}
+
+export interface ShareLink {
+  url: string;
+  expiresAt: string | null;
+  /** False when the link was made earlier this session and is reused. */
+  created: boolean;
+}
+
+interface KeptLink {
+  data: string;
+  url: string;
+  expiresAt: string | null;
+}
+
+const REQUEST_TIMEOUT_MS = 15_000;
+/** A reused link has at least this long to live, so a recipient can still open it. */
+const REUSE_MARGIN_MS = 24 * 60 * 60 * 1000;
+
+// Session memory: forgotten whenever the account changes.
+const kept = sessionSlot(() => new Map<string, KeptLink>());
+const pending = sessionSlot(() => new Map<string, Promise<ShareLink>>());
+
+function stillValid(link: KeptLink, now: number): boolean {
+  if (!link.expiresAt) return true;
+  const expires = Date.parse(link.expiresAt);
+  return Number.isFinite(expires) && expires - now > REUSE_MARGIN_MS;
+}
+
+async function postShare(userId: string, body: { itemType: ShareKind; itemData: unknown; title: string }): Promise<{ url: string; expiresAt: string | null }> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const { data } = await supabase.auth.getSession();
+    const session = data.session;
+    if (!session || session.user.id !== userId) throw new ShareLinkError('signIn', 'Not signed in as the owner');
+    const response = await fetch(`${supabaseProject.url}/functions/v1/share`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${session.access_token}`, apikey: supabaseProject.anonKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    const payload = await payloadOf(response);
+    if (!response.ok) {
+      const message = typeof payload?.error === 'string' ? payload.error : `Request failed: ${response.status}`;
+      if (response.status === 401) throw new ShareLinkError('signIn', message);
+      if (response.status === 429 || payload?.code === 'limit_reached') {
+        throw new ShareLinkError('limit', message, typeof payload?.limit === 'number' ? payload.limit : undefined);
+      }
+      if (response.status === 413 || payload?.code === 'payload_too_large') throw new ShareLinkError('tooLarge', message);
+      throw new ShareLinkError('failed', message);
+    }
+    const url = payload?.shareUrl;
+    if (typeof url !== 'string' || !/^https?:\/\//i.test(url)) throw new ShareLinkError('failed', 'The share response had no link');
+    return { url, expiresAt: typeof payload?.expiresAt === 'string' ? payload.expiresAt : null };
+  } catch (error) {
+    if (controller.signal.aborted) throw new ShareLinkError('timeout', 'The request took too long');
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * A link to a saved result for `userId`. `itemData` is the result as its
+ * document shows it, in the shape the website's share page reads.
+ */
+export function shareLinkFor(userId: string, kind: ShareKind, savedId: string, title: string, itemData: unknown): Promise<ShareLink> {
+  const data = JSON.stringify(itemData);
+  const key = `${kind}:${savedId}`;
+  const links = kept.get();
+  const known = links.get(key);
+  if (known && known.data === data && stillValid(known, Date.now())) {
+    return Promise.resolve({ url: known.url, expiresAt: known.expiresAt, created: false });
+  }
+  // A second tap while the first request runs waits for the same link.
+  const inFlight = pending.get();
+  const waitKey = `${key}:${data}`;
+  const running = inFlight.get(waitKey);
+  if (running) return running.then((link) => ({ ...link, created: false }));
+
+  const request = postShare(userId, { itemType: kind, itemData, title })
+    .then((link) => {
+      // The maps belong to the account that asked; after an account change they are no longer read.
+      links.set(key, { data, url: link.url, expiresAt: link.expiresAt });
+      return { ...link, created: true };
+    })
+    .finally(() => {
+      inFlight.delete(waitKey);
+    });
+  inFlight.set(waitKey, request);
+  return request;
+}
+
+export interface SharedItem {
+  itemType: string;
+  itemData: unknown;
+  title: string;
+  createdAt: string;
+}
+
+export type SharedRead = { status: 'found'; item: SharedItem } | { status: 'missing' } | { status: 'failed' };
+
+/** A shared item, as the website's SharedPage reads it: public, so it works signed out. A missing or expired code has no row. */
+export async function readSharedItem(code: string): Promise<SharedRead> {
+  try {
+    const { data, error, status } = await supabase.rpc('get_shared_item', { p_share_code: code }).maybeSingle();
+    // No answer (offline, timeout) or a server error is a failed read, not a missing link.
+    if (error) return status === 0 || status >= 500 ? { status: 'failed' } : { status: 'missing' };
+    const row = data as { item_type?: unknown; item_data?: unknown; title?: unknown; created_at?: unknown } | null;
+    if (!row || typeof row.item_type !== 'string') return { status: 'missing' };
+    return {
+      status: 'found',
+      item: {
+        itemType: row.item_type,
+        itemData: row.item_data,
+        title: typeof row.title === 'string' ? row.title : '',
+        createdAt: typeof row.created_at === 'string' ? row.created_at : '',
+      },
+    };
+  } catch {
+    return { status: 'failed' };
+  }
+}
diff --git a/apps/mobile/src/lib/source-actions.ts b/apps/mobile/src/lib/source-actions.ts
index 5380424c3..6b42b8e4f 100644
--- a/apps/mobile/src/lib/source-actions.ts
+++ b/apps/mobile/src/lib/source-actions.ts
@@ -6,8 +6,8 @@ import { folderLabel } from '@/components/source-display';
 import { useAuth } from './auth';
 import { copyText, shareText } from './export';
 import { haptics } from './haptics';
-import { isKnownOffline } from './network-status';
-import { addSource, removeSource, setSourcesActive, updateSource, type Source } from './sources';
+import { cancelQueuedSource, isLocalSourceId, queueAddSource, queueSetSourcesActive, queueUpdateSource } from './offline-queue';
+import { addSource, removeSource, type Source } from './sources';
 
 /** A source as plain text: its title, where it came from, and its text, as the website copies it. */
 export function sourceText(source: Pick<Source, 'title' | 'content' | 'origin'>, withOrigin = false): string {
@@ -17,8 +17,9 @@ export function sourceText(source: Pick<Source, 'title' | 'content' | 'origin'>,
 /**
  * What the Library does to one source, with the website's messages: delete
  * at once with Undo, switch it on or off for the AI, move it, copy or share it.
- * A change that does not reach the server never looks saved; the caller puts
- * the row back when a write resolves false.
+ * Switches and moves go through the offline queue: offline they wait for the
+ * connection and still count as made. A change the server refuses never looks
+ * saved; the caller puts the row back when a write resolves false.
  */
 export function useSourceActions() {
   const { t } = useTranslation();
@@ -26,15 +27,32 @@ export function useSourceActions() {
   const { session } = useAuth();
   const userId = session?.user.id ?? null;
 
-  /** Offline, nothing is written, so the change is refused up front, as on the website. */
-  const refuseOffline = useCallback((title: string) => {
-    if (!isKnownOffline()) return false;
-    toast({ tone: 'error', title, message: t('libraryPage.offlineNotSaved') });
+  /** A note that has not reached the server is taken out of the queue; Undo queues it again. */
+  const removeQueued = useCallback((source: Source): boolean => {
+    if (!userId || !source.debateId) return false;
+    if (!cancelQueuedSource(userId, source.id)) {
+      // On its way to the server right now; once it has synced it deletes as any source does.
+      toast({ tone: 'error', title: t('common.error'), message: t('libraryPage.deleteFailed') });
+      return false;
+    }
+    haptics.success();
+    toast({
+      title: t('libraryPage.sourceDeletedTitle', { title: source.title }),
+      action: {
+        label: t('common.undo'),
+        onPress: () => {
+          queueAddSource(userId, { title: source.title, content: source.content, type: source.type, origin: source.origin, folder: source.folder, isActive: source.isActive, debateId: source.debateId! })
+            .then(() => haptics.success())
+            .catch(() => toast({ tone: 'error', title: t('libraryPage.restoreFailed') }));
+        },
+      },
+    });
     return true;
-  }, [t, toast]);
+  }, [t, toast, userId]);
 
   const remove = useCallback(async (source: Source): Promise<boolean> => {
     if (!userId || !source.debateId) return false;
+    if (isLocalSourceId(source.id)) return removeQueued(source);
     try {
       await removeSource(userId, source.id, source.debateId);
     } catch (cause) {
@@ -67,36 +85,36 @@ export function useSourceActions() {
       },
     });
     return true;
-  }, [t, toast, userId]);
+  }, [removeQueued, t, toast, userId]);
 
   const setActive = useCallback(async (sources: Source[], isActive: boolean, folder?: string): Promise<boolean> => {
     const failedTitle = folder ? t('libraryPage.folderUpdateFailed') : t('libraryPage.toggleFailed');
     const debateId = sources[0]?.debateId;
     if (!userId || !debateId) return false;
-    if (refuseOffline(t('libraryPage.offlineTitle'))) return false;
     try {
-      await setSourcesActive(userId, debateId, sources.map((source) => source.id), isActive);
+      await queueSetSourcesActive(userId, debateId, sources.map((source) => source.id), isActive);
       return true;
     } catch (cause) {
       console.warn('Could not change the source:', cause instanceof Error ? cause.message : cause);
-      toast({ tone: 'error', title: failedTitle, message: isKnownOffline() ? t('libraryPage.offlineNotSaved') : t('libraryPage.toggleFailedDesc') });
+      toast({ tone: 'error', title: failedTitle, message: t('libraryPage.toggleFailedDesc') });
       return false;
     }
-  }, [refuseOffline, t, toast, userId]);
+  }, [t, toast, userId]);
 
   const move = useCallback(async (source: Source, folder: string): Promise<boolean> => {
     if (!userId || !source.debateId || folder === source.folder) return false;
-    if (refuseOffline(t('libraryPage.saveFailed'))) return false;
     try {
-      await updateSource(userId, source.debateId, source.id, { folder });
-      toast({ tone: 'success', title: t('libraryPage.sourceUpdated'), message: `${t('libraryPage.folder')}: ${folderLabel(t, folder)}` });
+      const status = await queueUpdateSource(userId, source.debateId, source.id, { folder });
+      toast(status === 'saved'
+        ? { tone: 'success', title: t('libraryPage.sourceUpdated'), message: `${t('libraryPage.folder')}: ${folderLabel(t, folder)}` }
+        : { tone: 'info', title: t('mobile.offlineQueue.changeQueuedTitle'), message: t('mobile.offlineQueue.changeQueuedDesc') });
       return true;
     } catch (cause) {
       console.warn('Could not move the source:', cause instanceof Error ? cause.message : cause);
       toast({ tone: 'error', title: t('libraryPage.saveFailed') });
       return false;
     }
-  }, [refuseOffline, t, toast, userId]);
+  }, [t, toast, userId]);
 
   const copy = useCallback(async (source: Source) => {
     try {
diff --git a/apps/mobile/src/lib/sources.ts b/apps/mobile/src/lib/sources.ts
index c4690ea60..5904e7f99 100644
--- a/apps/mobile/src/lib/sources.ts
+++ b/apps/mobile/src/lib/sources.ts
@@ -153,8 +153,9 @@ export async function addSource(
   const folderResult = await supabase
     .from('source_folders')
     .upsert({ user_id: userId, name: folder }, { onConflict: 'user_id,name' });
-  if (folderResult.error) throw new Error(folderResult.error.message);
-  const { data, error } = await supabase
+  // A write that got no answer throws readFailed's unreachable error, so the offline queue keeps it.
+  if (folderResult.error) throw readFailed(folderResult.error, folderResult.status);
+  const { data, error, status } = await supabase
     .from('sources')
     .insert({
       ...(input.id ? { id: input.id, created_at: new Date(input.createdAt ?? Date.now()).toISOString() } : {}),
@@ -171,7 +172,8 @@ export async function addSource(
     .select(SOURCE_COLUMNS)
     .single();
   if (error?.code === '23505') throw new DuplicateSourceError();
-  if (error || !data) throw new Error(error?.message ?? 'Could not save the source');
+  if (error) throw readFailed(error, status);
+  if (!data) throw new Error('Could not save the source');
   afterWrite(userId, [{ group: 'sources', key: input.debateId }, FOLDER_COPIES, ...debateListScopes(input.debateId, 'source')]);
   notifySourcesChanged();
   return fromRow(data as SourceRow);
@@ -271,8 +273,8 @@ async function loadFolders(userId: string, debateId: string): Promise<string[]>
 }
 
 async function saveFolderName(userId: string, name: string) {
-  const { error } = await supabase.from('source_folders').upsert({ user_id: userId, name }, { onConflict: 'user_id,name' });
-  if (error) throw new Error(error.message);
+  const { error, status } = await supabase.from('source_folders').upsert({ user_id: userId, name }, { onConflict: 'user_id,name' });
+  if (error) throw readFailed(error, status);
 }
 
 /** Saves an empty folder, as the website's New folder does. */
@@ -351,8 +353,8 @@ export function setSourcesActive(userId: string, debateId: string, ids: string[]
   if (ids.length === 0) return Promise.resolve();
   activePending += 1;
   return activeWrites(async () => {
-    const { error } = await supabase.from('sources').update({ is_active: isActive }).eq('user_id', userId).eq('debate_id', debateId).in('id', ids);
-    if (error) throw new Error(error.message);
+    const { error, status } = await supabase.from('sources').update({ is_active: isActive }).eq('user_id', userId).eq('debate_id', debateId).in('id', ids);
+    if (error) throw readFailed(error, status);
     afterWrite(userId, [{ group: 'sources', key: debateId }, ...ids.map((id) => ({ group: 'source' as const, key: id }))]);
   }).finally(() => {
     activePending -= 1;
@@ -377,8 +379,8 @@ export async function updateSource(userId: string, debateId: string, id: string,
   if (Object.keys(row).length === 0) return;
   const write = async () => {
     if (typeof row.folder === 'string') await saveFolderName(userId, row.folder);
-    const { error } = await supabase.from('sources').update(row).eq('user_id', userId).eq('debate_id', debateId).eq('id', id);
-    if (error) throw new Error(error.message);
+    const { error, status } = await supabase.from('sources').update(row).eq('user_id', userId).eq('debate_id', debateId).eq('id', id);
+    if (error) throw readFailed(error, status);
   };
   await (patch.isActive !== undefined ? activeWrites(write) : write());
   afterWrite(userId, [{ group: 'sources', key: debateId }, { group: 'source', key: id }, ...(row.folder ? [FOLDER_COPIES] : [])]);
@@ -460,6 +462,7 @@ export function subscribeSourcesChanged(listener: () => void): () => void {
   };
 }
 
-function notifySourcesChanged() {
+/** Screens showing sources read them again; the offline queue calls it when the server refuses a queued change. */
+export function notifySourcesChanged() {
   listeners.forEach((listener) => listener());
 }
diff --git a/apps/mobile/src/lib/spotlight.ts b/apps/mobile/src/lib/spotlight.ts
new file mode 100644
index 000000000..b397f71db
--- /dev/null
+++ b/apps/mobile/src/lib/spotlight.ts
@@ -0,0 +1,72 @@
+import { requireOptionalNativeModule } from 'expo';
+
+import { nativeCapabilities } from './native-capabilities';
+
+/**
+ * Spotlight search for debates and saved cases, through expo-core-spotlight
+ * (2.x is the line for SDK 56 and 57; it needs its config plugin, which
+ * app.config.ts adds once the package is installed). It is reached
+ * by its native module name, so nothing here loads in Expo Go, on the web or
+ * in a build without the package: there every call is a no-op.
+ *
+ * The Debate tab indexes the Current Debate's cases and the debate context
+ * clears the index on sign-out. TODO(spotlight): install expo-core-spotlight@^2
+ * for the development build, and clear the index after Delete all my data.
+ */
+
+/** One searchable item. Its URL is also its Spotlight identifier, which the package opens when the result is tapped. */
+export type SpotlightItem = {
+  /** An app link, such as `debatelab://case/<id>`. */
+  url: `debatelab://${string}`;
+  title: string;
+  description?: string;
+  keywords?: string[];
+};
+
+export type SpotlightDomain = 'debates' | 'cases';
+
+type CoreSpotlightModule = {
+  indexItems: (items: Record<string, unknown>[]) => Promise<void>;
+  removeAllItemsFromDomain: (domain: string) => Promise<void>;
+  removeAllItems: () => Promise<void>;
+};
+
+const domainId = (domain: SpotlightDomain) => `com.adam.debatelab.${domain}`;
+
+function spotlight(): CoreSpotlightModule | null {
+  if (!nativeCapabilities().spotlight) return null;
+  return requireOptionalNativeModule<CoreSpotlightModule>('ExpoCoreSpotlight');
+}
+
+/** Replaces everything indexed for one domain with these items, so deleted debates and cases leave Spotlight too. */
+export async function indexForSpotlight(domain: SpotlightDomain, items: SpotlightItem[]): Promise<void> {
+  const native = spotlight();
+  if (!native) return;
+  try {
+    await native.removeAllItemsFromDomain(domainId(domain));
+    if (items.length === 0) return;
+    await native.indexItems(
+      items.map((item) => ({
+        uniqueIdentifier: item.url,
+        url: item.url,
+        title: item.title,
+        contentDescription: item.description,
+        keywords: item.keywords,
+        domainIdentifier: domainId(domain),
+      })),
+    );
+  } catch (cause) {
+    console.warn('Could not update Spotlight:', cause instanceof Error ? cause.message : cause);
+  }
+}
+
+/** Removes every item this app indexed: one account's debates must not show in Spotlight for the next. */
+export async function clearSpotlight(): Promise<void> {
+  const native = spotlight();
+  if (!native) return;
+  try {
+    await native.removeAllItems();
+  } catch (cause) {
+    console.warn('Could not clear Spotlight:', cause instanceof Error ? cause.message : cause);
+  }
+}
diff --git a/apps/mobile/src/lib/supabase.ts b/apps/mobile/src/lib/supabase.ts
index 2dc213d2b..c582bda65 100644
--- a/apps/mobile/src/lib/supabase.ts
+++ b/apps/mobile/src/lib/supabase.ts
@@ -4,11 +4,13 @@ import { createClient } from '@supabase/supabase-js';
 import { AppState } from 'react-native';
 
 import { sessionStorage } from './device-storage';
+import { watchSessionRemoval } from './session-expiry';
 import { sessionStorageKey, supabaseProject } from './supabase-config';
 
 export const supabase = createClient(supabaseProject.url, supabaseProject.anonKey, {
   auth: {
-    storage: sessionStorage,
+    // A session the server ends is told apart from a sign-out here (session-expiry.ts).
+    storage: watchSessionRemoval(sessionStorage, sessionStorageKey),
     storageKey: sessionStorageKey,
     autoRefreshToken: true,
     persistSession: true,
diff --git a/apps/mobile/src/lib/supabase.web.ts b/apps/mobile/src/lib/supabase.web.ts
index a9cba68ae..0345f69a4 100644
--- a/apps/mobile/src/lib/supabase.web.ts
+++ b/apps/mobile/src/lib/supabase.web.ts
@@ -1,12 +1,14 @@
 import { createClient } from '@supabase/supabase-js';
 
 import { sessionStorage } from './device-storage';
+import { watchSessionRemoval } from './session-expiry';
 import { sessionStorageKey, supabaseProject } from './supabase-config';
 
 // In a browser supabase-js refreshes on tab visibility by itself.
 export const supabase = createClient(supabaseProject.url, supabaseProject.anonKey, {
   auth: {
-    storage: sessionStorage,
+    // A session the server ends is told apart from a sign-out here (session-expiry.ts).
+    storage: watchSessionRemoval(sessionStorage, sessionStorageKey),
     storageKey: sessionStorageKey,
     autoRefreshToken: true,
     persistSession: true,
diff --git a/apps/mobile/src/lib/use-first-run.ts b/apps/mobile/src/lib/use-first-run.ts
new file mode 100644
index 000000000..a67cb01a4
--- /dev/null
+++ b/apps/mobile/src/lib/use-first-run.ts
@@ -0,0 +1,25 @@
+import { useRootNavigationState, useRouter } from 'expo-router';
+import { useEffect } from 'react';
+
+import { firstRunPlan } from './first-run';
+
+/**
+ * Opens the first run once the app's navigation is ready: Ollie's welcome when
+ * this phone has not seen it, then the tour when this account has not
+ * finished it (the website's FirstRun). Once per signed-in account per launch.
+ */
+export function useFirstRun(userId: string | null) {
+  const router = useRouter();
+  const ready = Boolean(useRootNavigationState()?.key);
+  useEffect(() => {
+    if (!userId || !ready) return;
+    let live = true;
+    void firstRunPlan(userId).then((plan) => {
+      if (!live || (!plan.showIntro && plan.tourDone)) return;
+      router.push({ pathname: '/welcome', params: { intro: plan.showIntro ? '1' : '0', tour: plan.tourDone ? 'done' : 'todo' } });
+    });
+    return () => {
+      live = false;
+    };
+  }, [userId, ready, router]);
+}
diff --git a/apps/mobile/src/lib/use-offline-queue.ts b/apps/mobile/src/lib/use-offline-queue.ts
new file mode 100644
index 000000000..489280b89
--- /dev/null
+++ b/apps/mobile/src/lib/use-offline-queue.ts
@@ -0,0 +1,96 @@
+import { useEffect, useSyncExternalStore } from 'react';
+import { useTranslation } from 'react-i18next';
+import { AppState } from 'react-native';
+
+import { useToast } from '@/components/toast';
+import { useAuth } from './auth';
+import { useOfflineStatus } from './network-status';
+import {
+  getQueueSnapshot,
+  replayOfflineQueue,
+  setQueueOwner,
+  subscribeQueue,
+  subscribeQueueReports,
+  subscribeStorageTrouble,
+  waitingCount,
+  type QueueSnapshot,
+} from './offline-queue';
+
+/** How often a queue that still waits tries again while the device says it is online (a captive portal, a server that did not answer). */
+const RETRY_MS = 30_000;
+
+const EMPTY: QueueSnapshot = { owner: null, items: [], synced: new Map() };
+
+/** The offline queue of this account, for drawing queued changes; empty for any other account. */
+export function useQueuedWrites(userId: string | null): QueueSnapshot {
+  const state = useSyncExternalStore(subscribeQueue, getQueueSnapshot, getQueueSnapshot);
+  return userId && state.owner === userId ? state : EMPTY;
+}
+
+/**
+ * Runs the offline queue for the signed-in account: names its owner once auth
+ * has settled (another account's queue is removed), sends it on launch, when
+ * the connection returns and when the app comes to the foreground, and says in
+ * one toast what a replay saved or what the server refused.
+ * Call it once, in the root layout, inside AuthProvider and ToastProvider.
+ */
+export function useOfflineQueue(): void {
+  const { t } = useTranslation();
+  const toast = useToast();
+  const { session, loading, settled } = useAuth();
+  const { offline } = useOfflineStatus();
+  const userId = session?.user.id ?? null;
+  const queued = useQueuedWrites(userId);
+  const waiting = waitingCount(queued) > 0;
+
+  // The stored session is read before auth settles; until then the account is unknown, not signed out.
+  // No session counts as signed out (which removes stored queues) only once auth has settled: an early
+  // read that failed must not delete an account's unsynced work.
+  useEffect(() => {
+    if (loading || (!userId && !settled)) return;
+    setQueueOwner(userId);
+    if (userId) void replayOfflineQueue();
+  }, [loading, settled, userId]);
+
+  useEffect(() => {
+    if (!loading && userId && !offline) void replayOfflineQueue();
+  }, [loading, userId, offline]);
+
+  useEffect(() => {
+    const subscription = AppState.addEventListener('change', (state) => {
+      if (state === 'active') void replayOfflineQueue();
+    });
+    return () => subscription.remove();
+  }, []);
+
+  useEffect(() => {
+    if (!waiting || offline) return;
+    const timer = setInterval(() => void replayOfflineQueue(), RETRY_MS);
+    return () => clearInterval(timer);
+  }, [waiting, offline]);
+
+  useEffect(
+    () =>
+      subscribeQueueReports(({ synced, dropped }) => {
+        if (dropped.length > 0) {
+          const [first] = dropped;
+          const message = dropped.length === 1 && first.kind === 'add' && first.title
+            ? t('mobile.offlineQueue.noteRefused', { title: first.title })
+            : t('mobile.offlineQueue.refusedDesc', { count: dropped.length });
+          toast({ tone: 'error', title: t('mobile.offlineQueue.refusedTitle', { count: dropped.length }), message });
+          return;
+        }
+        if (synced > 0) toast({ tone: 'success', title: t('mobile.offlineQueue.synced', { count: synced }) });
+      }),
+    [t, toast],
+  );
+
+  // The phone could not store the queue: changes still sync while the app stays open.
+  useEffect(
+    () =>
+      subscribeStorageTrouble(() =>
+        toast({ tone: 'error', title: t('mobile.offlineQueue.notKeptTitle'), message: t('mobile.offlineQueue.notKeptDesc') }),
+      ),
+    [t, toast],
+  );
+}
diff --git a/apps/mobile/src/lib/use-share-link.ts b/apps/mobile/src/lib/use-share-link.ts
new file mode 100644
index 000000000..e0e47875b
--- /dev/null
+++ b/apps/mobile/src/lib/use-share-link.ts
@@ -0,0 +1,77 @@
+import type { TFunction } from 'i18next';
+import { useCallback, useEffect, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import type { NoticeTone } from '@/components/document';
+
+import { useAuth } from './auth';
+import { copyText, shareUrl } from './export';
+import { haptics } from './haptics';
+import { ShareLinkError, shareLinkFor, type ShareKind } from './share-links';
+
+function failureText(t: TFunction, cause: unknown): string {
+  if (!(cause instanceof ShareLinkError)) return t('mobile.share.failed');
+  switch (cause.failure) {
+    case 'signIn':
+      return t('mobile.share.signIn');
+    case 'limit':
+      return t('mobile.share.limitReached', { limit: cause.limit ?? 50 });
+    case 'tooLarge':
+      return t('mobile.share.tooLarge');
+    case 'timeout':
+      return t('mobile.share.timeout');
+    default:
+      return t('mobile.share.failed');
+  }
+}
+
+/**
+ * A saved document's "Share link": make (or reuse) the link, then open the
+ * share sheet with it. When the sheet cannot open, the link is copied instead.
+ * Outcomes show in the document's own notice, which sits above its pinned
+ * buttons; the toast would sit on them.
+ */
+export function useShareLink(setNotice: (text: string, tone?: NoticeTone) => void) {
+  const { t } = useTranslation();
+  const { session } = useAuth();
+  const userId = session?.user.id ?? null;
+  const owner = useRef(userId);
+  const busy = useRef(false);
+  useEffect(() => {
+    owner.current = userId;
+  }, [userId]);
+
+  return useCallback(
+    async (kind: ShareKind, savedId: string, title: string, itemData: unknown) => {
+      if (!userId || busy.current) return;
+      const forUser = userId;
+      busy.current = true;
+      let url: string;
+      try {
+        const link = await shareLinkFor(forUser, kind, savedId, title, itemData);
+        url = link.url;
+        if (owner.current !== forUser) return;
+        if (link.created) haptics.success();
+      } catch (cause) {
+        console.warn('Could not create a share link:', cause instanceof Error ? cause.message : cause);
+        if (owner.current !== forUser) return;
+        haptics.warning();
+        setNotice(failureText(t, cause));
+        return;
+      } finally {
+        busy.current = false;
+      }
+      try {
+        await shareUrl(title, url);
+      } catch {
+        try {
+          await copyText(url);
+          setNotice(t('mobile.share.linkCopied'), 'success');
+        } catch {
+          setNotice(t('mobile.share.failed'));
+        }
+      }
+    },
+    [setNotice, t, userId],
+  );
+}
diff --git a/apps/mobile/src/lib/website.ts b/apps/mobile/src/lib/website.ts
index 28ddd26ae..826f8daa9 100644
--- a/apps/mobile/src/lib/website.ts
+++ b/apps/mobile/src/lib/website.ts
@@ -10,3 +10,8 @@ const websiteUrl = (Constants.expoConfig?.extra as { websiteUrl?: string } | und
 export function websitePage(path: '/terms' | '/privacy'): string {
   return `${websiteUrl}${path}`;
 }
+
+/** A shared item on the website, for when the app cannot show it. */
+export function websiteShareUrl(code: string): string {
+  return `${websiteUrl}/share/${encodeURIComponent(code)}`;
+}
diff --git a/apps/mobile/src/theme/font-scale.ts b/apps/mobile/src/theme/font-scale.ts
new file mode 100644
index 000000000..4c4ecf26f
--- /dev/null
+++ b/apps/mobile/src/theme/font-scale.ts
@@ -0,0 +1,4 @@
+/** iOS scales text itself (Dynamic Type), so the native app adds nothing. See font-scale.web.ts. */
+export function webFontScale(): number {
+  return 1;
+}
diff --git a/apps/mobile/src/theme/font-scale.web.ts b/apps/mobile/src/theme/font-scale.web.ts
new file mode 100644
index 000000000..09e7943e3
--- /dev/null
+++ b/apps/mobile/src/theme/font-scale.web.ts
@@ -0,0 +1,11 @@
+/**
+ * react-native-web ignores the system text size, so the screenshot script
+ * sets `window.__debateowlFontScale` before the app loads to draw a Dynamic
+ * Type size (3.1 is iOS's largest accessibility size for body text). Text and
+ * fields multiply their font sizes by it, capped by maxFontSizeMultiplier as
+ * on iOS.
+ */
+export function webFontScale(): number {
+  const scale = (window as unknown as { __debateowlFontScale?: unknown }).__debateowlFontScale;
+  return typeof scale === 'number' && scale > 0 ? scale : 1;
+}
diff --git a/apps/mobile/src/theme/motion.ts b/apps/mobile/src/theme/motion.ts
new file mode 100644
index 000000000..9042dd555
--- /dev/null
+++ b/apps/mobile/src/theme/motion.ts
@@ -0,0 +1,84 @@
+import { useEffect, useState } from 'react';
+import { AccessibilityInfo } from 'react-native';
+import { Easing, ReduceMotion, useReducedMotion as useStartupReducedMotion } from 'react-native-reanimated';
+
+/**
+ * The website's motion tokens (src/styles/tokens.css, `--do-dur-*` and `--do-ease-*`) for
+ * Reanimated. Everything runs on the UI thread; under Reduce Motion each component settles
+ * at once (useReduceMotion below; layout animations follow the system setting).
+ */
+export const DURATION = {
+  instant: 70,
+  quick: 120,
+  fast: 180,
+  base: 240,
+  moderate: 320,
+  slow: 450,
+  deliberate: 600,
+  celebrate: 1400,
+  ambient: 2400,
+} as const;
+
+export const EASE = {
+  standard: Easing.bezier(0.2, 0, 0, 1),
+  decelerate: Easing.bezier(0, 0, 0.2, 1),
+  accelerate: Easing.bezier(0.3, 0, 1, 1),
+  overshoot: Easing.bezier(0.34, 1.56, 0.64, 1),
+  press: Easing.bezier(0.3, 0, 0.5, 1),
+} as const;
+
+/** Springs: `pop` is the website's (framer-motion stiffness 420, damping 22); `press` snaps a button down and back. */
+export const SPRING = {
+  pop: { stiffness: 420, damping: 22, mass: 1 },
+  press: { stiffness: 1100, damping: 38, mass: 0.6 },
+  settle: { stiffness: 260, damping: 24, mass: 1 },
+} as const;
+
+/** Rows arrive one after another, 40 ms apart, and never more than eight steps late. */
+export function staggerDelay(index: number): number {
+  return Math.min(Math.max(index, 0), 8) * 40;
+}
+
+// The setting as last reported, shared by every component, so one mounted later starts from it.
+let latest: boolean | null = null;
+const listeners = new Set<(reduce: boolean) => void>();
+let watching = false;
+
+function watch() {
+  if (watching) return;
+  watching = true;
+  const report = (reduce: boolean) => {
+    if (latest === reduce) return;
+    latest = reduce;
+    listeners.forEach((listener) => listener(reduce));
+  };
+  AccessibilityInfo.addEventListener('reduceMotionChanged', report);
+  void AccessibilityInfo.isReduceMotionEnabled().then(report, () => undefined);
+}
+
+/**
+ * Whether Reduce Motion is on, kept current while the app runs. It starts from Reanimated's
+ * reading at launch (synchronous, so a first frame never animates by mistake) and follows the
+ * setting when the student changes it in Settings, which Reanimated's own hook does not.
+ */
+export function useReduceMotion(): boolean {
+  const startup = useStartupReducedMotion();
+  const [reduce, setReduce] = useState(() => latest ?? startup);
+  useEffect(() => {
+    watch();
+    listeners.add(setReduce);
+    if (latest !== null) setReduce(latest);
+    return () => {
+      listeners.delete(setReduce);
+    };
+  }, []);
+  return reduce;
+}
+
+/**
+ * For layout animations (entering, exiting, layout): Reanimated's default follows the setting it
+ * read at launch, so each one is told the live setting from useReduceMotion instead.
+ */
+export function motionSetting(reduce: boolean): ReduceMotion {
+  return reduce ? ReduceMotion.Always : ReduceMotion.Never;
+}
diff --git a/apps/mobile/src/widgets/current-debate.tsx b/apps/mobile/src/widgets/current-debate.tsx
new file mode 100644
index 000000000..b00af38b0
--- /dev/null
+++ b/apps/mobile/src/widgets/current-debate.tsx
@@ -0,0 +1,157 @@
+import { HStack, Image, Link, Spacer, Text, VStack } from '@expo/ui/swift-ui';
+import {
+  background,
+  clipShape,
+  containerBackground,
+  font,
+  foregroundStyle,
+  frame,
+  lineLimit,
+  padding,
+  resizable,
+  widgetURL,
+} from '@expo/ui/swift-ui/modifiers';
+import { createWidget, type WidgetEnvironment } from 'expo-widgets';
+
+// The Current Debate on the Home Screen (small and medium). expo-widgets
+// serialises the function below and runs it in the widget extension's own
+// runtime, which has only @expo/ui's SwiftUI views and modifiers: no hooks, no
+// imports, nothing from outside the function body. Everything it shows comes
+// in its props, written by src/lib/debate-widget.ts, which is also the only
+// place that may import this file (creating the widget needs the native
+// module, which Expo Go lacks). The name must match the widget entry in
+// app.config.ts (withRound4).
+
+export type WidgetStat = { value: number; label: string };
+
+/** The DebateOwl colours the widget uses, from src/theme/colors.ts. */
+export type WidgetColors = {
+  background: string;
+  heading: string;
+  secondary: string;
+  primary: string;
+  primaryFill: string;
+  onPrimary: string;
+};
+
+export type CurrentDebateWidgetProps = {
+  /** The Current Debate's motion, or null when there is none (signed out or none started). */
+  motion: string | null;
+  /** "Current debate". */
+  title: string;
+  /** Sources, results and rounds, as the Debate tab shows them when it opens (the In favor side). */
+  stats: WidgetStat[];
+  /** The medium widget's row: sources, each side's results and rounds. */
+  wideStats: WidgetStat[];
+  spar: string;
+  emptyTitle: string;
+  emptyAction: string;
+  openUrl: string;
+  sparUrl: string;
+  newDebateUrl: string;
+  /** The owl mark in the shared App Group folder, or null to show a symbol instead. */
+  owl: string | null;
+  light: WidgetColors;
+  dark: WidgetColors;
+};
+
+const CurrentDebateWidget = (props: CurrentDebateWidgetProps, environment: WidgetEnvironment) => {
+  'widget';
+  const colors = environment.colorScheme === 'dark' ? props.dark : props.light;
+  const medium = environment.widgetFamily === 'systemMedium';
+  const mark = props.owl ? (
+    <Image uiImage={props.owl} modifiers={[resizable(), frame({ width: medium ? 22 : 18, height: medium ? 22 : 18 })]} />
+  ) : (
+    <Image systemName="bubble.left.and.bubble.right.fill" size={medium ? 16 : 14} color={colors.primary} />
+  );
+  const header = (
+    <HStack spacing={6}>
+      {mark}
+      <Text
+        modifiers={[
+          font({ size: 12, weight: 'bold', design: 'rounded' }),
+          foregroundStyle(colors.secondary),
+          lineLimit(1),
+        ]}>
+        {props.title}
+      </Text>
+    </HStack>
+  );
+
+  if (props.motion === null) {
+    return (
+      <VStack
+        alignment="leading"
+        spacing={6}
+        modifiers={[containerBackground(colors.background, 'widget'), widgetURL(props.newDebateUrl)]}>
+        {header}
+        <Spacer />
+        <Text
+          modifiers={[
+            font({ size: medium ? 17 : 15, weight: 'semibold', design: 'rounded' }),
+            foregroundStyle(colors.heading),
+            lineLimit(2),
+          ]}>
+          {props.emptyTitle}
+        </Text>
+        <Text
+          modifiers={[
+            font({ size: 13, weight: 'bold', design: 'rounded' }),
+            foregroundStyle(colors.primary),
+            lineLimit(1),
+          ]}>
+          {props.emptyAction}
+        </Text>
+      </VStack>
+    );
+  }
+
+  const row = (medium ? props.wideStats : props.stats).map((stat) => (
+    <VStack key={stat.label} alignment="leading" spacing={0}>
+      <Text modifiers={[font({ size: medium ? 20 : 17, weight: 'bold', design: 'rounded' }), foregroundStyle(colors.primary)]}>
+        {String(stat.value)}
+      </Text>
+      <Text modifiers={[font({ size: 10, weight: 'semibold' }), foregroundStyle(colors.secondary), lineLimit(1)]}>
+        {stat.label}
+      </Text>
+    </VStack>
+  ));
+
+  return (
+    <VStack
+      alignment="leading"
+      spacing={medium ? 8 : 6}
+      modifiers={[containerBackground(colors.background, 'widget'), widgetURL(props.openUrl)]}>
+      <HStack>
+        {header}
+        <Spacer />
+        {medium ? (
+          <Link destination={props.sparUrl}>
+            <Text
+              modifiers={[
+                font({ size: 13, weight: 'bold', design: 'rounded' }),
+                foregroundStyle(colors.onPrimary),
+                padding({ horizontal: 12, vertical: 5 }),
+                background(colors.primaryFill),
+                clipShape('capsule'),
+              ]}>
+              {props.spar}
+            </Text>
+          </Link>
+        ) : null}
+      </HStack>
+      <Text
+        modifiers={[
+          font({ size: medium ? 16 : 14, weight: 'semibold', design: 'rounded' }),
+          foregroundStyle(colors.heading),
+          lineLimit(medium ? 3 : 4),
+        ]}>
+        {props.motion}
+      </Text>
+      <Spacer />
+      <HStack spacing={medium ? 16 : 10}>{row}</HStack>
+    </VStack>
+  );
+};
+
+export default createWidget<CurrentDebateWidgetProps>('CurrentDebate', CurrentDebateWidget);
diff --git a/docs/operations.md b/docs/operations.md
index e24af4cc3..c62e06bdc 100644
--- a/docs/operations.md
+++ b/docs/operations.md
@@ -102,7 +102,7 @@ No staging run passed after 2026-09-23. Until 2026-10-01 the job did not run, be
 
 ## Staging sync
 
-Staging is project `debate-trainer-staging` (`brifeyypjauyusmkptkx`). Production is `debate-trainer` (`uziwdtkzofptihahfooo`). Staging syncs itself: a timer on the VPS applies migrations and deploys changed Edge Functions to staging within about 5 minutes of every commit on `main`. It sets the `staging-sync` commit status, and on failure it opens the **Staging is out of sync with main** issue. No per-run authorization is needed for staging. [staging.md](staging.md) covers the timer, its credential, the seed, and how to get in.
+Staging is project `brifeyypjauyusmkptkx` ("DebateOwl Staging"). Production is `uziwdtkzofptihahfooo` ("DebateOwl"). Scripts go by ref; the display names can change. Staging syncs itself: a timer on the VPS applies migrations and deploys changed Edge Functions to staging within about 5 minutes of every commit on `main`. It sets the `staging-sync` commit status, and on failure it opens the **Staging is out of sync with main** issue. No per-run authorization is needed for staging. [staging.md](staging.md) covers the timer, its credential, the seed, and how to get in.
 
 Before a production backend deploy, check that the commit's `staging-sync` status is green and that `Protected staging E2E` passed for it. Then follow [Supabase changes](#supabase-changes) with the list of migrations and functions that `npm run backend:status` reports for production.
 
diff --git a/docs/staging.md b/docs/staging.md
index eed7535cb..6a08894f6 100644
--- a/docs/staging.md
+++ b/docs/staging.md
@@ -2,7 +2,7 @@
 
 **Current.** The one place that says how to reach staging, what is on it, and how it stays in sync with `main`.
 
-Staging is the Supabase project `debate-trainer-staging` (`brifeyypjauyusmkptkx`). Production is `debate-trainer` (`uziwdtkzofptihahfooo`). Staging has its own users, data, and secrets. Nothing on staging can read or write production.
+Staging is the Supabase project `brifeyypjauyusmkptkx` (named "DebateOwl Staging" in the dashboard). Production is `uziwdtkzofptihahfooo` ("DebateOwl"). Scripts identify projects by ref only; the names are display labels and can change. Staging has its own users, data, and secrets. Nothing on staging can read or write production.
 
 ## Get in
 
@@ -43,7 +43,7 @@ Staging deliberately has no Stripe or ElevenLabs secrets. Checkout, the billing
 A user systemd timer on Adam's VPS, `debatelab-staging-sync.timer`, runs [`ops/staging-sync/run.sh`](../ops/staging-sync/run.sh) every 5 minutes. When `origin/main` has a commit it has not synced, it:
 
 1. checks that commit out in a dedicated clone at `~/ops/debatelab-staging-sync/repo` (it never runs `npm install`);
-2. runs [`scripts/staging-sync.mjs`](../scripts/staging-sync.mjs), which refuses unless the Supabase CLI sees `brifeyypjauyusmkptkx` named `debate-trainer-staging`, passes `--project-ref brifeyypjauyusmkptkx` to every CLI call, applies pending migrations, deploys new or changed Edge Functions except the hidden `workspace-invites`, and then checks that nothing is left pending. A function counts as changed when git has changed it since its last deploy, or when the source staging runs (from `supabase functions download`) differs byte for byte from the commit. The second check catches an older checkout deployed by hand;
+2. runs [`scripts/staging-sync.mjs`](../scripts/staging-sync.mjs), which refuses unless the Supabase CLI can see `brifeyypjauyusmkptkx` (by ref, so renaming the project in the dashboard doesn't break it) and `SUPABASE_PROJECT_ID`, if set, is that same ref, passes `--project-ref brifeyypjauyusmkptkx` to every CLI call, applies pending migrations, deploys new or changed Edge Functions except the hidden `workspace-invites`, and then checks that nothing is left pending. A function counts as changed when git has changed it since its last deploy, or when the source staging runs (from `supabase functions download`) differs byte for byte from the commit. The second check catches an older checkout deployed by hand;
 3. reruns the seed;
 4. sets the `staging-sync` commit status on that commit, and opens or comments on the GitHub issue **Staging is out of sync with main** when anything fails. A later successful sync closes the issue.
 
@@ -57,7 +57,7 @@ PRs that change `supabase/migrations/` or `supabase/functions/` get a comment sa
 
 The timer uses the Supabase CLI login already on the VPS (`~/.supabase/access-token`). It is a classic personal access token for Adam's account, so it reaches production too. The scripts' ref checks keep the sync itself on staging, but they are not a security boundary. Anyone who can merge to `main` can change those scripts, and the timer will run the new code with that token within 5 minutes. A malicious or broken merge could read or change production, including its database and secrets. Today that is the same trust as the other agents on the VPS that use this token, and only Adam merges to `main`.
 
-To shrink it, replace the token with a Supabase scoped token limited to `debate-trainer-staging` (Database and Edge Functions read-write) and pass it to the service as `SUPABASE_ACCESS_TOKEN`. Then a bad merge can touch staging only.
+To shrink it, replace the token with a Supabase scoped token limited to the staging project `brifeyypjauyusmkptkx` (Database and Edge Functions read-write) and pass it to the service as `SUPABASE_ACCESS_TOKEN`. Then a bad merge can touch staging only.
 
 ### Operate it
 
diff --git a/e2e.config.ts b/e2e.config.ts
index dd7d16189..bdac2c76b 100644
--- a/e2e.config.ts
+++ b/e2e.config.ts
@@ -45,7 +45,7 @@ const judge = claudeOnly(process.env.E2E_JUDGE_MODEL || E2E_JUDGE_DEFAULT);
 const context = [
   "DebateLab is a debate training app for students. A motion is the debate topic, such as \"This House would ban homework\".",
   "Each student works in one Current Debate at a time. The header control reads \"Start debate\" until one exists, then names the motion. Tool pages show a strip \"Working in: <motion>\".",
-  "Tools: Generate (a full debate case: thesis, contentions, predicted opponent case, prepared counters), Attack, Brainstorm, Factoids, Ask, Sparring (a practice round against an AI opponent, judged at the end), Crossfire (cross-examination practice), Flowchart, Timer, Library (sources for the Current Debate), and History (saved results).",
+  "Tools: Generate (a debate case for one speaker: an opening, arguments with point, explanation, evidence and why it matters, an \"If they say…\" list of their claims and our answers, a closing line and sources; R2 backs up the team's arguments instead of adding new ones, and the Conclusor gives reasons why we win), Attack, Brainstorm, Factoids, Ask, Sparring (a practice round against an AI opponent, judged at the end), Crossfire (cross-examination practice), Flowchart, Timer, Library (sources for the Current Debate), and History (saved results).",
   "A tool given a motion with no Current Debate asks \"Start a debate with this motion?\". A motion that differs from the Current Debate asks \"This is a different motion\".",
   "The interface language can be English, Spanish or Hungarian. Source titles, citations, user content and model names may stay in their own language. Hungarian abbreviates AI as MI (mesterséges intelligencia), so \"MI-modell\" is Hungarian, and English loanwords such as coaching are Hungarian there too, inflected (\"coachingot\") or as a modifier (\"coaching funkciók\"). The Spanish interface deliberately keeps the loanwords coach, coaching and sparring (\"Pregunta a tu coach\", \"Para Coaches\", \"Rondas de sparring\"); they are Spanish there.",
   "Long values in selects, chips and narrow fields are shortened with an ellipsis (…) on purpose.",
diff --git a/e2e/fixtures/ai-responses.ts b/e2e/fixtures/ai-responses.ts
index 40f32b9c7..849bb7e13 100644
--- a/e2e/fixtures/ai-responses.ts
+++ b/e2e/fixtures/ai-responses.ts
@@ -54,25 +54,20 @@ const CONTENTIONS = [
 ];
 
 const generate = (motion: string, length: string) => ({
+  opening: { hook: 'Picture a nurse who skips the night bus because the fare is a tenth of her shift.' },
   caseStructure: {
     thesis: `We support the motion that ${motion}`,
-    framework: 'Net societal benefit, weighed on access and cost.',
-    keyDefinitions: ['Public transport: publicly funded scheduled transit.'],
-    burdenOfProof: 'We must show the policy produces a net gain in practice.',
   },
   contentions: CONTENTIONS.slice(0, CONTENTION_COUNT[length] ?? 2),
-  predictedOpponentCase: {
-    likelyArguments: ['The lost farebox revenue has to come from somewhere.'],
-    strategicWeaknesses: ['Assumes fare revenue is the only funding model.'],
-    keyClashes: ['Who actually bears the cost.'],
-  },
   counters: [
     {
-      targetArgument: 'Funding gap',
-      counterpoint: 'Fare collection itself carries substantial overhead.',
-      rebuttal: 'Net cost is far below headline farebox revenue.',
+      targetArgument: 'The lost farebox revenue has to come from somewhere.',
+      counterpoint: 'Fare collection itself carries substantial overhead, so the net cost is far below headline farebox revenue.',
+      source: 'UITP, 2024',
     },
   ],
+  closingLine: 'That is why free public transport pays for itself.',
+  sources: [{ org: 'UITP', year: '2024', claim: 'Ridership rose after fares were removed' }],
   metadata: { side: 'pro', format: 'bp', generatedAt: new Date().toISOString() },
 });
 
diff --git a/e2e/full-stack/fake-openrouter.mjs b/e2e/full-stack/fake-openrouter.mjs
index 4f48206d2..5be51c986 100644
--- a/e2e/full-stack/fake-openrouter.mjs
+++ b/e2e/full-stack/fake-openrouter.mjs
@@ -51,34 +51,83 @@ const usage = { prompt_tokens: 120, completion_tokens: 80, total_tokens: 200, co
 
 const contention = (index) => ({
   id: String(index + 1),
+  title: `Fares shut people out ${index + 1}`,
   claim: `${MARK} contention ${index + 1}: fares block the riders who need transit most`,
   reasoning: "Fares are a regressive barrier concentrated on low-income riders.",
-  evidence: "Comparable jurisdictions report ridership gains after fare removal.",
+  evidence: "UITP reported in 2024 that comparable cities gained riders after removing fares.",
   needsSource: false,
-  impact: "More people reach work, school, and healthcare.",
+  // The prompt asks for whyItMatters; the Edge Function files it under impact.
+  whyItMatters: "More people reach work, school, and healthcare.",
 });
 
+const counter = (index) => ({
+  targetArgument: [
+    "The lost farebox revenue has to come from somewhere.",
+    "Free buses will be overcrowded and dirty.",
+    "People do not value what they do not pay for.",
+    "Drivers will not leave their cars anyway.",
+    "Only tourists and the well-off benefit.",
+    "Cities cannot afford the extra buses.",
+    "Fares already have discounts for people who need them.",
+    "Free transport has been tried and dropped elsewhere.",
+  ][index],
+  counterpoint: `${MARK} answer ${index + 1}: fare collection itself costs a large share of what it brings in, so the real gap is far smaller.`,
+  ...(index % 2 === 0 ? { source: "UITP, 2024" } : {}),
+});
+
+// R2's answers are full spoken blocks the speaker underlines and builds on.
+const r2Answer = (index) => ({
+  ...counter(index),
+  counterpoint: `${MARK} answer ${index + 1}: that is not what the numbers show. Fare collection itself costs a large share of what it brings in, so the real gap is far smaller than they say (UITP, 2024). Low-income households already spend more of their budget on transport than anyone else (Eurostat, 2023). For a family on a low income, that difference is the bus to work or the walk. If the money were really the problem, why do cities that dropped fares keep them dropped? This is exactly our first argument: fares shut out the people who need transit most.`,
+  source: "UITP, 2024",
+});
+
+// The role decides the shape, as the real prompt asks: the Introductor may
+// define an unclear term, R2 backs up the team's arguments and then answers
+// theirs, and the Conclusor brings reasons why we win. Neither R2 nor the
+// Conclusor brings new arguments.
 const generate = (user) => {
   const length = /^Length: (\w+)/m.exec(user)?.[1] ?? "standard";
+  const role = /^Role: (\w+)/m.exec(user)?.[1] ?? "r1";
   const count = { brief: 2, standard: 3, comprehensive: 4 }[length] ?? 3;
+  const conc = role === "conc";
+  const r2 = role === "r2";
+  // R2: one full answer for each thing they are likely to say.
+  const answers = length === "brief" ? 5 : 6;
   return {
-    caseStructure: {
-      thesis: `${MARK} case thesis: free transit is a net public good`,
-      framework: "Net societal benefit, weighed on access and cost.",
-      keyDefinitions: ["Public transport: publicly funded scheduled transit."],
-      burdenOfProof: "We must show the policy produces a net gain in practice.",
+    opening: {
+      hook: `${MARK} opening hook: picture a nurse who skips the night bus because the fare is a tenth of her shift's pay.`,
+      ...(role === "intro" ? { definition: "By free public transport we mean no fare at the point of use, paid for from public budgets." } : {}),
     },
-    contentions: Array.from({ length: count }, (_, index) => contention(index)),
-    predictedOpponentCase: {
-      likelyArguments: ["The lost farebox revenue has to come from somewhere."],
-      strategicWeaknesses: ["Assumes fare revenue is the only funding model."],
-      keyClashes: ["Who actually bears the cost."],
+    caseStructure: {
+      thesis: conc
+        ? `${MARK} case thesis: here is why free transit won this debate`
+        : r2
+          ? `${MARK} case thesis: I'm the R2 of my team, and I'm here to show that free transit is a net public good`
+          : `${MARK} case thesis: today we will show ${count} arguments that prove free transit is a net public good`,
     },
-    counters: [{
-      targetArgument: "Funding gap",
-      counterpoint: "Fare collection itself carries substantial overhead.",
-      rebuttal: "Net cost is far below headline farebox revenue.",
-    }],
+    contentions: conc || r2 ? [] : Array.from({ length: count }, (_, index) => contention(index)),
+    counters: conc ? [] : Array.from({ length: r2 ? answers : 3 }, (_, index) => (r2 ? r2Answer(index) : counter(index))),
+    ...(r2 ? {
+      reinforce: [
+        { argument: "Our first argument: fares shut people out", text: `${MARK} backing up: our first argument was that fares shut out the riders who need transit most. Eurostat found in 2023 that low-income households spend more of their budget on transport. If fares were fair, those numbers would not look like this.` },
+        { argument: "Our second argument: more people ride", text: `${MARK} backing up: our second argument was that free fares bring more passengers. UITP reported in 2024 that cities gained riders after removing fares. That is the policy working.` },
+      ],
+    } : {}),
+    ...(conc ? {
+      whyWeWin: [
+        "Their funding worry never answered our point that fare collection eats most of the fare.",
+        "Only our side showed who actually gets to work, school, and the doctor.",
+        "Even if some buses get busier, a full bus is the policy working.",
+      ].slice(0, length === "brief" ? 2 : 3),
+    } : {}),
+    closingLine: r2
+      ? "That is why it is clear that free public transport pays for itself in the lives it opens up. Thank you."
+      : "That is why it is clear that free public transport pays for itself in the lives it opens up.",
+    sources: [
+      { org: "UITP", year: "2024", claim: "Ridership rose after fares were removed", url: "https://www.uitp.org/free-fares-2024" },
+      { org: "Eurostat", year: "2023", claim: "Low-income households spend more of their budget on transport" },
+    ],
     metadata: { side: "pro", format: "custom", generatedAt: new Date().toISOString() },
   };
 };
diff --git a/e2e/sparring.spec.ts b/e2e/sparring.spec.ts
index e69bcac41..6c991ba5f 100644
--- a/e2e/sparring.spec.ts
+++ b/e2e/sparring.spec.ts
@@ -123,13 +123,13 @@ test('uses the school 4-6-6-3 roles and coaching in the default round', async ({
 
   const introductor = page.getByRole('textbox', { name: 'Draft for Pro Introductor' });
   await expect(introductor).toBeVisible();
-  await expect(page.getByText(/Open with an exordio, define the key terms/)).toBeVisible();
+  await expect(page.getByText(/Open with a hook, say "we will show N arguments that prove…"/)).toBeVisible();
   await introductor.fill('Our framework is civic responsibility. We define service as supervised work that directly benefits the local community.');
   await page.getByRole('button', { name: 'Submit speech' }).click();
 
   await expect(page.getByRole('region', { name: 'Transcript' }).getByText('Opponent response 1:')).toBeVisible();
   await expect(page.getByRole('textbox', { name: 'Draft for Pro R1' })).toBeVisible();
-  await expect(page.getByText(/Build the core arguments with claims, warrants, support, and impacts/)).toBeVisible();
+  await expect(page.getByText(/Build the arguments in full: the point, why it is true, evidence with its source and year/)).toBeVisible();
   expect(actions).toEqual(['respond']);
 });
 
diff --git a/package-lock.json b/package-lock.json
index b2feb56a1..13adfa57a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -125,12 +125,14 @@
         "@expo-google-fonts/fredoka": "^0.4.1",
         "@expo-google-fonts/nunito": "^0.4.2",
         "@expo/dom-webview": "~57.0.1",
+        "@expo/ui": "~57.0.22",
         "@formatjs/intl-listformat": "^8.3.15",
         "@formatjs/intl-pluralrules": "^6.3.15",
         "@react-native-async-storage/async-storage": "2.2.0",
         "@supabase/supabase-js": "^2.49.1",
         "aes-js": "^3.1.2",
         "date-fns": "^3.6.0",
+        "docx": "^9.5.1",
         "expo": "~57.0.27",
         "expo-audio": "~57.0.5",
         "expo-clipboard": "~57.0.2",
diff --git a/packages/core/src/ai/case-view.ts b/packages/core/src/ai/case-view.ts
new file mode 100644
index 000000000..ecefda310
--- /dev/null
+++ b/packages/core/src/ai/case-view.ts
@@ -0,0 +1,159 @@
+// One reading of a generated case for every place that shows or exports it.
+// New cases have an opening, arguments, an "If they say…" list, a closing line
+// and a sources list. R2 brings no new arguments: it backs up the team's
+// earlier ones (`reinforce`), and the Conclusor sums up why we win. Saved cases from before keep their old keys (exordio,
+// framework, burden of proof, definitions, the predicted opponent case and a
+// separate rebuttal), so those come through as `legacy` and show only when
+// they have content.
+import type { CaseSource, GenerateOutput, Reinforcement } from './schemas/generate';
+
+export interface CaseArgument {
+  id: string;
+  title?: string;
+  point: string;
+  explanation: string;
+  evidence: string;
+  whyItMatters: string;
+  needsSource: boolean;
+  sourceQuery?: string;
+}
+
+export interface CaseAnswer {
+  theySay: string;
+  weAnswer: string;
+  /** Older cases' second phrasing of the answer, when it adds something. */
+  inRound?: string;
+  source?: string;
+}
+
+export interface CaseView {
+  opening: {
+    hook?: string;
+    definition?: string;
+    /** "We will show N arguments that prove…"; older cases' thesis. */
+    roadmap?: string;
+  };
+  arguments: CaseArgument[];
+  /** R2: the team's earlier arguments, backed up again. */
+  reinforce: Reinforcement[];
+  ifTheySay: CaseAnswer[];
+  whyWeWin: string[];
+  closingLine?: string;
+  sources: CaseSource[];
+  legacy: {
+    framework?: string;
+    burdenOfProof?: string;
+    definitions: string[];
+    likelyArguments: string[];
+    weaknesses: string[];
+    clashes: string[];
+  };
+}
+
+function text(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function texts(value: unknown): string[] {
+  return Array.isArray(value) ? value.map(text).filter((item): item is string => Boolean(item)) : [];
+}
+
+/** Saved and shared cases come from storage, so only a web link is ever linked. */
+function webUrl(value: unknown): string | undefined {
+  const url = text(value);
+  if (!url) return undefined;
+  try {
+    const { protocol } = new URL(url);
+    return protocol === 'https:' || protocol === 'http:' ? url : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function joined(...parts: Array<string | undefined>): string | undefined {
+  const present = parts.filter(Boolean);
+  return present.length ? present.join(' ') : undefined;
+}
+
+export function readCase(result: GenerateOutput): CaseView {
+  const structure = result.caseStructure ?? { thesis: '' };
+  const counters = Array.isArray(result.counters) ? result.counters : [];
+  const opponent = result.predictedOpponentCase;
+  const answered = new Set(counters.map((counter) => text(counter?.targetArgument)?.toLowerCase()));
+  return {
+    opening: {
+      hook: text(result.opening?.hook) ?? joined(text(result.exordio?.hook), text(result.exordio?.transition)),
+      definition: text(result.opening?.definition),
+      roadmap: text(structure.thesis),
+    },
+    arguments: (Array.isArray(result.contentions) ? result.contentions : []).map((contention, index) => ({
+      id: contention?.id || String(index + 1),
+      title: text(contention?.title),
+      point: text(contention?.claim) ?? '',
+      explanation: text(contention?.reasoning) ?? '',
+      evidence: text(contention?.evidence) ?? '',
+      whyItMatters: text(contention?.impact) ?? '',
+      needsSource: Boolean(contention?.needsSource),
+      sourceQuery: text(contention?.sourceQuery),
+    })),
+    reinforce: (Array.isArray(result.reinforce) ? result.reinforce : []).flatMap((item) => {
+      const body = text(item?.text);
+      return body ? [{ argument: text(item?.argument) ?? '', text: body }] : [];
+    }),
+    ifTheySay: counters.flatMap((counter) => {
+      const theySay = text(counter?.targetArgument);
+      const counterpoint = text(counter?.counterpoint);
+      const rebuttal = text(counter?.rebuttal);
+      const weAnswer = counterpoint ?? rebuttal;
+      if (!theySay && !weAnswer) return [];
+      return [{
+        theySay: theySay ?? '',
+        weAnswer: weAnswer ?? '',
+        inRound: counterpoint && rebuttal && rebuttal !== counterpoint ? rebuttal : undefined,
+        source: text(counter?.source),
+      }];
+    }),
+    whyWeWin: texts(result.whyWeWin),
+    closingLine: text(result.closingLine),
+    sources: (Array.isArray(result.sources) ? result.sources : []).flatMap((source) => {
+      const org = text(source?.org);
+      const claim = text(source?.claim);
+      if (!org && !claim) return [];
+      return [{ org: org ?? '', claim: claim ?? '', year: text(source?.year), url: webUrl(source?.url) }];
+    }),
+    legacy: {
+      framework: text(structure.framework),
+      burdenOfProof: text(structure.burdenOfProof),
+      definitions: texts(structure.keyDefinitions),
+      // An argument the list already answers is not repeated as a bare bullet.
+      likelyArguments: texts(opponent?.likelyArguments).filter((argument) => !answered.has(argument.toLowerCase())),
+      weaknesses: texts(opponent?.strategicWeaknesses),
+      clashes: texts(opponent?.keyClashes),
+    },
+  };
+}
+
+/** "UNICEF (2025)", or just the organisation when the year is unknown. */
+export function sourceLabel(source: Pick<CaseSource, 'org' | 'year'>): string {
+  return [source.org, source.year && `(${source.year})`].filter(Boolean).join(' ');
+}
+
+/** "UNICEF (2025) – Most minors use AI to learn – https://…" for exports and plain text. */
+export function sourceLine(source: CaseSource): string {
+  return [sourceLabel(source), source.claim, source.url].filter(Boolean).join(' – ');
+}
+
+/**
+ * A regenerated section can cite new sources while the rest of the case still
+ * cites the old ones, so the list keeps both, each source once.
+ */
+export function mergeCaseSources(current: CaseSource[] | null | undefined, next: CaseSource[] | null | undefined): CaseSource[] | undefined {
+  const seen = new Set<string>();
+  const merged = [...(next ?? []), ...(current ?? [])].filter((source) => {
+    const key = (source.url || `${source.org}|${source.claim}`).trim().toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return merged.length ? merged : undefined;
+}
diff --git a/packages/core/src/ai/generate-output.test.ts b/packages/core/src/ai/generate-output.test.ts
new file mode 100644
index 000000000..8d977839b
--- /dev/null
+++ b/packages/core/src/ai/generate-output.test.ts
@@ -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);
+  });
+});
diff --git a/packages/core/src/ai/generate-output.ts b/packages/core/src/ai/generate-output.ts
index 68190b9e7..3e55ff711 100644
--- a/packages/core/src/ai/generate-output.ts
+++ b/packages/core/src/ai/generate-output.ts
@@ -1,3 +1,4 @@
+import { mergeCaseSources } from './case-view';
 import type { GenerateInput, GenerateOutput } from './schemas/generate';
 
 function cleanGeneratedString(value: string) {
@@ -24,9 +25,8 @@ export function cleanGeneratedOutput<T>(value: T): T {
  * This handles cases where the AI returns a different structure than requested.
  */
 export function transformGenerateResponse(response: Record<string, unknown>): GenerateOutput {
-  // If already in correct format, return as-is (with exordio preserved)
-  if (response.caseStructure && response.contentions && response.predictedOpponentCase && response.counters && response.metadata) {
-    // Ensure exordio is properly structured if present
+  // Already in the expected shape (a new case, or an older one with its extra sections).
+  if (response.caseStructure && response.contentions && response.counters && response.metadata) {
     const result = response as unknown as GenerateOutput;
     if (response.exordio && typeof response.exordio === 'object') {
       const ex = response.exordio as Record<string, unknown>;
@@ -59,23 +59,15 @@ export function transformGenerateResponse(response: Record<string, unknown>): Ge
     impact: c.impact || c.analysis || '',
   }));
 
-  // Transform rebuttals to counters
+  // Transform rebuttals to "If they say…" answers
   const rebuttals = (response.rebuttals as Array<{ attack?: string; response?: string }>) || [];
-  const counters = rebuttals.map(r => ({
-    targetArgument: r.attack || '',
-    counterpoint: r.response || '',
-    rebuttal: r.response || '',
-  }));
-
-  // Transform potentialWeaknesses to predictedOpponentCase
-  const weaknesses = (response.potentialWeaknesses as string[]) || [];
+  const counters = rebuttals
+    .filter((r) => r.attack || r.response)
+    .map((r) => ({ targetArgument: r.attack || '', counterpoint: r.response || '' }));
 
   const result: GenerateOutput = {
     caseStructure: {
       thesis: (response.thesis as string) || (response.title as string) || '',
-      framework: 'General framework',
-      keyDefinitions: [],
-      burdenOfProof: 'We must prove that ' + ((response.thesis as string) || '').slice(0, 50),
     },
     contentions: transformedContentions.length > 0 ? transformedContentions : [{
       id: '1',
@@ -86,16 +78,7 @@ export function transformGenerateResponse(response: Record<string, unknown>): Ge
       sourceQuery: '',
       impact: 'Impact here',
     }],
-    predictedOpponentCase: {
-      likelyArguments: weaknesses.slice(0, 3),
-      strategicWeaknesses: weaknesses,
-      keyClashes: ['Main clash point'],
-    },
-    counters: counters.length > 0 ? counters : [{
-      targetArgument: 'Opponent argument',
-      counterpoint: 'Our counter',
-      rebuttal: 'Rebuttal text',
-    }],
+    counters,
     metadata: {
       side: (response.side as 'pro' | 'con') || 'pro',
       format: 'custom',
@@ -127,21 +110,44 @@ export function expectedContentionCount(length: GenerateInput['length']): number
   }
 }
 
+/**
+ * Whether a case has the argument count its length asks for. R2 backs up the
+ * team's arguments and a Conclusor sums up why we win, so neither brings new
+ * arguments. An older backend still sends both the usual argument count.
+ */
+export function hasExpectedArguments(result: GenerateOutput, input: Pick<GenerateInput, 'length' | 'role'>): boolean {
+  const noNewArguments = (input.role === 'r2' && Boolean(result.reinforce?.length))
+    || (input.role === 'conc' && Boolean(result.whyWeWin?.length));
+  return noNewArguments || result.contentions.length === expectedContentionCount(input.length);
+}
+
 /** The parts of a case Regenerate can replace one at a time, as the website's section cards name them. */
-export type CaseSection = 'exordio' | 'structure' | 'contentions' | 'opponent' | 'counters';
+export type CaseSection = 'opening' | 'contentions' | 'counters' | 'reinforce' | 'whyWeWin' | 'closing';
 
 /**
  * A case with one part taken from a newly generated one, as the website's
- * Regenerate merges it. The metadata comes from the new run.
+ * Regenerate merges it. The metadata comes from the new run, and the sources
+ * list keeps both runs' sources.
  */
 export function mergeRegeneratedSection(base: GenerateOutput, next: GenerateOutput, section: CaseSection): GenerateOutput {
   return {
     ...base,
-    ...(section === 'structure' ? { caseStructure: next.caseStructure } : {}),
-    ...(section === 'contentions' ? { contentions: next.contentions } : {}),
-    ...(section === 'opponent' ? { predictedOpponentCase: next.predictedOpponentCase } : {}),
-    ...(section === 'counters' ? { counters: next.counters } : {}),
-    ...(section === 'exordio' ? { exordio: next.exordio } : {}),
+    // 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 } : {}),
+    // 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 } : {}),
+    ...(section === 'closing' ? { closingLine: next.closingLine } : {}),
+    sources: mergeCaseSources(base.sources, next.sources),
     metadata: next.metadata,
   };
 }
diff --git a/packages/core/src/ai/live-sections.ts b/packages/core/src/ai/live-sections.ts
index fcd1f9d32..2503ae222 100644
--- a/packages/core/src/ai/live-sections.ts
+++ b/packages/core/src/ai/live-sections.ts
@@ -65,42 +65,39 @@ function section(id: string, title: string, blocks: DraftBlock[]): DraftSection[
 }
 
 export function generateDraftSections(draft: Draft, t: Translate): DraftSection[] {
-  const exordio = record(draft.exordio);
+  const opening = record(draft.opening);
   const structure = record(draft.caseStructure);
-  const opponent = record(draft.predictedOpponentCase);
   return [
-    ...section('exordio', t('generateResults.exordio'), [
-      ...block(t('generateResults.hook'), exordio.hook),
-      ...block(t('generateResults.transition'), exordio.transition),
-    ]),
-    ...section('structure', t('generateResults.caseStructure'), [
-      ...block(t('generateResults.thesis'), structure.thesis),
-      ...block(t('generateResults.framework'), structure.framework),
-      ...itemsBlock(t('generateResults.keyDefinitions'), structure.keyDefinitions),
-      ...block(t('generateResults.burdenOfProof'), structure.burdenOfProof),
+    ...section('opening', t('generateResults.opening'), [
+      ...block(undefined, opening.hook),
+      ...block(t('generateResults.definition'), opening.definition),
+      ...block(t('generateResults.roadmap'), structure.thesis),
     ]),
     ...section('contentions', t('generateResults.arguments'), list(draft.contentions).flatMap((value) => {
       const contention = record(value);
       return [
-        ...heading(contention.claim),
-        ...block(t('generateResults.reasoning'), contention.reasoning),
+        ...heading(contention.title ?? contention.claim),
+        ...(text(contention.title) ? block(t('generateResults.point'), contention.claim) : []),
+        ...block(t('generateResults.explanation'), contention.reasoning),
         ...block(t('generateResults.evidence'), contention.evidence),
-        ...block(t('generateResults.impact'), contention.impact),
+        // The model writes whyItMatters; the server files it under impact.
+        ...block(t('generateResults.whyItMatters'), contention.whyItMatters ?? contention.impact),
       ];
     })),
-    ...section('opponent', t('generateResults.predictedOpponent'), [
-      ...itemsBlock(t('generateResults.likelyArguments'), opponent.likelyArguments),
-      ...itemsBlock(t('generateResults.strategicWeaknesses'), opponent.strategicWeaknesses),
-      ...itemsBlock(t('generateResults.keyClashes'), opponent.keyClashes),
-    ]),
-    ...section('counters', t('generateResults.preparedCounters'), list(draft.counters).flatMap((value) => {
+    ...section('reinforce', t('generateResults.reinforce'), list(draft.reinforce).flatMap((value) => {
+      const item = record(value);
+      return [...heading(item.argument), ...block(undefined, item.text)];
+    })),
+    ...section('whyWeWin', t('generateResults.whyWeWin'), itemsBlock(undefined, draft.whyWeWin)),
+    ...section('counters', t('generateResults.ifTheySay'), list(draft.counters).flatMap((value) => {
       const counter = record(value);
       return [
         ...heading(counter.targetArgument),
-        ...block(t('generateResults.counter'), counter.counterpoint),
-        ...block(t('generateResults.rebuttal'), counter.rebuttal),
+        ...block(t('generateResults.weAnswer'), counter.counterpoint),
+        ...block(t('generateResults.source'), counter.source),
       ];
     })),
+    ...section('closing', t('generateResults.closingLine'), block(undefined, draft.closingLine)),
   ];
 }
 
diff --git a/packages/core/src/ai/schemas/generate.ts b/packages/core/src/ai/schemas/generate.ts
index 960c79b0b..10f14c73b 100644
--- a/packages/core/src/ai/schemas/generate.ts
+++ b/packages/core/src/ai/schemas/generate.ts
@@ -14,8 +14,13 @@ export const GenerateInputSchema = z.object({
 
 export type GenerateInput = z.infer<typeof GenerateInputSchema>;
 
+// New fields accept null as well as absence: models often send null for a
+// field the prompt says to omit.
+// Each argument reads Title, Point (claim), Explanation (reasoning), Evidence and
+// Why it matters (impact). The keys stay as they were so saved cases keep loading.
 export const ContentionSchema = z.object({
   id: z.string(),
+  title: z.string().nullish(),
   claim: z.string(),
   reasoning: z.string(),
   evidence: z.string(),
@@ -24,30 +29,69 @@ export const ContentionSchema = z.object({
   impact: z.string(),
 });
 
+/** Older cases only: the Introductor's hook and bridge, now part of the opening. */
 export const ExordioSchema = z.object({
   hook: z.string(),
   transition: z.string(),
 });
 
+export const OpeningSchema = z.object({
+  hook: z.string(),
+  /** One line defining a motion term, only when the term is genuinely unclear. */
+  definition: z.string().nullish(),
+});
+
+/** One "If they say…" item: their claim, our answer, and an optional source. */
+export const CounterSchema = z.object({
+  targetArgument: z.string(),
+  counterpoint: z.string(),
+  /** Older cases only: a second, in-round phrasing of the answer. */
+  rebuttal: z.string().optional(),
+  source: z.string().nullish(),
+});
+
+/**
+ * R2 only: one block backing up an argument the team already made, in the
+ * style "Our second argument was about bullying…", instead of new arguments.
+ */
+export const ReinforceSchema = z.object({
+  /** Which earlier argument this backs up, e.g. "Our second argument: bullying". */
+  argument: z.string(),
+  text: z.string(),
+});
+
+export const CaseSourceSchema = z.object({
+  org: z.string(),
+  year: z.string().nullish(),
+  claim: z.string(),
+  url: z.string().nullish(),
+});
+
 export const GenerateOutputSchema = z.object({
+  opening: OpeningSchema.nullish(),
   exordio: ExordioSchema.optional(),
+  // thesis is the opening's "we will show N arguments that prove…" line. The
+  // other three are older cases' sections, shown only when they have content.
   caseStructure: z.object({
     thesis: z.string(),
-    framework: z.string(),
-    keyDefinitions: z.array(z.string()),
-    burdenOfProof: z.string(),
+    framework: z.string().optional(),
+    keyDefinitions: z.array(z.string()).optional(),
+    burdenOfProof: z.string().optional(),
   }),
   contentions: z.array(ContentionSchema),
+  /** Older cases only; new cases fold the opponent's arguments into counters. */
   predictedOpponentCase: z.object({
-    likelyArguments: z.array(z.string()),
-    strategicWeaknesses: z.array(z.string()),
-    keyClashes: z.array(z.string()),
-  }),
-  counters: z.array(z.object({
-    targetArgument: z.string(),
-    counterpoint: z.string(),
-    rebuttal: z.string(),
-  })),
+    likelyArguments: z.array(z.string()).optional(),
+    strategicWeaknesses: z.array(z.string()).optional(),
+    keyClashes: z.array(z.string()).optional(),
+  }).optional(),
+  counters: z.array(CounterSchema),
+  /** R2 only: about two minutes backing up the team's arguments. */
+  reinforce: z.array(ReinforceSchema).nullish(),
+  /** Conclusor only: two or three summaries of why our side wins. */
+  whyWeWin: z.array(z.string()).nullish(),
+  closingLine: z.string().nullish(),
+  sources: z.array(CaseSourceSchema).nullish(),
   metadata: z.object({
     side: z.enum(['pro', 'con']),
     format: z.string(),
@@ -71,3 +115,6 @@ export const GenerateOutputSchema = z.object({
 
 export type GenerateOutput = z.infer<typeof GenerateOutputSchema>;
 export type Contention = z.infer<typeof ContentionSchema>;
+export type Counter = z.infer<typeof CounterSchema>;
+export type CaseSource = z.infer<typeof CaseSourceSchema>;
+export type Reinforcement = z.infer<typeof ReinforceSchema>;
diff --git a/packages/core/src/crossfire/prefill.ts b/packages/core/src/crossfire/prefill.ts
index e437eadec..0914ebdce 100644
--- a/packages/core/src/crossfire/prefill.ts
+++ b/packages/core/src/crossfire/prefill.ts
@@ -1,5 +1,6 @@
 import type { AttackOutput } from '../ai/schemas/attack';
 import type { GenerateOutput } from '../ai/schemas/generate';
+import { readCase } from '../ai/case-view';
 import {
   CrossfirePrefillSchema,
   MAX_CROSSFIRE_ARGUMENT_CHARS,
@@ -17,21 +18,25 @@ function boundedArgument(parts: string[]): string {
 }
 
 export function prefillFromGenerate(resolution: string, result: GenerateOutput): CrossfirePrefill {
-  const contentionText = result.contentions.map((contention, index) => [
-    `Contention ${index + 1}: ${contention.claim}`,
-    `Reasoning: ${contention.reasoning}`,
-    `Evidence: ${contention.evidence}`,
-    `Impact: ${contention.impact}`,
-  ].join('\n'));
+  const view = readCase(result);
+  const line = (label: string, value: string | undefined) => (value ? `${label}: ${value}` : '');
+  const argumentText = view.arguments.map((argument, index) => [
+    `Argument ${index + 1}: ${argument.title ? `${argument.title}. ` : ''}${argument.point}`,
+    line('Explanation', argument.explanation),
+    line('Evidence', argument.evidence),
+    line('Why it matters', argument.whyItMatters),
+  ].filter(Boolean).join('\n'));
 
   return CrossfirePrefillSchema.parse({
     source: 'generate',
     resolution: resolution.trim().slice(0, 500),
     argument: boundedArgument([
-      `Thesis: ${result.caseStructure.thesis}`,
-      `Framework: ${result.caseStructure.framework}`,
-      `Burden of proof: ${result.caseStructure.burdenOfProof}`,
-      ...contentionText,
+      line('What we will show', view.opening.roadmap),
+      line('How to judge this debate', view.legacy.framework),
+      line('What we have to show', view.legacy.burdenOfProof),
+      ...argumentText,
+      ...view.reinforce.map((item, index) => `Backing up ${item.argument || `argument ${index + 1}`}: ${item.text}`),
+      ...view.whyWeWin.map((reason, index) => `Why we win ${index + 1}: ${reason}`),
     ]),
   });
 }
diff --git a/packages/core/src/export/docx.ts b/packages/core/src/export/docx.ts
new file mode 100644
index 000000000..4a95bccaa
--- /dev/null
+++ b/packages/core/src/export/docx.ts
@@ -0,0 +1,502 @@
+// The Word documents both clients export. Each builder lays out one result as a
+// `docx` Document and names the file as the website always has; the client
+// imports the `docx` library itself (lazily: it is large), passes it in, and
+// packs and saves or shares the Document its own way. Strings come through
+// `ctx.t` with the website's `export.*` keys, so both clients print the same
+// labels in every language.
+import { readCase, sourceLine } from '../ai/case-view';
+import type { AttackOutput } from '../ai/schemas/attack';
+import type { BrainstormOutput } from '../ai/schemas/brainstorm';
+import type { FactoidsOutput } from '../ai/schemas/factoids';
+import type { GenerateOutput } from '../ai/schemas/generate';
+import type { SparringSession } from '../sparring/session';
+
+/** The `docx` module namespace, as `await import('docx')` returns it. */
+export type DocxModule = typeof import('docx');
+type DocxDocument = InstanceType<DocxModule['Document']>;
+type DocxParagraph = InstanceType<DocxModule['Paragraph']>;
+
+export interface DocxContext {
+  t: (key: string, options?: Record<string, unknown>) => string;
+  /** A day, as the website's formatEuropeanDate shows it. */
+  formatDate: (date: Date) => string;
+  /** A day and time, as the website's formatEuropeanDateTime shows it. */
+  formatDateTime: (date: Date) => string;
+}
+
+export interface BuiltDocx {
+  doc: DocxDocument;
+  fileName: string;
+}
+
+/** Today's date as the file names use it: 2026-10-28. */
+function isoDay(date = new Date()): string {
+  return date.toISOString().split('T')[0];
+}
+
+/** What every case export needs; the older sections are optional. */
+export function hasCaseData(result: GenerateOutput | undefined): result is GenerateOutput {
+  return Boolean(result?.metadata && result.caseStructure && Array.isArray(result.contentions) && Array.isArray(result.counters));
+}
+
+export function buildCaseDocx(docx: DocxModule, result: GenerateOutput, ctx: DocxContext): BuiltDocx {
+  if (!hasCaseData(result)) {
+    throw new Error('Missing required case data for export.');
+  }
+  const { Document, Paragraph, TextRun, HeadingLevel, AlignmentType } = docx;
+  const { t } = ctx;
+
+  const view = readCase(result);
+  const roadmap = view.opening.roadmap || t('export.untitledCase');
+  const motion = (result.metadata as Record<string, unknown>)?.motion as string | undefined;
+  const caseTitle = motion || roadmap.split('.')[0] || roadmap;
+  const sideLabel = result.metadata.side === 'pro'
+    ? t('export.proposition')
+    : result.metadata.side === 'con'
+      ? t('export.opposition')
+      : 'Unknown';
+  const formatLabel = result.metadata.format ? result.metadata.format.toUpperCase() : 'UNKNOWN';
+  const generatedAtDate = result.metadata.generatedAt ? new Date(result.metadata.generatedAt) : null;
+  const generatedAtText = generatedAtDate && !Number.isNaN(generatedAtDate.getTime())
+    ? ctx.formatDate(generatedAtDate)
+    : 'Unknown';
+
+  const heading = (text: string, before = 0) =>
+    new Paragraph({ text: text.toUpperCase(), heading: HeadingLevel.HEADING_2, ...(before ? { spacing: { before } } : {}) });
+  const labelled = (label: string, text: string, after = 100, bold = false) => new Paragraph({
+    children: [new TextRun({ text: `${label}: `, ...(bold ? { bold: true } : { italics: true }) }), new TextRun(text)],
+    spacing: { after },
+  });
+  const bullets = (items: string[]) => items.map((item) => new Paragraph({ text: '• ' + item, spacing: { after: 100 } }));
+  const legacyBlock = (label: string, text: string | undefined) => text ? [labelled(label, text, 200, true)] : [];
+
+  const openingSection = [
+    ...(view.opening.hook ? [new Paragraph({ children: [new TextRun({ text: view.opening.hook, italics: true })], spacing: { after: 200 } })] : []),
+    ...(view.opening.definition ? [labelled(t('export.definition'), view.opening.definition, 200, true)] : []),
+    ...(view.opening.roadmap ? [new Paragraph({ text: view.opening.roadmap, spacing: { after: 200 } })] : []),
+    ...legacyBlock(t('export.legacyJudgeBy'), view.legacy.framework),
+    ...legacyBlock(t('export.legacyMustShow'), view.legacy.burdenOfProof),
+    ...(view.legacy.definitions.length ? [labelled(t('export.legacyDefinitions'), view.legacy.definitions.join('; '), 200, true)] : []),
+  ];
+
+  const argumentsSection = view.arguments.flatMap((argument, i) => [
+    new Paragraph({
+      children: [new TextRun({ text: `${t('export.argumentNumber', { number: i + 1 })}: ${argument.title ?? argument.point}`, bold: true, size: 28 })],
+      spacing: { before: 200, after: 100 },
+    }),
+    ...(argument.title && argument.point ? [labelled(t('export.point'), argument.point)] : []),
+    ...(argument.explanation ? [labelled(t('export.explanation'), argument.explanation)] : []),
+    ...(argument.evidence ? [labelled(t('export.evidence'), argument.evidence)] : []),
+    ...(argument.whyItMatters ? [labelled(t('export.whyItMatters'), argument.whyItMatters, 300)] : []),
+  ]);
+
+  // R2: each earlier argument it backs up, then the spoken paragraph.
+  const reinforceSection = view.reinforce.flatMap((item) => [
+    ...(item.argument ? [new Paragraph({ children: [new TextRun({ text: item.argument, bold: true })], spacing: { before: 200, after: 100 } })] : []),
+    new Paragraph({ text: item.text, spacing: { after: 200 } }),
+  ]);
+
+  const answersSection = view.ifTheySay.flatMap((answer) => [
+    new Paragraph({
+      children: [new TextRun({ text: `${t('export.theySay')}: `, bold: true }), new TextRun(answer.theySay)],
+    }),
+    labelled(t('export.weAnswer'), answer.weAnswer, answer.inRound || answer.source ? 100 : 200),
+    ...(answer.inRound ? [labelled(t('export.legacySayItLike'), answer.inRound, answer.source ? 100 : 200)] : []),
+    ...(answer.source ? [labelled(t('export.source'), answer.source, 200)] : []),
+  ]);
+
+  const doc = new Document({
+    sections: [
+      {
+        properties: {},
+        children: [
+          // Title
+          new Paragraph({
+            text: t('export.debateCase') + ": " + caseTitle,
+            heading: HeadingLevel.HEADING_1,
+            alignment: AlignmentType.CENTER,
+            spacing: { after: 400 },
+          }),
+
+          // Metadata
+          new Paragraph({
+            children: [
+              new TextRun({ text: `${t('export.side')}: `, bold: true }),
+              new TextRun(sideLabel),
+              new TextRun({ text: " | Format: ", bold: true }),
+              new TextRun(formatLabel),
+              new TextRun({ text: " | Date: ", bold: true }),
+              new TextRun(generatedAtText),
+            ],
+            spacing: { after: 400 },
+          }),
+
+          ...(openingSection.length ? [heading(t('export.opening')), ...openingSection] : []),
+          ...(argumentsSection.length ? [heading(t('export.arguments'), 200), ...argumentsSection] : []),
+          ...(reinforceSection.length ? [heading(t('export.reinforce'), 200), ...reinforceSection] : []),
+          ...(view.whyWeWin.length ? [heading(t('export.whyWeWin'), 200), ...bullets(view.whyWeWin)] : []),
+          ...(answersSection.length || view.legacy.likelyArguments.length ? [
+            heading(t('export.ifTheySay'), 400),
+            ...answersSection,
+            ...(view.legacy.likelyArguments.length ? [new Paragraph({ children: [new TextRun({ text: t('export.legacyAlsoSay'), bold: true })], spacing: { before: 200, after: 100 } }), ...bullets(view.legacy.likelyArguments)] : []),
+          ] : []),
+          ...(view.closingLine ? [heading(t('export.closingLine'), 400), new Paragraph({ children: [new TextRun({ text: view.closingLine, bold: true })], spacing: { after: 200 } })] : []),
+          ...(view.sources.length ? [heading(t('export.sources'), 400), ...bullets(view.sources.map(sourceLine))] : []),
+        ],
+      },
+    ],
+  });
+
+  return { doc, fileName: `DebateCase_${result.metadata.side || 'case'}.docx` };
+}
+
+export function buildAttackDocx(docx: DocxModule, result: AttackOutput, ctx: DocxContext): BuiltDocx {
+  if (!result?.overallAssessment || !Array.isArray(result.weaknesses)) {
+    throw new Error('Missing required attack data for export.');
+  }
+  const { Document, Paragraph, TextRun, HeadingLevel, AlignmentType } = docx;
+  const { t } = ctx;
+
+  const weaknesses = result.weaknesses || [];
+  const weaknessesSection = weaknesses.length > 0
+    ? weaknesses.flatMap((w, i) => [
+      new Paragraph({
+        children: [new TextRun({ text: `${i + 1}. [${w.severity?.toUpperCase()}] ${w.description}`, bold: true })],
+        spacing: { before: 200, after: 100 },
+      }),
+      new Paragraph({
+        children: [new TextRun({ text: `${t('export.whyWeak')}: `, italics: true }), new TextRun(w.whyWeak || '')],
+        spacing: { after: 100 },
+      }),
+      new Paragraph({
+        children: [new TextRun({ text: `${t('export.howOpponentAttacks')}: `, italics: true }), new TextRun(w.howOpponentAttacks || '')],
+        spacing: { after: 100 },
+      }),
+      new Paragraph({
+        children: [new TextRun({ text: `${t('export.improvedVersion')}: `, italics: true }), new TextRun(w.improvedVersion || '')],
+        spacing: { after: 200 },
+      }),
+    ])
+    : [new Paragraph({ text: t('export.noWeaknesses'), spacing: { after: 200 } })];
+
+  const fallacies = result.fallaciesDetected || [];
+  const fallaciesSection = fallacies.length > 0
+    ? fallacies.flatMap(f => [
+      new Paragraph({
+        children: [new TextRun({ text: f.name, bold: true })],
+        spacing: { before: 100, after: 50 },
+      }),
+      new Paragraph({ text: `Location: ${f.location}`, spacing: { after: 50 } }),
+      new Paragraph({ text: f.explanation, spacing: { after: 150 } }),
+    ])
+    : [new Paragraph({ text: t('export.noFallacies'), spacing: { after: 200 } })];
+
+  const crossEx = result.crossExQuestions || [];
+  const crossExSection = crossEx.length > 0
+    ? crossEx.flatMap((q, i) => [
+      new Paragraph({
+        children: [new TextRun({ text: `Q${i + 1}: ${q.question}`, bold: true })],
+        spacing: { before: 100, after: 50 },
+      }),
+      new Paragraph({ text: `Purpose: ${q.purpose}`, spacing: { after: 50 } }),
+      new Paragraph({ text: `Expected Trap: ${q.expectedTrap}`, spacing: { after: 150 } }),
+    ])
+    : [new Paragraph({ text: t('export.noCrossEx'), spacing: { after: 200 } })];
+
+  const doc = new Document({
+    sections: [{
+      properties: {},
+      children: [
+        new Paragraph({
+          text: t('export.caseAttack'),
+          heading: HeadingLevel.HEADING_1,
+          alignment: AlignmentType.CENTER,
+          spacing: { after: 400 },
+        }),
+        new Paragraph({
+          children: [
+            new TextRun({ text: `${t('export.overallScore')}: `, bold: true }),
+            new TextRun(`${result.overallAssessment.score}/100`),
+          ],
+          spacing: { after: 200 },
+        }),
+        new Paragraph({ text: result.overallAssessment.summary, spacing: { after: 400 } }),
+
+        new Paragraph({ text: t('export.weaknesses').toUpperCase(), heading: HeadingLevel.HEADING_2 }),
+        ...weaknessesSection,
+
+        new Paragraph({ text: t('export.fallacies').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
+        ...fallaciesSection,
+
+        new Paragraph({ text: t('export.crossExQuestions').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
+        ...crossExSection,
+      ],
+    }],
+  });
+
+  return { doc, fileName: `AttackAnalysis_${isoDay()}.docx` };
+}
+
+export function buildBrainstormDocx(docx: DocxModule, result: BrainstormOutput, ctx: DocxContext): BuiltDocx {
+  const { Document, Paragraph, TextRun, HeadingLevel, AlignmentType } = docx;
+  const { t } = ctx;
+
+  const children: DocxParagraph[] = [
+    new Paragraph({
+      text: t('export.brainstormResults'),
+      heading: HeadingLevel.HEADING_1,
+      alignment: AlignmentType.CENTER,
+      spacing: { after: 400 },
+    }),
+  ];
+
+  // Top Five
+  const topFive = result.topFive || [];
+  if (topFive.length > 0) {
+    children.push(new Paragraph({ text: "TOP 5 ARGUMENT ANGLES", heading: HeadingLevel.HEADING_2 }));
+    topFive.forEach(item => {
+      children.push(new Paragraph({
+        children: [new TextRun({ text: `#${item.rank}: ${item.idea?.title || 'Untitled'}`, bold: true })],
+        spacing: { before: 150, after: 50 },
+      }));
+      children.push(new Paragraph({ text: item.idea?.description || '', spacing: { after: 50 } }));
+      children.push(new Paragraph({
+        children: [new TextRun({ text: `${t('export.whyTop')}: `, italics: true }), new TextRun(item.whyTop || '')],
+        spacing: { after: 150 },
+      }));
+    });
+  }
+
+  // Mind Map
+  const mindmap = result.mindmap || [];
+  if (mindmap.length > 0) {
+    children.push(new Paragraph({ text: "ARGUMENT MAP", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }));
+    mindmap.forEach(category => {
+      children.push(new Paragraph({
+        children: [new TextRun({ text: category.category, bold: true })],
+        spacing: { before: 200, after: 100 },
+      }));
+      category.items?.forEach(idea => {
+        children.push(new Paragraph({
+          text: `• ${idea.title}: ${idea.description}`,
+          spacing: { after: 75 },
+        }));
+      });
+    });
+  }
+
+  // Buckets
+  const buckets = result.buckets || [];
+  if (buckets.length > 0) {
+    children.push(new Paragraph({ text: "ARGUMENT BUCKETS", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }));
+    buckets.forEach(bucket => {
+      children.push(new Paragraph({
+        children: [new TextRun({ text: bucket.name, bold: true })],
+        spacing: { before: 200, after: 50 },
+      }));
+      children.push(new Paragraph({ text: bucket.keyInsight || '', spacing: { after: 100 } }));
+      bucket.ideas?.forEach(idea => {
+        children.push(new Paragraph({ text: `• ${idea.title}`, spacing: { after: 50 } }));
+      });
+    });
+  }
+
+  // Next Steps
+  const nextSteps = result.nextSteps || [];
+  if (nextSteps.length > 0) {
+    children.push(new Paragraph({ text: "NEXT STEPS", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }));
+    nextSteps.forEach((step, i) => {
+      children.push(new Paragraph({ text: `${i + 1}. ${step}`, spacing: { after: 75 } }));
+    });
+  }
+
+  const doc = new Document({ sections: [{ properties: {}, children }] });
+  return { doc, fileName: `Brainstorm_${isoDay()}.docx` };
+}
+
+export function buildFactoidsDocx(docx: DocxModule, result: FactoidsOutput, ctx: DocxContext): BuiltDocx {
+  if (!Array.isArray(result.factoids)) {
+    throw new Error('Missing required factoids data for export.');
+  }
+  const { Document, Paragraph, TextRun, HeadingLevel, AlignmentType } = docx;
+  const { t } = ctx;
+
+  const factoids = result.factoids || [];
+  const factoidsSection = factoids.length > 0
+    ? factoids.flatMap((f, i) => [
+      new Paragraph({
+        children: [new TextRun({ text: `${i + 1}. ${f.shortClaim}`, bold: true })],
+        spacing: { before: 200, after: 100 },
+      }),
+      new Paragraph({
+        children: [new TextRun({ text: `${t('export.keyFigure')}: `, italics: true }), new TextRun(f.keyFigure || '')],
+        spacing: { after: 50 },
+      }),
+      new Paragraph({
+        children: [new TextRun({ text: `${t('export.context')}: `, italics: true }), new TextRun(f.context || '')],
+        spacing: { after: 50 },
+      }),
+      new Paragraph({
+        children: [new TextRun({ text: `${t('export.howToUse')}: `, italics: true }), new TextRun(f.howToUse || '')],
+        spacing: { after: 50 },
+      }),
+      new Paragraph({
+        children: [
+          new TextRun({ text: `${t('export.source')}: `, italics: true }),
+          new TextRun(`${f.citation?.title || 'Unknown'} - ${f.citation?.publisher || 'Unknown'}`),
+        ],
+        spacing: { after: 200 },
+      }),
+    ])
+    : [new Paragraph({ text: t('export.noFactoids'), spacing: { after: 200 } })];
+
+  const warnings = result.warnings || [];
+  const warningsSection = warnings.length > 0
+    ? warnings.map(w => new Paragraph({ text: `⚠ ${w}`, spacing: { after: 75 } }))
+    : [];
+
+  const doc = new Document({
+    sections: [{
+      properties: {},
+      children: [
+        new Paragraph({
+          text: t('export.researchFactoids'),
+          heading: HeadingLevel.HEADING_1,
+          alignment: AlignmentType.CENTER,
+          spacing: { after: 400 },
+        }),
+        new Paragraph({ text: "FACTS & EVIDENCE", heading: HeadingLevel.HEADING_2 }),
+        ...factoidsSection,
+        ...(warningsSection.length > 0 ? [
+          new Paragraph({ text: "WARNINGS", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
+          ...warningsSection,
+        ] : []),
+      ],
+    }],
+  });
+
+  return { doc, fileName: `Factoids_${isoDay()}.docx` };
+}
+
+// The website's src/lib/export-sparring-labels.ts reads these through its i18n
+// instance for the PDF export too; these take `t` so core stays i18n-free.
+function sparringDuration(seconds: number): string {
+  const totalSeconds = Math.max(0, Math.round(seconds));
+  const minutes = Math.floor(totalSeconds / 60);
+  const remainder = String(totalSeconds % 60).padStart(2, '0');
+  return `${minutes}:${remainder}`;
+}
+
+function sparringSideLabel(t: DocxContext['t'], side: SparringSession['userSide']): string {
+  return side === 'pro' ? t('export.proposition') : t('export.opposition');
+}
+
+function sparringWinnerLabel(t: DocxContext['t'], session: SparringSession): string {
+  const winner = session.scorecard?.winner;
+  if (winner === 'user') return t('export.sparringUser');
+  if (winner === 'ai') return t('export.sparringOpponent');
+  return t('export.sparringTie');
+}
+
+export function buildSparringDocx(docx: DocxModule, session: SparringSession, ctx: DocxContext): BuiltDocx {
+  const { Document, Paragraph, TextRun, HeadingLevel, AlignmentType } = docx;
+  const { t } = ctx;
+
+  const totalTimeUsedSeconds = session.speeches.reduce((total, speech) => total + speech.timeUsedSeconds, 0);
+  const totalTimeLimitSeconds = session.speeches.reduce((total, speech) => total + speech.timeLimitSeconds, 0);
+  const scorecard = session.scorecard;
+  const metadata = [
+    [t('export.motion'), session.motion],
+    [t('export.sparringFormat'), t(`sparring.format.${session.format}`, { defaultValue: session.format.toUpperCase() })],
+    [t('export.side'), sparringSideLabel(t, session.userSide)],
+    [t('export.sparringDifficulty'), t(`sparring.difficulty.${session.difficulty}`, { defaultValue: session.difficulty })],
+    [t('export.sparringCompleted'), ctx.formatDateTime(new Date(session.updatedAt))],
+    [t('export.sparringTimeUsed'), `${sparringDuration(totalTimeUsedSeconds)} / ${sparringDuration(totalTimeLimitSeconds)}`],
+  ].map(([label, value]) => new Paragraph({
+    children: [new TextRun({ text: `${label}: `, bold: true }), new TextRun(value)],
+    spacing: { after: 100 },
+  }));
+
+  const scorecardContent = scorecard
+    ? [
+      new Paragraph({ text: t('export.sparringTotals').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 300, after: 150 } }),
+      new Paragraph({
+        children: [
+          new TextRun({ text: `${t('export.sparringUser')}: `, bold: true }),
+          new TextRun(`${scorecard.userScore}/100`),
+          new TextRun({ text: `   ${t('export.sparringOpponent')}: `, bold: true }),
+          new TextRun(`${scorecard.aiScore}/100`),
+        ],
+        spacing: { after: 100 },
+      }),
+      new Paragraph({
+        children: [new TextRun({ text: `${t('export.sparringWinner')}: `, bold: true }), new TextRun(sparringWinnerLabel(t, session))],
+        spacing: { after: 200 },
+      }),
+      new Paragraph({ text: t('export.sparringCategories').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 200, after: 150 } }),
+      ...scorecard.categories.flatMap((category) => [
+        new Paragraph({
+          children: [new TextRun({ text: `${t(`sparring.category.${category.name}`, { defaultValue: category.name })}: `, bold: true }), new TextRun(`${category.userScore}/25 ${t('export.sparringUser').toLowerCase()} | ${category.aiScore}/25 ${t('export.sparringOpponent').toLowerCase()}`)],
+          spacing: { after: 75 },
+        }),
+        new Paragraph({ text: category.feedback, spacing: { after: 150 } }),
+      ]),
+      new Paragraph({ text: t('export.sparringFeedback').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 200, after: 150 } }),
+      new Paragraph({ text: scorecard.verdict, spacing: { after: 100 } }),
+      new Paragraph({ text: scorecard.overallFeedback, spacing: { after: 150 } }),
+      ...(scorecard.keyMoments.length > 0
+        ? [
+          new Paragraph({ text: t('export.sparringKeyMoments'), heading: HeadingLevel.HEADING_2, spacing: { before: 150, after: 75 } }),
+          ...scorecard.keyMoments.map((moment) => new Paragraph({ text: `• ${moment}`, spacing: { after: 75 } })),
+        ]
+        : []),
+      ...(scorecard.improvementAreas.length > 0
+        ? [
+          new Paragraph({ text: t('export.sparringImprovementAreas'), heading: HeadingLevel.HEADING_2, spacing: { before: 150, after: 75 } }),
+          ...scorecard.improvementAreas.map((area) => new Paragraph({ text: `• ${area}`, spacing: { after: 75 } })),
+        ]
+        : []),
+    ]
+    : [
+      new Paragraph({ text: t('export.sparringScorecardUnavailable'), spacing: { before: 300, after: 150 } }),
+    ];
+
+  const transcriptContent = session.speeches.length > 0
+    ? session.speeches.flatMap((speech, index) => [
+      new Paragraph({
+        children: [new TextRun({ text: `${index + 1}. ${t(`sparring.turns.${speech.turnId}`, { defaultValue: speech.role })}`, bold: true })],
+        spacing: { before: 200, after: 75 },
+      }),
+      new Paragraph({
+        children: [
+          new TextRun({ text: `${t('export.side')}: `, bold: true }),
+          new TextRun(sparringSideLabel(t, speech.side)),
+          new TextRun({ text: `   ${t('export.sparringTimeUsed')}: `, bold: true }),
+          new TextRun(`${sparringDuration(speech.timeUsedSeconds)} / ${sparringDuration(speech.timeLimitSeconds)}`),
+        ],
+        spacing: { after: 75 },
+      }),
+      new Paragraph({ text: speech.content, spacing: { after: 150 } }),
+    ])
+    : [new Paragraph({ text: t('export.sparringNoTranscript'), spacing: { after: 150 } })];
+
+  const doc = new Document({
+    sections: [{
+      properties: {},
+      children: [
+        new Paragraph({
+          text: t('export.sparringTranscript'),
+          heading: HeadingLevel.HEADING_1,
+          alignment: AlignmentType.CENTER,
+          spacing: { after: 250 },
+        }),
+        ...metadata,
+        ...scorecardContent,
+        new Paragraph({ text: t('export.sparringTranscript').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 300, after: 150 } }),
+        ...transcriptContent,
+      ],
+    }],
+  });
+
+  return { doc, fileName: `SparringTranscript_${new Date(session.updatedAt).toISOString().slice(0, 10)}.docx` };
+}
diff --git a/packages/core/src/flowchart.ts b/packages/core/src/flowchart.ts
index ff6aa5a69..4fdbdd5ac 100644
--- a/packages/core/src/flowchart.ts
+++ b/packages/core/src/flowchart.ts
@@ -7,6 +7,8 @@
  * a spread, so fields this file does not know (positions, sizes, handles,
  * styles React Flow added) survive the round trip to the website.
  */
+import { readCase } from './ai/case-view';
+import type { GenerateOutput } from './ai/schemas/generate';
 
 export const FLOW_NODE_TYPES = ['thesis', 'contention', 'attack', 'rebuttal', 'dropped'] as const;
 export type FlowNodeType = (typeof FLOW_NODE_TYPES)[number];
@@ -389,17 +391,9 @@ function caseNode(
   };
 }
 
-/** The parts of a generated case a flowchart is built from. */
-export interface CaseForFlowchart {
-  caseStructure: { thesis: string };
-  contentions: { claim: string; evidence?: string }[];
-  predictedOpponentCase?: { likelyArguments?: string[] };
-  counters?: { targetArgument?: string; counterpoint?: string; rebuttal?: string }[];
-}
-
-/** A generated case has what a flowchart needs: a thesis and at least one contention. */
-export const caseHasFlowchart = (result: CaseForFlowchart | null | undefined): boolean =>
-  Boolean(result?.caseStructure?.thesis && result.contentions?.length);
+/** A generated case has what a flowchart needs: a thesis and an argument, R2's backed-up arguments, or a Conclusor's reasons why we win. */
+export const caseHasFlowchart = (result: GenerateOutput | null | undefined): result is GenerateOutput =>
+  Boolean(result?.caseStructure?.thesis && (result.contentions?.length || result.reinforce?.length || result.whyWeWin?.length));
 
 const NODE_GAP_X = 300;
 const ROW_GAP_Y = 150;
@@ -443,46 +437,54 @@ function answeredAttack(target: string | undefined, attacks: string[], index: nu
 
 /**
  * Maps a generated case onto a map, as the website's Flowcharts button does:
- * the thesis, one node per contention with its claim and evidence, the
- * predicted opposing arguments, and the counters.
+ * the thesis, one node per argument with its title, point and evidence (R2's
+ * backed-up arguments or a Conclusor's reasons why we win stand in for
+ * arguments), what the other side will say, and our answers.
  */
-export function flowchartFromCase(result: CaseForFlowchart, t: TranslateNumbered): { nodes: FlowNode[]; edges: FlowEdge[] } {
+export function flowchartFromCase(result: GenerateOutput, t: TranslateNumbered): { nodes: FlowNode[]; edges: FlowEdge[] } {
   const nodes: FlowNode[] = [];
   const edges: FlowEdge[] = [];
+  const view = readCase(result);
 
   nodes.push(caseNode('thesis', { x: 400, y: 50 }, 'thesis', t, { labelKey: 'flowchart.fromCase.thesis', description: result.caseStructure.thesis }));
 
-  const contentions = result.contentions;
-  const contentionTier = placeTier(contentions.length, 230);
-  contentions.forEach((contention, i) => {
+  const points = view.arguments.length
+    ? view.arguments.map((argument) => [argument.title, argument.point, argument.evidence].filter(Boolean).join('\n'))
+    : view.reinforce.length
+      ? view.reinforce.map((item) => [item.argument, item.text].filter(Boolean).join('\n'))
+      : view.whyWeWin;
+  const contentionTier = placeTier(points.length, 230);
+  points.forEach((description, i) => {
     const id = `c-${i}`;
     nodes.push(caseNode(id, contentionTier.position(i), 'contention', t, {
       labelKey: 'flowchart.fromCase.argument',
       labelNumber: i + 1,
-      description: [contention.claim, contention.evidence].filter((part) => part?.trim()).join('\n'),
+      description,
       strength: 'strong',
     }));
     edges.push({ id: `e-thesis-${id}`, source: 'thesis', target: id, markerEnd: { type: 'arrowclosed' } });
   });
 
-  const attacks = result.predictedOpponentCase?.likelyArguments ?? [];
+  // Older cases listed the opposing arguments; newer ones name each in "If they say…".
+  const listed = (result.predictedOpponentCase?.likelyArguments ?? []).filter((argument) => argument?.trim());
+  const attacks = listed.length ? listed : view.ifTheySay.map((answer) => answer.theySay).filter(Boolean);
   const attackTier = placeTier(attacks.length, contentionTier.bottom);
   attacks.forEach((argument, i) => {
     const id = `a-${i}`;
     nodes.push(caseNode(id, attackTier.position(i), 'attack', t, { labelKey: 'flowchart.fromCase.attack', labelNumber: i + 1, description: argument }));
-    edges.push(flowEdgeOfKind('attack', contentions.length ? `c-${i % contentions.length}` : 'thesis', id, t));
+    edges.push(flowEdgeOfKind('attack', points.length ? `c-${i % points.length}` : 'thesis', id, t));
   });
 
-  // A counter answers one of their arguments, so it hangs off that attack.
-  const counters = result.counters ?? [];
-  const counterTier = placeTier(counters.length, attackTier.bottom);
-  counters.forEach((counter, i) => {
+  // An answer replies to one of their arguments, so it hangs off that attack.
+  const answers = view.ifTheySay;
+  const counterTier = placeTier(answers.length, attackTier.bottom);
+  answers.forEach((answer, i) => {
     const id = `r-${i}`;
-    const attackIndex = answeredAttack(counter.targetArgument, attacks, i);
+    const attackIndex = answeredAttack(answer.theySay, attacks, i);
     nodes.push(caseNode(id, counterTier.position(i), 'rebuttal', t, {
       labelKey: 'flowchart.fromCase.rebuttal',
       labelNumber: i + 1,
-      description: counter.rebuttal || counter.counterpoint || '',
+      description: answer.inRound ?? answer.weAnswer,
     }));
     edges.push(flowEdgeOfKind('rebuttal', attackIndex >= 0 ? `a-${attackIndex}` : 'thesis', id, t));
   });
diff --git a/packages/core/src/trial.ts b/packages/core/src/trial.ts
new file mode 100644
index 000000000..7376d46d3
--- /dev/null
+++ b/packages/core/src/trial.ts
@@ -0,0 +1,13 @@
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Calendar days from today to a trial's end on the reader's clock; 0 on its
+ * last day, null once it has ended or when the date cannot be read. The
+ * website's trial banner and the app's share it.
+ */
+export function trialDaysLeft(endsAt: string, now = new Date()): number | null {
+  const end = new Date(endsAt);
+  if (Number.isNaN(end.getTime()) || end.getTime() <= now.getTime()) return null;
+  const startOfDay = (date: Date) => new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+  return Math.round((startOfDay(end) - startOfDay(now)) / DAY_MS);
+}
diff --git a/public/ai-debate-case-generator/index.html b/public/ai-debate-case-generator/index.html
index b02ed87e1..440a48a0e 100644
--- a/public/ai-debate-case-generator/index.html
+++ b/public/ai-debate-case-generator/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>AI Debate Case Generator with Citations | DebateOwl</title>
-  <meta name="description" content="DebateOwl drafts a structured debate case with claims, warrants, impacts and cited evidence leads that you check before taking it into a round." />
+  <meta name="description" content="DebateOwl turns a motion into a ready-to-read debate case: an opening, arguments with evidence, If they say… replies, a closing line and sources to check." />
   <meta name="robots" content="index, follow, max-snippet:-1, max-image-preview:large" />
   <link rel="canonical" href="https://debateowl.com/ai-debate-case-generator" />
   <meta name="author" content="DebateOwl" />
@@ -16,21 +16,21 @@
   <meta property="og:type" content="article" />
   <meta property="og:site_name" content="DebateOwl" />
   <meta property="og:title" content="AI Debate Case Generator with Citations | DebateOwl" />
-  <meta property="og:description" content="DebateOwl drafts a structured debate case with claims, warrants, impacts and cited evidence leads that you check before taking it into a round." />
+  <meta property="og:description" content="DebateOwl turns a motion into a ready-to-read debate case: an opening, arguments with evidence, If they say… replies, a closing line and sources to check." />
   <meta property="og:url" content="https://debateowl.com/ai-debate-case-generator" />
   <meta property="og:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta property="og:image:width" content="1200" />
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="AI Debate Case Generator with Citations | DebateOwl" />
-  <meta name="twitter:description" content="DebateOwl drafts a structured debate case with claims, warrants, impacts and cited evidence leads that you check before taking it into a round." />
+  <meta name="twitter:description" content="DebateOwl turns a motion into a ready-to-read debate case: an opening, arguments with evidence, If they say… replies, a closing line and sources to check." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"AI Debate Case Generator with Citations","name":"AI Debate Case Generator with Citations | DebateOwl","url":"https://debateowl.com/ai-debate-case-generator","description":"DebateOwl drafts a structured debate case with claims, warrants, impacts and cited evidence leads that you check before taking it into a round.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can an AI debate case generator write a case I can actually use?","acceptedAnswer":{"@type":"Answer","text":"Yes, as a draft. DebateOwl's case generator turns a motion into a structured case (thesis, framework, contentions with warrants and impacts, the likely opposing case and counters) and lists the web sources it used, which you then verify and rewrite in your own words. Treat its citations as research leads: open every source and confirm the exact claim. The judgement calls, such as which contention to cut and where to pre-empt the opposition, stay with you."}},{"@type":"Question","name":"Does the case generator write a complete case?","acceptedAnswer":{"@type":"Answer","text":"It writes a complete draft: thesis, framework, contentions with warrants and impacts, the likely opposing case and counters. Treat it as a structure to cut, verify and rewrite in your own words."}},{"@type":"Question","name":"Are the generated citations reliable?","acceptedAnswer":{"@type":"Answer","text":"They are research leads. Every draft is researched on the web and lists the sources it found, and a contention that still needs evidence is marked Needs Source. Open every source, confirm the exact claim and record the full citation before using it."}},{"@type":"Question","name":"Which debate formats does the generator support?","acceptedAnswer":{"@type":"Answer","text":"Set the Current Debate's format to British Parliamentary, Policy, Classroom or Custom, and Generate reads it along with the debate's Instructions. Generate's own speaker roles (introductor, R1, R2 and conclusor) follow the School 4-6-6-3 format. For WSDC, Public Forum and Lincoln-Douglas, use Custom and describe the structure in the Instructions."}},{"@type":"Question","name":"Can I change one part of a case without starting over?","acceptedAnswer":{"@type":"Answer","text":"Yes. Regenerate a single section and the rest of the case stays on screen unchanged."}},{"@type":"Question","name":"Can I export a generated case?","acceptedAnswer":{"@type":"Answer","text":"Yes. Cases export to PDF and DOCX, and cases created in a Current Debate are saved to it automatically."}},{"@type":"Question","name":"Is there a free AI debate case generator?","acceptedAnswer":{"@type":"Answer","text":"DebateOwl's case generator is included in the 3-day free trial, with no credit card, and then in Pro at $5/month + tax; there is no permanent free plan. Without an account you can use the free debate timer, motion generator, flow sheet and speech time calculator, but not the case generator."}},{"@type":"Question","name":"Can AI write a Public Forum case?","acceptedAnswer":{"@type":"Answer","text":"It can draft one. Set the Current Debate's format to Custom and describe the Public Forum structure in its Instructions, since Generate's own speaker roles follow School 4-6-6-3. A PF constructive is four minutes, which usually fits two contentions with evidence, so cut the draft to that and verify every source."}},{"@type":"Question","name":"Is using an AI case generator cheating?","acceptedAnswer":{"@type":"Answer","text":"Using it to draft and research before a round is preparation, but check your league's and your school's rules first: most leagues forbid electronic help during a round. Verify every source, rewrite the case in your own words and make sure you can defend each contention, because a case you cannot explain is easy to beat."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"AI Debate Case Generator with Citations","item":"https://debateowl.com/ai-debate-case-generator"}]},{"@type":"DefinedTerm","name":"AI debate case generator","description":"A tool that drafts a debate case for a given motion and side, with claims, warrants, impacts and evidence leads, for a debater to verify and adapt.","url":"https://debateowl.com/ai-debate-case-generator#definition"}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"AI Debate Case Generator with Citations","name":"AI Debate Case Generator with Citations | DebateOwl","url":"https://debateowl.com/ai-debate-case-generator","description":"DebateOwl turns a motion into a ready-to-read debate case: an opening, arguments with evidence, If they say… replies, a closing line and sources to check.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can an AI debate case generator write a case I can actually use?","acceptedAnswer":{"@type":"Answer","text":"Yes, as a draft. DebateOwl's case generator turns a motion into a ready-to-read case: an opening, arguments with explanation, evidence and why it matters, \"If they say… we answer…\" replies, a closing line and the sources it used. You then verify it and rewrite it in your own words. Treat its citations as research leads: open every source and confirm the exact claim. The judgement calls, such as which argument to cut and where to answer the opposition early, stay with you."}},{"@type":"Question","name":"Does the case generator write a complete case?","acceptedAnswer":{"@type":"Answer","text":"It writes a complete draft: an opening, arguments with explanation, evidence and why each matters, \"If they say… we answer…\" replies, a closing line and the sources it cites. Treat it as a structure to cut, verify and rewrite in your own words."}},{"@type":"Question","name":"Are the generated citations reliable?","acceptedAnswer":{"@type":"Answer","text":"They are research leads. Every draft is researched on the web and lists the sources it cites, and an argument that still needs evidence is marked Needs Source. Open every source, confirm the exact claim and record the full citation before using it."}},{"@type":"Question","name":"Which debate formats does the generator support?","acceptedAnswer":{"@type":"Answer","text":"Set the Current Debate's format to British Parliamentary, Policy, Classroom or Custom, and Generate reads it along with the debate's Instructions. Generate's own speaker roles (introductor, R1, R2 and conclusor) follow the School 4-6-6-3 format. For WSDC, Public Forum and Lincoln-Douglas, use Custom and describe the structure in the Instructions."}},{"@type":"Question","name":"Can I change one part of a case without starting over?","acceptedAnswer":{"@type":"Answer","text":"Yes. Regenerate a single section and the rest of the case stays on screen unchanged."}},{"@type":"Question","name":"Can I export a generated case?","acceptedAnswer":{"@type":"Answer","text":"Yes. Cases export to PDF and DOCX, and cases created in a Current Debate are saved to it automatically."}},{"@type":"Question","name":"Is there a free AI debate case generator?","acceptedAnswer":{"@type":"Answer","text":"DebateOwl's case generator is included in the 3-day free trial, with no credit card, and then in Pro at $5/month + tax; there is no permanent free plan. Without an account you can use the free debate timer, motion generator, flow sheet and speech time calculator, but not the case generator."}},{"@type":"Question","name":"Can AI write a Public Forum case?","acceptedAnswer":{"@type":"Answer","text":"It can draft one. Set the Current Debate's format to Custom and describe the Public Forum structure in its Instructions, since Generate's own speaker roles follow School 4-6-6-3. A PF constructive is four minutes, which usually fits two arguments with evidence, so cut the draft to that and verify every source."}},{"@type":"Question","name":"Is using an AI case generator cheating?","acceptedAnswer":{"@type":"Answer","text":"Using it to draft and research before a round is preparation, but check your league's and your school's rules first: most leagues forbid electronic help during a round. Verify every source, rewrite the case in your own words and make sure you can defend each argument, because a case you cannot explain is easy to beat."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"AI Debate Case Generator with Citations","item":"https://debateowl.com/ai-debate-case-generator"}]},{"@type":"DefinedTerm","name":"AI debate case generator","description":"A tool that turns a motion into a draft debate case for one side and speaker role, with an opening, arguments backed by evidence, answers to what the other side will say and a source list, for a debater to verify and adapt.","url":"https://debateowl.com/ai-debate-case-generator#definition"}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,12 +39,12 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">AI Debate Case Generator with Citations</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Tool guide</span><h1>AI Debate Case Generator with Citations</h1><p class="lead">Draft faster, verify carefully, and walk into the round with a structured case.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
-      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Can an AI debate case generator write a case I can actually use?</h2><p>Yes, as a draft. DebateOwl&#x27;s case generator turns a motion into a structured case (thesis, framework, contentions with warrants and impacts, the likely opposing case and counters) and lists the web sources it used, which you then verify and rewrite in your own words. Treat its citations as research leads: open every source and confirm the exact claim. The judgement calls, such as which contention to cut and where to pre-empt the opposition, stay with you.</p></section>
-      <section class="article section" aria-label="Definition"><dl id="definition"><dt><strong>What is an AI debate case generator?</strong></dt><dd>A tool that drafts a debate case for a given motion and side, with claims, warrants, impacts and evidence leads, for a debater to verify and adapt.</dd></dl></section>
-      <section class="grid" aria-label="Highlights"><article class="card"><h3>Structured case drafts</h3><p class="muted">Each draft has a thesis, a framework, contentions with warrants and impacts, the case the other side is likely to run, and counters to it.</p></article><article class="card"><h3>Evidence leads</h3><p class="muted">Every draft is researched on the web and lists the sources it found. Check each one against the original before it goes on a card.</p></article><article class="card"><h3>Roles and length</h3><p class="muted">Pick your side and speaker role, then set the case length, the audience level and the tone of the draft.</p></article></section>
-      <div class="article section"><h2>What the case generator produces</h2><p>Generate takes the motion from your Current Debate and returns a structured case, not a block of prose. Every draft has the same parts, so you always know where to look:</p><ul><li>Thesis: the one-sentence reason your side should win.</li><li>Framework: how the judge should decide the round, such as the definition, the burden or the <a href="/how-to-weigh-in-debate">weighing</a> standard you will argue for.</li><li>Contentions: each with a claim, the warrant that makes it true, and the impact that makes it matter.</li><li>Predicted opponent case: the arguments a strong team on the other side is likely to run.</li><li>Counters: first responses to that predicted case.</li></ul><p>Because the opponent case is part of the draft, you start preparing rebuttals at the same time as your own case. When one section is weak, regenerate just that section; the rest of the case stays where it is. Finished cases export to PDF or DOCX.</p><h2>Generated draft vs. finished case: what you still do</h2><div class="table"><table><caption>What the case generator gives you, and what you check before the round</caption><thead><tr><th scope="col">Section</th><th scope="col">The generator gives</th><th scope="col">You check</th></tr></thead><tbody><tr><td data-label="Section">Thesis</td><td data-label="The generator gives">One sentence on why your side should win</td><td data-label="You check">That it answers the motion exactly as worded and you can say it without notes</td></tr><tr><td data-label="Section">Framework</td><td data-label="The generator gives">The definition, burden or weighing standard to argue for</td><td data-label="You check">That it fits your format, for example a value and criterion in Lincoln-Douglas</td></tr><tr><td data-label="Section">Contentions</td><td data-label="The generator gives">A claim, the warrant that makes it true and the impact that makes it matter</td><td data-label="You check">Which ones clash with the other side; cut the rest to fit your speech time</td></tr><tr><td data-label="Section">Predicted opponent case</td><td data-label="The generator gives">The arguments a strong team on the other side is likely to run</td><td data-label="You check">Which of your contentions answers each one</td></tr><tr><td data-label="Section">Counters</td><td data-label="The generator gives">First responses to the predicted case</td><td data-label="You check">That each response is short enough to deliver as a rebuttal block</td></tr><tr><td data-label="Section">Sources</td><td data-label="The generator gives">The web sources it found, with contentions that still need evidence marked Needs Source</td><td data-label="You check">Open every original, confirm the exact claim and record the full citation</td></tr></tbody></table></div><h2>From motion to verified case in seven steps</h2><ol><li>Start a Current Debate with the exact motion wording. Small wording changes, such as should against would, change the burden.</li><li>Add the sources you already trust to the Library. Active sources are used when the case is generated, so the draft builds on your research instead of ignoring it.</li><li>Choose your side and speaker role: introductor, R1, R2 or conclusor. Under More options, set the length (two, three or four contentions), the audience level and the tone. If you need a particular angle, for example a principled argument or an economic one, put it in the Current Debate&#x27;s Instructions.</li><li>Generate the case. Generate researches the motion on the web every time, lists the sources it found under the draft, and saves the relevant ones to the debate&#x27;s Library.</li><li>Read the predicted opponent case first and decide which of your contentions actually answers it. Cut contentions that do not clash with anything.</li><li>Regenerate any section that is vague, then verify every evidence lead against its original source.</li><li>Rewrite the final case in your own words and time a full reading of it before you call it ready.</li></ol><h2>Worked example: a generated case, and what the debater changed</h2><div class="card"><h3>Motion: This house would introduce a four-day school week</h3><p><strong>Side:</strong> Proposition.</p><p><strong>Thesis:</strong> A shorter week concentrates instruction where it works and gives schools a recruitment advantage they cannot buy with pay.</p><p><strong>Framework:</strong> The round should be decided by learning outcomes for students across the school, not by the convenience of any single group.</p><p><strong>Contention 1:</strong> Teacher retention. Claim: a four-day week keeps experienced teachers. Warrant: schools competing for staff cannot always raise salaries, but they can offer time. Impact: experienced teachers are among the strongest in-school drivers of student learning.</p><p><strong>Predicted opposition:</strong> Childcare costs for working parents on the fifth day, and lost instruction time for students who are already behind.</p><p><strong>Counter:</strong> Schools can run an optional fifth-day programme for families who need it, and longer remaining days protect total instruction hours.</p><p><strong>Evidence lead to verify:</strong> Research on districts that moved to four-day weeks, looking at attendance, teacher turnover and test results. Read the methodology: results differ between rural and urban districts.</p><p><strong>What the debater changed:</strong> Cut a weaker cost-saving contention the opposition would easily mitigate, and moved the instruction-hours counter into the first speech so it was on the table before the opposition raised it.</p></div><p>The draft gave the debater a full structure in minutes. The judgement calls, which contention to cut and where to pre-empt the opposition, were still theirs, and that is where the round was won.</p><h2>Checking citations before they reach a card</h2><p>Generated evidence is a starting point. Before any source goes into a speech:</p><ul><li>Open the original. If you cannot find it, do not use it.</li><li>Find the exact sentence that supports your claim, and check that the surrounding paragraph does not qualify it.</li><li>Check the date, the author and who published it. A think-tank brief and a peer-reviewed study carry different weight.</li><li>Make sure the evidence supports your link, not just your topic. A study showing four-day weeks save money does not prove they improve learning.</li><li>Record the full citation so you can produce it if an opponent or judge asks.</li></ul><p>Factoids is useful here: give it a single statement from your case and it researches that statement and suggests searches you can use to confirm it.</p><h2>Adapting a generated case to your format</h2><h3>World Schools (WSDC)</h3><p>A WSDC case is split between the first and second speakers, with a team line both can repeat. Use the thesis as the team line, give the first speaker the framework and the first contention, and keep the strongest contention for the second speaker so the case builds rather than front-loads. Leave the Current Debate&#x27;s format on Custom and describe this split in its Instructions.</p><h3>British Parliamentary (BP)</h3><p>Set the Current Debate&#x27;s format to <a href="/british-parliamentary-debate">British Parliamentary</a> and name your team position in its Instructions; Generate&#x27;s own role options follow the School 4-6-6-3 speakers. Opening government needs a clear definition and mechanism in the draft. Closing teams should treat the generated case as material the opening half will probably use, and look in the predicted opponent case for an extension nobody else in the room is likely to run.</p><h3>Public Forum (PF)</h3><p>A PF constructive is four minutes, which usually means two contentions with evidence, not four. Since PF teams often find out their side shortly before the round, generate both sides of the resolution in the same debate and prepare the counters for each.</p><h3>Lincoln-Douglas (LD)</h3><p>In LD, the framework section becomes your <a href="/lincoln-douglas-debate">value and criterion</a>. Check that every contention explicitly links back to the criterion; if one does not, add your criterion to the Current Debate&#x27;s Instructions and regenerate the contentions. Prepare a short defence of the criterion itself, because the negative will often attack it first.</p><h2>Mistakes to avoid with generated cases</h2><ul><li>Reading the draft in round. Judges hear the difference between a case you wrote and one you are reading for the first time.</li><li>Keeping every contention. Three well-defended points beat five thin ones.</li><li>Skipping the predicted opponent case. It is the fastest route to your rebuttals.</li><li>Citing an evidence lead you never opened.</li></ul></div>
-      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>Does the case generator write a complete case?</summary><p>It writes a complete draft: thesis, framework, contentions with warrants and impacts, the likely opposing case and counters. Treat it as a structure to cut, verify and rewrite in your own words.</p></details><details><summary>Are the generated citations reliable?</summary><p>They are research leads. Every draft is researched on the web and lists the sources it found, and a contention that still needs evidence is marked Needs Source. Open every source, confirm the exact claim and record the full citation before using it.</p></details><details><summary>Which debate formats does the generator support?</summary><p>Set the Current Debate&#x27;s format to British Parliamentary, Policy, Classroom or Custom, and Generate reads it along with the debate&#x27;s Instructions. Generate&#x27;s own speaker roles (introductor, R1, R2 and conclusor) follow the School 4-6-6-3 format. For WSDC, Public Forum and Lincoln-Douglas, use Custom and describe the structure in the Instructions.</p></details><details><summary>Can I change one part of a case without starting over?</summary><p>Yes. Regenerate a single section and the rest of the case stays on screen unchanged.</p></details><details><summary>Can I export a generated case?</summary><p>Yes. Cases export to PDF and DOCX, and cases created in a Current Debate are saved to it automatically.</p></details><details><summary>Is there a free AI debate case generator?</summary><p>DebateOwl&#x27;s case generator is included in the 3-day free trial, with no credit card, and then in Pro at $5/month + tax; there is no permanent free plan. Without an account you can use the free debate timer, motion generator, flow sheet and speech time calculator, but not the case generator.</p></details><details><summary>Can AI write a Public Forum case?</summary><p>It can draft one. Set the Current Debate&#x27;s format to Custom and describe the Public Forum structure in its Instructions, since Generate&#x27;s own speaker roles follow School 4-6-6-3. A PF constructive is four minutes, which usually fits two contentions with evidence, so cut the draft to that and verify every source.</p></details><details><summary>Is using an AI case generator cheating?</summary><p>Using it to draft and research before a round is preparation, but check your league&#x27;s and your school&#x27;s rules first: most leagues forbid electronic help during a round. Verify every source, rewrite the case in your own words and make sure you can defend each contention, because a case you cannot explain is easy to beat.</p></details></section>
+      <header class="hero"><span class="eyebrow">Tool guide</span><h1>AI Debate Case Generator with Citations</h1><p class="lead">Draft faster, verify carefully, and walk into the round with a case you can read out.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Can an AI debate case generator write a case I can actually use?</h2><p>Yes, as a draft. DebateOwl&#x27;s case generator turns a motion into a ready-to-read case: an opening, arguments with explanation, evidence and why it matters, &quot;If they say… we answer…&quot; replies, a closing line and the sources it used. You then verify it and rewrite it in your own words. Treat its citations as research leads: open every source and confirm the exact claim. The judgement calls, such as which argument to cut and where to answer the opposition early, stay with you.</p></section>
+      <section class="article section" aria-label="Definition"><dl id="definition"><dt><strong>What is an AI debate case generator?</strong></dt><dd>A tool that turns a motion into a draft debate case for one side and speaker role, with an opening, arguments backed by evidence, answers to what the other side will say and a source list, for a debater to verify and adapt.</dd></dl></section>
+      <section class="grid" aria-label="Highlights"><article class="card"><h3>A case you can read out</h3><p class="muted">Each draft has an opening, arguments with an explanation, evidence and why it matters, &quot;If they say… we answer…&quot; replies, a closing line and the sources it cites.</p></article><article class="card"><h3>Evidence leads</h3><p class="muted">Every draft is researched on the web, names the source and year in each piece of evidence and lists its sources at the end. Check each one against the original before it goes on a card.</p></article><article class="card"><h3>Roles and length</h3><p class="muted">Pick your side and speaker role, then set the case length, the audience level and the tone of the draft.</p></article></section>
+      <div class="article section"><h2>What the case generator produces</h2><p>Generate takes the motion from your Current Debate and returns a case you can read out, not a block of prose. Every draft has the same parts, in the order you would say them:</p><ul><li>Opening: a hook that makes the judge listen, then the line &quot;Today we will show N arguments that prove…&quot;.</li><li>Arguments: each with a short title, the point in one sentence, an explanation of why it is true, evidence that names its source and year, and why it matters.</li><li>If they say…: the claims the other side is likely to make, each with our answer and, when there is one, the source behind it.</li><li>Closing line: one sentence that ties back to the opening.</li><li>Sources: every source the case cites, with the organisation, the year, the claim it supports and the link.</li></ul><p>Your speaker role shapes the speech. The introductor gets the opening and short headline arguments, plus one line on what a motion term means when it is genuinely unclear. R1 gets the full arguments. R2 brings no new arguments: it spends about two minutes backing up the team&#x27;s arguments, then answers the other side with five or six &quot;If they say…&quot; blocks. The conclusor brings no new arguments: it gets two or three reasons why your side won and the closing line.</p><p>Because the answers to the other side are part of the draft, you start preparing rebuttals at the same time as your own case. When one section is weak, regenerate just that section; the rest of the case stays where it is. Finished cases export to PDF or DOCX.</p><h2>Generated draft vs. finished case: what you still do</h2><div class="table"><table><caption>What the case generator gives you, and what you check before the round</caption><thead><tr><th scope="col">Section</th><th scope="col">The generator gives</th><th scope="col">You check</th></tr></thead><tbody><tr><td data-label="Section">Opening</td><td data-label="The generator gives">A hook and the line &quot;Today we will show N arguments that prove…&quot;</td><td data-label="You check">That the hook is true, the line answers the motion exactly as worded and you can say it without notes</td></tr><tr><td data-label="Section">Arguments</td><td data-label="The generator gives">A title, the point, an explanation, evidence and why it matters</td><td data-label="You check">Which ones meet what the other side will say; cut the rest to fit your speech time</td></tr><tr><td data-label="Section">If they say…</td><td data-label="The generator gives">The other side&#x27;s likely claims, each with our answer</td><td data-label="You check">That each answer meets the claim as they would make it and is short enough to say in a rebuttal</td></tr><tr><td data-label="Section">Closing line</td><td data-label="The generator gives">One sentence that ties back to the opening</td><td data-label="You check">That it sums up the case in words you would actually say</td></tr><tr><td data-label="Section">Sources</td><td data-label="The generator gives">Every source the case cites, with arguments that still need evidence marked Needs Source</td><td data-label="You check">Open every original, confirm the exact claim and record the full citation</td></tr></tbody></table></div><h2>From motion to verified case in seven steps</h2><ol><li>Start a Current Debate with the exact motion wording. Small wording changes, such as should against would, change the <a href="/debate-motion-analysis">burden</a>.</li><li>Add the sources you already trust to the Library. Active sources are used when the case is generated, so the draft builds on your research instead of ignoring it.</li><li>Choose your side and speaker role: introductor, R1, R2 or conclusor. Under More options, set the length, the audience level and the tone. Length sets two, three or four arguments for the introductor and R1, and for R2 how many &quot;If they say…&quot; answers you get. If you need a particular angle, for example a principled argument or an economic one, put it in the Current Debate&#x27;s Instructions.</li><li>Generate the case. Generate researches the motion on the web every time, lists the sources it found under the draft, and saves the relevant ones to the debate&#x27;s Library.</li><li>Read the &quot;If they say…&quot; answers first and decide which of your arguments actually meets each claim. Cut arguments that do not clash with anything.</li><li>Regenerate any section that is vague, then verify every evidence lead against its original source.</li><li>Rewrite the final case in your own words and time a full reading of it before you call it ready.</li></ol><h2>Worked example: a generated case, and what the debater changed</h2><div class="card"><h3>Motion: This house would introduce a four-day school week</h3><p><strong>Side and role:</strong> Proposition, R1.</p><p><strong>Opening:</strong> A school that cannot pay more can still offer its teachers time. Today we will show two arguments that prove a four-day week helps students learn.</p><p><strong>Argument 1, keeping teachers:</strong> Point: a four-day week keeps experienced teachers. Explanation: schools competing for staff cannot always raise salaries, but they can offer time. Why it matters: experienced teachers are among the strongest in-school drivers of student learning.</p><p><strong>If they say:</strong> Working parents will pay for childcare on the fifth day, and students who are already behind lose teaching time.</p><p><strong>We answer:</strong> Schools can run an optional fifth-day programme for families who need it, and longer remaining days protect total teaching hours.</p><p><strong>Closing line:</strong> That is why a four-day week is the cheapest way to keep the teachers students learn most from.</p><p><strong>Evidence lead to verify:</strong> Research on districts that moved to four-day weeks, looking at attendance, teacher turnover and test results. Read the methodology: results differ between rural and urban districts.</p><p><strong>What the debater changed:</strong> Cut a weaker cost-saving argument the opposition would easily answer, and moved the teaching-hours answer into the first speech so it was on the table before the opposition raised it.</p></div><p>The draft gave the debater a full structure in minutes. The judgement calls, which argument to cut and where to answer the opposition early, were still theirs, and that is where the round was won.</p><h2>Checking citations before they reach a card</h2><p>Generated evidence is a starting point. Before any source goes into a speech:</p><ul><li>Open the original. If you cannot find it, do not use it.</li><li>Find the exact sentence that supports your claim, and check that the surrounding paragraph does not qualify it.</li><li>Check the date, the author and who published it. A think-tank brief and a peer-reviewed study carry different weight.</li><li>Make sure the evidence supports your point, not just your topic. A study showing four-day weeks save money does not prove they improve learning.</li><li>Record the full citation so you can produce it if an opponent or judge asks.</li></ul><p>Factoids is useful here: give it a single statement from your case and it researches that statement and suggests searches you can use to confirm it.</p><h2>Adapting a generated case to your format</h2><h3>World Schools (WSDC)</h3><p>A WSDC case is split between the first and second speakers, with a team line both can repeat. Use the opening&#x27;s &quot;we will show&quot; line as the team line, give the first speaker the opening and the first argument, and keep the strongest argument for the second speaker so the case builds rather than front-loads. Leave the Current Debate&#x27;s format on Custom and describe this split in its Instructions.</p><h3>British Parliamentary (BP)</h3><p>Set the Current Debate&#x27;s format to <a href="/british-parliamentary-debate">British Parliamentary</a> and name your team position in its Instructions; Generate&#x27;s own role options follow the School 4-6-6-3 speakers. Opening government needs a clear definition and mechanism, so describe them in the Instructions if the draft does not give them. Closing teams should treat the generated case as material the opening half will probably use, and look in the &quot;If they say…&quot; answers for an extension nobody else in the room is likely to run.</p><h3>Public Forum (PF)</h3><p>A PF constructive is four minutes, which usually means two arguments with evidence, not four. Since PF teams often find out their side shortly before the round, generate both sides of the resolution in the same debate and prepare the answers for each.</p><h3>Lincoln-Douglas (LD)</h3><p>Generate does not write a <a href="/lincoln-douglas-debate">value and criterion</a> for you, so put yours in the Current Debate&#x27;s Instructions before you generate. Then check that each argument&#x27;s why it matters links back to the criterion; if one does not, regenerate the arguments. Prepare a short defence of the criterion itself, because the negative will often attack it first.</p><h2>Mistakes to avoid with generated cases</h2><ul><li>Reading the draft in round. Judges hear the difference between a case you wrote and one you are reading for the first time.</li><li>Keeping every argument. Three well-defended points beat five thin ones.</li><li>Skipping the &quot;If they say…&quot; answers. They are the fastest route to your rebuttals.</li><li>Citing an evidence lead you never opened.</li></ul></div>
+      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>Does the case generator write a complete case?</summary><p>It writes a complete draft: an opening, arguments with explanation, evidence and why each matters, &quot;If they say… we answer…&quot; replies, a closing line and the sources it cites. Treat it as a structure to cut, verify and rewrite in your own words.</p></details><details><summary>Are the generated citations reliable?</summary><p>They are research leads. Every draft is researched on the web and lists the sources it cites, and an argument that still needs evidence is marked Needs Source. Open every source, confirm the exact claim and record the full citation before using it.</p></details><details><summary>Which debate formats does the generator support?</summary><p>Set the Current Debate&#x27;s format to British Parliamentary, Policy, Classroom or Custom, and Generate reads it along with the debate&#x27;s Instructions. Generate&#x27;s own speaker roles (introductor, R1, R2 and conclusor) follow the School 4-6-6-3 format. For WSDC, Public Forum and Lincoln-Douglas, use Custom and describe the structure in the Instructions.</p></details><details><summary>Can I change one part of a case without starting over?</summary><p>Yes. Regenerate a single section and the rest of the case stays on screen unchanged.</p></details><details><summary>Can I export a generated case?</summary><p>Yes. Cases export to PDF and DOCX, and cases created in a Current Debate are saved to it automatically.</p></details><details><summary>Is there a free AI debate case generator?</summary><p>DebateOwl&#x27;s case generator is included in the 3-day free trial, with no credit card, and then in Pro at $5/month + tax; there is no permanent free plan. Without an account you can use the free debate timer, motion generator, flow sheet and speech time calculator, but not the case generator.</p></details><details><summary>Can AI write a Public Forum case?</summary><p>It can draft one. Set the Current Debate&#x27;s format to Custom and describe the Public Forum structure in its Instructions, since Generate&#x27;s own speaker roles follow School 4-6-6-3. A PF constructive is four minutes, which usually fits two arguments with evidence, so cut the draft to that and verify every source.</p></details><details><summary>Is using an AI case generator cheating?</summary><p>Using it to draft and research before a round is preparation, but check your league&#x27;s and your school&#x27;s rules first: most leagues forbid electronic help during a round. Verify every source, rewrite the case in your own words and make sure you can defend each argument, because a case you cannot explain is easy to beat.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
     <section class="section article" aria-labelledby="related"><h2 id="related">Related DebateOwl guides</h2><nav class="links" aria-label="Related guides"><a href="/ai-rebuttal-generator">AI Rebuttal Generator for Debate</a>
diff --git a/public/ai-debate-coach/index.html b/public/ai-debate-coach/index.html
index b7ce6183b..64da0dca3 100644
--- a/public/ai-debate-coach/index.html
+++ b/public/ai-debate-coach/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>AI Debate Coach | DebateOwl</title>
-  <meta name="description" content="Ask DebateOwl&#x27;s AI debate coach about strategy, case structure, weighing, rebuttals and speeches, with answers tied to your own motion and side." />
+  <meta name="description" content="Ask DebateOwl&#x27;s AI debate coach about strategy, arguments, rebuttals and speeches, with answers tied to your own motion, side and speaker role." />
   <meta name="robots" content="index, follow, max-snippet:-1, max-image-preview:large" />
   <link rel="canonical" href="https://debateowl.com/ai-debate-coach" />
   <meta name="author" content="DebateOwl" />
@@ -16,21 +16,21 @@
   <meta property="og:type" content="article" />
   <meta property="og:site_name" content="DebateOwl" />
   <meta property="og:title" content="AI Debate Coach | DebateOwl" />
-  <meta property="og:description" content="Ask DebateOwl&#x27;s AI debate coach about strategy, case structure, weighing, rebuttals and speeches, with answers tied to your own motion and side." />
+  <meta property="og:description" content="Ask DebateOwl&#x27;s AI debate coach about strategy, arguments, rebuttals and speeches, with answers tied to your own motion, side and speaker role." />
   <meta property="og:url" content="https://debateowl.com/ai-debate-coach" />
   <meta property="og:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta property="og:image:width" content="1200" />
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="AI Debate Coach | DebateOwl" />
-  <meta name="twitter:description" content="Ask DebateOwl&#x27;s AI debate coach about strategy, case structure, weighing, rebuttals and speeches, with answers tied to your own motion and side." />
+  <meta name="twitter:description" content="Ask DebateOwl&#x27;s AI debate coach about strategy, arguments, rebuttals and speeches, with answers tied to your own motion, side and speaker role." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Ask an AI Debate Coach for Round-Ready Prep","name":"AI Debate Coach | DebateOwl","url":"https://debateowl.com/ai-debate-coach","description":"Ask DebateOwl's AI debate coach about strategy, case structure, weighing, rebuttals and speeches, with answers tied to your own motion and side.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can an AI debate coach actually help you prepare?","acceptedAnswer":{"@type":"Answer","text":"Yes. DebateOwl's Ask coach is an AI debate coach that answers specific prep questions about burdens, clash, weighing and speech structure, and gives feedback on practice speeches; it works best when you name the format, side and speaker role. Vague questions get generic answers. Treat any sources it cites as leads to check. An AI coach has not watched you speak and does not know your judges or your partner, so take its conclusions to your human coach or team."}},{"@type":"Question","name":"What can I ask the AI debate coach?","acceptedAnswer":{"@type":"Answer","text":"Anything you would ask a coach between rounds: burdens, clash, weighing, speech structure, how to answer a specific argument, or why a practice speech did not land. Specific questions with format, side and speaker role get the best answers."}},{"@type":"Question","name":"Does the coach know my case?","acceptedAnswer":{"@type":"Answer","text":"It knows your Current Debate: the motion, and the Library sources you have marked active. Paste a speech or a case section into the question when you want feedback on that exact text."}},{"@type":"Question","name":"Can the AI coach cite sources?","acceptedAnswer":{"@type":"Answer","text":"Yes. Turn on Citations in Ask and the answer includes sources you can open. Check each one against the original before using it in a round."}},{"@type":"Question","name":"Will the coach write my speeches for me?","acceptedAnswer":{"@type":"Answer","text":"It can draft an outline or a passage, but you will speak better from structure you understand. Use it to find what is missing, then write the speech in your own words."}},{"@type":"Question","name":"How is this different from a general AI chatbot?","acceptedAnswer":{"@type":"Answer","text":"The coach works inside one debate at a time, so it keeps your motion, debate settings and sources in context, and it is set up for debate questions rather than essays."}},{"@type":"Question","name":"Is there a free AI debate coach?","acceptedAnswer":{"@type":"Answer","text":"Not a permanent one in DebateOwl. The Ask coach comes with the app's 3-day free trial, no credit card needed, and after that with Pro at $5/month + tax. The tools you can use free without an account, the debate timer, motion generator, flow sheet and speech time calculator, do not include coaching."}},{"@type":"Question","name":"Can an AI judge my debate speech?","acceptedAnswer":{"@type":"Answer","text":"Partly. Sparring rounds end with a judged verdict that names the reason for the decision, and the Ask coach can tell you what was unclear, under-warranted or dropped in a speech you paste in. It has not watched you speak and does not know the judges at your tournament, so treat its verdict as practice feedback, not a prediction of a real ballot."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Ask an AI Debate Coach for Round-Ready Prep","item":"https://debateowl.com/ai-debate-coach"}]},{"@type":"DefinedTerm","name":"AI debate coach","description":"A chat tool that answers a debater's prep questions about burdens, clash, weighing and speech structure and gives feedback on practice speeches, for the debater to test and adapt.","url":"https://debateowl.com/ai-debate-coach#definition"}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Ask an AI Debate Coach for Round-Ready Prep","name":"AI Debate Coach | DebateOwl","url":"https://debateowl.com/ai-debate-coach","description":"Ask DebateOwl's AI debate coach about strategy, arguments, rebuttals and speeches, with answers tied to your own motion, side and speaker role.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can an AI debate coach actually help you prepare?","acceptedAnswer":{"@type":"Answer","text":"Yes. DebateOwl's Ask coach is an AI debate coach that answers specific prep questions about what your side has to prove, which argument decides the round and how to structure a speech, and gives feedback on practice speeches; it works best when you name the format, side and speaker role. Vague questions get generic answers. Treat any sources it cites as leads to check. An AI coach has not watched you speak and does not know your judges or your partner, so take its conclusions to your human coach or team."}},{"@type":"Question","name":"What can I ask the AI debate coach?","acceptedAnswer":{"@type":"Answer","text":"Anything you would ask a coach between rounds: what your side has to prove, which argument decides the round, speech structure, how to answer a specific argument, or why a practice speech did not land. Specific questions with format, side and speaker role get the best answers."}},{"@type":"Question","name":"Does the coach know my case?","acceptedAnswer":{"@type":"Answer","text":"It knows your Current Debate: the motion, and the Library sources you have marked active. Paste a speech or a case section into the question when you want feedback on that exact text."}},{"@type":"Question","name":"Can the AI coach cite sources?","acceptedAnswer":{"@type":"Answer","text":"Yes. Turn on Citations in Ask and the answer includes sources you can open. Check each one against the original before using it in a round."}},{"@type":"Question","name":"Will the coach write my speeches for me?","acceptedAnswer":{"@type":"Answer","text":"It can draft an outline or a passage, but you will speak better from structure you understand. Use it to find what is missing, then write the speech in your own words."}},{"@type":"Question","name":"How is this different from a general AI chatbot?","acceptedAnswer":{"@type":"Answer","text":"The coach works inside one debate at a time, so it keeps your motion, debate settings and sources in context, and it is set up for debate questions rather than essays."}},{"@type":"Question","name":"Is there a free AI debate coach?","acceptedAnswer":{"@type":"Answer","text":"Not a permanent one in DebateOwl. The Ask coach comes with the app's 3-day free trial, no credit card needed, and after that with Pro at $5/month + tax. The tools you can use free without an account, the debate timer, motion generator, flow sheet and speech time calculator, do not include coaching."}},{"@type":"Question","name":"Can an AI judge my debate speech?","acceptedAnswer":{"@type":"Answer","text":"Partly. Sparring rounds end with a judged verdict that names the reason for the decision, and the Ask coach can tell you what was unclear, under-warranted or dropped in a speech you paste in. It has not watched you speak and does not know the judges at your tournament, so treat its verdict as practice feedback, not a prediction of a real ballot."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Ask an AI Debate Coach for Round-Ready Prep","item":"https://debateowl.com/ai-debate-coach"}]},{"@type":"DefinedTerm","name":"AI debate coach","description":"A chat tool that answers a debater's prep questions about strategy, arguments, answers to the other side and speech structure, and gives feedback on practice speeches, for the debater to test and adapt.","url":"https://debateowl.com/ai-debate-coach#definition"}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,12 +39,12 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">Ask an AI Debate Coach for Round-Ready Prep</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Feature guide</span><h1>Ask an AI Debate Coach for Round-Ready Prep</h1><p class="lead">Get focused help with strategy, structure, weighing, rebuttals, speeches, and practice feedback.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
-      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Can an AI debate coach actually help you prepare?</h2><p>Yes. DebateOwl&#x27;s Ask coach is an AI debate coach that answers specific prep questions about burdens, clash, weighing and speech structure, and gives feedback on practice speeches; it works best when you name the format, side and speaker role. Vague questions get generic answers. Treat any sources it cites as leads to check. An AI coach has not watched you speak and does not know your judges or your partner, so take its conclusions to your human coach or team.</p></section>
-      <section class="article section" aria-label="Definition"><dl id="definition"><dt><strong>What is an AI debate coach?</strong></dt><dd>A chat tool that answers a debater&#x27;s prep questions about burdens, clash, weighing and speech structure and gives feedback on practice speeches, for the debater to test and adapt.</dd></dl></section>
-      <section class="grid" aria-label="Highlights"><article class="card"><h3>Strategy help</h3><p class="muted">Ask which clash decides the round, what your burden is and where to spend your speaking time, with answers that use your debate&#x27;s motion and sources.</p></article><article class="card"><h3>Speech structure</h3><p class="muted">Get an outline for a constructive, rebuttal, summary or reply speech: the order of points and how long to give each one.</p></article><article class="card"><h3>Practice feedback</h3><p class="muted">Paste a speech or a flow and ask what was unclear, under-warranted or dropped, then pick one fix to drill.</p></article></section>
+      <header class="hero"><span class="eyebrow">Feature guide</span><h1>Ask an AI Debate Coach for Round-Ready Prep</h1><p class="lead">Get focused help with strategy, arguments, rebuttals, speeches, and practice feedback.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Can an AI debate coach actually help you prepare?</h2><p>Yes. DebateOwl&#x27;s Ask coach is an AI debate coach that answers specific prep questions about what your side has to prove, which argument decides the round and how to structure a speech, and gives feedback on practice speeches; it works best when you name the format, side and speaker role. Vague questions get generic answers. Treat any sources it cites as leads to check. An AI coach has not watched you speak and does not know your judges or your partner, so take its conclusions to your human coach or team.</p></section>
+      <section class="article section" aria-label="Definition"><dl id="definition"><dt><strong>What is an AI debate coach?</strong></dt><dd>A chat tool that answers a debater&#x27;s prep questions about strategy, arguments, answers to the other side and speech structure, and gives feedback on practice speeches, for the debater to test and adapt.</dd></dl></section>
+      <section class="grid" aria-label="Highlights"><article class="card"><h3>Strategy help</h3><p class="muted">Ask which argument decides the round, what your side has to prove and where to spend your speaking time, with answers that use your debate&#x27;s motion and sources.</p></article><article class="card"><h3>Speech structure</h3><p class="muted">Get an outline for a constructive, rebuttal, summary or reply speech: the order of points and how long to give each one.</p></article><article class="card"><h3>Practice feedback</h3><p class="muted">Paste a speech or a flow and ask what was unclear, under-warranted or dropped, then pick one fix to drill.</p></article></section>
       <div class="article section"><h2>What an AI debate coach is for</h2><p>A good human coach rarely gives you an answer first. They ask what the round is about, which side you are on, what you have to prove, and what the judge will be comparing at the end. The AI coach in DebateOwl works best the same way: as a partner you think out loud with, not a machine that writes speeches.</p><p>Ask is a coaching chat that streams its answer as it writes, and it already knows your Current Debate: the motion and the Library sources you have marked active. That context is the main difference from a <a href="/debateowl-vs-chatgpt">general chatbot</a>. You do not have to paste the motion and your research into every question, and the advice stays tied to one debate instead of drifting between topics.</p><h2>How to ask a coaching question that gets a useful answer</h2><p>Vague questions get generic answers. Compare these two:</p><ul><li>Weak: How do I win this debate?</li><li>Strong: I am second opposition in a WSDC round on this motion. Our first speaker argued the policy is unworkable. What should I add so I am not repeating her, and which proposition argument should I spend most of my rebuttal on?</li></ul><p>The strong version names the format, the speaker role, what has already been said and the decision you actually have to make. A reliable template is: format, side and speaker, what is already on the table, what you are stuck on, and what kind of answer you want (a list, an outline or a single recommendation).</p><h2>Five coaching conversations worth having before a tournament</h2><ol><li>Burden check: ask what each side has to prove for the motion to stand or fall, and where the line between them sits. Many rounds are lost on a burden nobody named.</li><li>Clash map: ask for the three places where the cases will meet. Plan your speeches around those, not around your own contentions.</li><li>Weighing rehearsal: give the coach your impact and the likely opposing impact and ask for the comparison in two sentences. Repeat until you can say it without notes.</li><li>Speech audit: paste a practice speech and ask which claim had no warrant, which point ran too long, and what a judge would remember from it.</li><li>Opponent prediction: ask how a strong team on the other side would frame the debate, then ask what your first response to that framing should be.</li></ol><h2>Worked example: coaching a weak rebuttal</h2><div class="card"><h3>Motion: This house believes social media companies should be legally liable for misinformation on their platforms</h3><p><strong>Student&#x27;s rebuttal:</strong> Their argument is wrong because free speech is important and this would destroy it.</p><p><strong>Coach&#x27;s diagnosis:</strong> The response asserts a value but never connects it to the proposition&#x27;s mechanism. It does not say how liability leads to less speech, so the judge has nothing to weigh.</p><p><strong>Coach&#x27;s question back:</strong> What would a platform rationally do if it could be sued for every false post?</p><p><strong>Rebuilt rebuttal:</strong> Liability makes every borderline post a legal risk. A platform facing that risk removes anything it cannot verify quickly, which includes breaking news, whistleblowers and minority viewpoints. So the proposition does not just remove misinformation; it removes true speech that is hard to check, and the people who lose most are those with no other platform.</p><p><strong>Follow-up drill:</strong> Deliver the rebuilt response in forty-five seconds, then ask the coach for the strongest proposition answer to it and prepare a single-sentence reply.</p></div><p>Notice that the coach did not write the rebuttal outright. It asked the question that exposed the missing link, which is the habit you want to build for rounds where no coach is available.</p><h2>Coaching by format</h2><h3>World Schools (WSDC)</h3><p>Ask the coach to check your team split: what the first and second speakers each own, and whether the third speaker can rebut without introducing a new argument. For the <a href="/world-schools-debate">reply speech</a>, ask for a structure built around the two or three questions the debate turned on, told from your side, without new material.</p><h3>British Parliamentary (BP)</h3><p>Role fulfilment decides BP rooms. Ask the coach whether your member speech is a true extension or a restatement of your opening bench, and ask what a whip speech should do with the five other speeches already in the room: group them into clashes, not summaries of each speaker.</p><h3>Public Forum (PF)</h3><p>Use coaching to plan the summary before the round. Ask which two issues you can realistically extend from constructive through <a href="/public-forum-debate">final focus</a>, and what the second rebuttal must frontline so those issues survive. Also ask for crossfire questions that set up your summary rather than score points.</p><h3>Lincoln-Douglas (LD)</h3><p>LD coaching is often framework coaching. Ask the coach whether your criterion actually measures your value, how your contentions link back to the criterion, and when it is safer to concede the opponent&#x27;s framework and show that you win under it anyway.</p><h2>Getting answers with sources</h2><p>When a coaching answer depends on facts, turn on Citations in Ask. The coach then answers with sources you can open. Treat those as leads: read the original, confirm it says what the answer claims, and only then use it in a speech. Adding your own trusted articles to the Library has the same effect from the other direction, because active sources that fit the question are used in its answers for that debate.</p><h2>What an AI coach cannot do</h2><p>It has not watched you speak, it does not know the judges at your tournament, and it cannot tell you how your partner works under pressure. Bring the conclusions from AI coaching sessions to your human coach or team, and let them correct the advice that does not fit the people in the room.</p></div>
-      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>What can I ask the AI debate coach?</summary><p>Anything you would ask a coach between rounds: burdens, clash, weighing, speech structure, how to answer a specific argument, or why a practice speech did not land. Specific questions with format, side and speaker role get the best answers.</p></details><details><summary>Does the coach know my case?</summary><p>It knows your Current Debate: the motion, and the Library sources you have marked active. Paste a speech or a case section into the question when you want feedback on that exact text.</p></details><details><summary>Can the AI coach cite sources?</summary><p>Yes. Turn on Citations in Ask and the answer includes sources you can open. Check each one against the original before using it in a round.</p></details><details><summary>Will the coach write my speeches for me?</summary><p>It can draft an outline or a passage, but you will speak better from structure you understand. Use it to find what is missing, then write the speech in your own words.</p></details><details><summary>How is this different from a general AI chatbot?</summary><p>The coach works inside one debate at a time, so it keeps your motion, debate settings and sources in context, and it is set up for debate questions rather than essays.</p></details><details><summary>Is there a free AI debate coach?</summary><p>Not a permanent one in DebateOwl. The Ask coach comes with the app&#x27;s 3-day free trial, no credit card needed, and after that with Pro at $5/month + tax. The tools you can use free without an account, the debate timer, motion generator, flow sheet and speech time calculator, do not include coaching.</p></details><details><summary>Can an AI judge my debate speech?</summary><p>Partly. Sparring rounds end with a judged verdict that names the reason for the decision, and the Ask coach can tell you what was unclear, under-warranted or dropped in a speech you paste in. It has not watched you speak and does not know the judges at your tournament, so treat its verdict as practice feedback, not a prediction of a real ballot.</p></details></section>
+      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>What can I ask the AI debate coach?</summary><p>Anything you would ask a coach between rounds: what your side has to prove, which argument decides the round, speech structure, how to answer a specific argument, or why a practice speech did not land. Specific questions with format, side and speaker role get the best answers.</p></details><details><summary>Does the coach know my case?</summary><p>It knows your Current Debate: the motion, and the Library sources you have marked active. Paste a speech or a case section into the question when you want feedback on that exact text.</p></details><details><summary>Can the AI coach cite sources?</summary><p>Yes. Turn on Citations in Ask and the answer includes sources you can open. Check each one against the original before using it in a round.</p></details><details><summary>Will the coach write my speeches for me?</summary><p>It can draft an outline or a passage, but you will speak better from structure you understand. Use it to find what is missing, then write the speech in your own words.</p></details><details><summary>How is this different from a general AI chatbot?</summary><p>The coach works inside one debate at a time, so it keeps your motion, debate settings and sources in context, and it is set up for debate questions rather than essays.</p></details><details><summary>Is there a free AI debate coach?</summary><p>Not a permanent one in DebateOwl. The Ask coach comes with the app&#x27;s 3-day free trial, no credit card needed, and after that with Pro at $5/month + tax. The tools you can use free without an account, the debate timer, motion generator, flow sheet and speech time calculator, do not include coaching.</p></details><details><summary>Can an AI judge my debate speech?</summary><p>Partly. Sparring rounds end with a judged verdict that names the reason for the decision, and the Ask coach can tell you what was unclear, under-warranted or dropped in a speech you paste in. It has not watched you speak and does not know the judges at your tournament, so treat its verdict as practice feedback, not a prediction of a real ballot.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
     <section class="section article" aria-labelledby="related"><h2 id="related">Related DebateOwl guides</h2><nav class="links" aria-label="Related guides"><a href="/ai-debate-case-generator">AI Debate Case Generator with Citations</a>
diff --git a/public/ai-debate-practice/index.html b/public/ai-debate-practice/index.html
index 0f42ae380..970d6fe7e 100644
--- a/public/ai-debate-practice/index.html
+++ b/public/ai-debate-practice/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>AI Debate Practice | DebateOwl</title>
-  <meta name="description" content="Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and weighing." />
+  <meta name="description" content="Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and speeches." />
   <meta name="robots" content="index, follow, max-snippet:-1, max-image-preview:large" />
   <link rel="canonical" href="https://debateowl.com/ai-debate-practice" />
   <meta name="author" content="DebateOwl" />
@@ -16,21 +16,21 @@
   <meta property="og:type" content="article" />
   <meta property="og:site_name" content="DebateOwl" />
   <meta property="og:title" content="AI Debate Practice | DebateOwl" />
-  <meta property="og:description" content="Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and weighing." />
+  <meta property="og:description" content="Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and speeches." />
   <meta property="og:url" content="https://debateowl.com/ai-debate-practice" />
   <meta property="og:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta property="og:image:width" content="1200" />
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="AI Debate Practice | DebateOwl" />
-  <meta name="twitter:description" content="Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and weighing." />
+  <meta name="twitter:description" content="Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and speeches." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"AI Debate Practice for Stronger Cases, Rebuttals, and Speeches","name":"AI Debate Practice | DebateOwl","url":"https://debateowl.com/ai-debate-practice","description":"Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and weighing.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can practising debate against an AI actually make you better?","acceptedAnswer":{"@type":"Answer","text":"Yes, if it shortens the loop of giving a speech, finding what failed, fixing one thing and giving it again. A useful session needs a motion, a side, real speech times, an opponent that responds to what you said and a verdict that names why you won or lost. DebateOwl's Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds this way. AI practice adds repetitions between team practices but does not replace them: judge adaptation, delivery under pressure and strategic judgement still develop fastest with a coach and real rounds."}},{"@type":"Question","name":"Which formats can I spar against the AI in?","acceptedAnswer":{"@type":"Answer","text":"Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds with their speech order and times. For WSDC, British Parliamentary and other formats you can still generate cases, get coaching and drill rebuttals, and time speeches yourself."}},{"@type":"Question","name":"Can I give my practice speeches out loud?","acceptedAnswer":{"@type":"Answer","text":"Yes. Sparring and Crossfire can run as spoken rounds in the browser, so you can practise delivery as well as content."}},{"@type":"Question","name":"How often should I practise against an AI opponent?","acceptedAnswer":{"@type":"Answer","text":"Two or three focused sessions a week usually beats one long one. Each session should end with one specific fix that you drill before the next round."}},{"@type":"Question","name":"Does AI practice replace a coach or real rounds?","acceptedAnswer":{"@type":"Answer","text":"No. It adds repetitions between team practices. Judge adaptation, delivery under pressure and strategic judgement still develop fastest with people."}},{"@type":"Question","name":"Is AI debate prep better than traditional prep?","acceptedAnswer":{"@type":"Answer","text":"Neither is better on its own. AI is faster at outlines, block drafts and evidence leads; reading sources, coaching and real rounds build the judgement AI drafts lack."}},{"@type":"Question","name":"Are my practice rounds private?","acceptedAnswer":{"@type":"Answer","text":"Yes. Rounds, verdicts and debriefs are saved to your account inside the Current Debate they belong to, behind sign-in. Search engines only see these public guides."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"AI Debate Practice for Stronger Cases, Rebuttals, and Speeches","item":"https://debateowl.com/ai-debate-practice"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"AI Debate Practice for Stronger Cases, Rebuttals, and Speeches","name":"AI Debate Practice | DebateOwl","url":"https://debateowl.com/ai-debate-practice","description":"Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and speeches.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can practising debate against an AI actually make you better?","acceptedAnswer":{"@type":"Answer","text":"Yes, if it shortens the loop of giving a speech, finding what failed, fixing one thing and giving it again. A useful session needs a motion, a side, real speech times, an opponent that responds to what you said and a verdict that names why you won or lost. DebateOwl's Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds this way. AI practice adds repetitions between team practices but does not replace them: judge adaptation, delivery under pressure and strategic judgement still develop fastest with a coach and real rounds."}},{"@type":"Question","name":"Which formats can I spar against the AI in?","acceptedAnswer":{"@type":"Answer","text":"Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds with their speech order and times. For WSDC, British Parliamentary and other formats you can still generate cases, get coaching and drill rebuttals, and time speeches yourself."}},{"@type":"Question","name":"Can I give my practice speeches out loud?","acceptedAnswer":{"@type":"Answer","text":"Yes. Sparring and Crossfire can run as spoken rounds in the browser, so you can practise delivery as well as content."}},{"@type":"Question","name":"How often should I practise against an AI opponent?","acceptedAnswer":{"@type":"Answer","text":"Two or three focused sessions a week usually beats one long one. Each session should end with one specific fix that you drill before the next round."}},{"@type":"Question","name":"Does AI practice replace a coach or real rounds?","acceptedAnswer":{"@type":"Answer","text":"No. It adds repetitions between team practices. Judge adaptation, delivery under pressure and strategic judgement still develop fastest with people."}},{"@type":"Question","name":"Is AI debate prep better than traditional prep?","acceptedAnswer":{"@type":"Answer","text":"Neither is better on its own. AI is faster at outlines, block drafts and evidence leads; reading sources, coaching and real rounds build the judgement AI drafts lack."}},{"@type":"Question","name":"Are my practice rounds private?","acceptedAnswer":{"@type":"Answer","text":"Yes. Rounds, verdicts and debriefs are saved to your account inside the Current Debate they belong to, behind sign-in. Search engines only see these public guides."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"AI Debate Practice for Stronger Cases, Rebuttals, and Speeches","item":"https://debateowl.com/ai-debate-practice"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">AI Debate Practice for Stronger Cases, Rebuttals, and Speeches</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">DebateOwl guide</span><h1>AI Debate Practice for Stronger Cases, Rebuttals, and Speeches</h1><p class="lead">Use a focused debate workspace for cases, rebuttals, sources, flowcharts, coaching, and timed practice.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">DebateOwl guide</span><h1>AI Debate Practice for Stronger Cases, Rebuttals, and Speeches</h1><p class="lead">Use a focused debate workspace for cases, rebuttals, sources, flowcharts, coaching, and timed practice.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Can practising debate against an AI actually make you better?</h2><p>Yes, if it shortens the loop of giving a speech, finding what failed, fixing one thing and giving it again. A useful session needs a motion, a side, real speech times, an opponent that responds to what you said and a verdict that names why you won or lost. DebateOwl&#x27;s Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds this way. AI practice adds repetitions between team practices but does not replace them: judge adaptation, delivery under pressure and strategic judgement still develop fastest with a coach and real rounds.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Practice against AI opponents</h3><p class="muted">Run a full Sparring round in School 4-6-6-3, Lincoln-Douglas or Public Forum, type or speak each speech, and finish with a judged verdict.</p></article><article class="card"><h3>Turn feedback into drills</h3><p class="muted">Take the weakest point from a verdict or a Crossfire debrief, rebuild it with Attack or Ask, and run that speech again.</p></article><article class="card"><h3>Keep private prep out of search</h3><p class="muted">Cases, sources, rounds and history stay inside your Current Debate behind sign-in. Only these public guides are indexed.</p></article></section>
-      <div class="article section"><h2>What a useful AI practice session looks like</h2><p>Most debaters improve through repetitions with feedback: give a speech, find out what failed, fix one thing, give it again. AI practice is valuable when it shortens that loop, not when it hands you a finished speech to read.</p><p>A chat window can produce arguments on request, but it does not hold a round together. It forgets which side you are on, does not time you, and rarely tells you which of your points the judge would have dropped. Practice needs a motion, a side, a format with real speech times, an opponent that responds to what you actually said, and a verdict that names the reason you lost or won.</p><p>DebateOwl is built around that loop. You start a Current Debate for one motion, and every case, source, round and debrief you create stays filed under it. That means the AI opponent in your third practice round argues the same motion you wrote your case for, and your History shows how the debate developed across sessions.</p><h2>A 45-minute practice session, step by step</h2><p>This plan fits a weeknight. It assumes you have a motion but no case yet.</p><ol><li>Start a Current Debate with the motion written exactly as it will be announced (2 minutes). Add any articles or notes you already trust to the Library so later answers are grounded in them.</li><li>Run Brainstorm on the motion and pick the two or three angles you can explain in one sentence each (5 minutes). Discard angles that need evidence you do not have.</li><li>Generate a case for your side (10 minutes). Read the predicted opponent case before your own contentions: it tells you what you will have to answer.</li><li>Run a Sparring round in your format (15 minutes). Give every speech in full, at time, without pausing to edit. Voice mode lets you speak instead of type.</li><li>Read the verdict and write down the single reason it gives for the decision (3 minutes).</li><li>Rebuild only that part (5 minutes): ask Attack to stress-test the rewritten argument, or regenerate the one case section that failed.</li><li>Give the rebuilt speech again against the timer (5 minutes). Compare it with the first attempt.</li></ol><p>The discipline is in step six. Fixing one problem per session sticks; rewriting the whole case after every round mostly produces new problems.</p><h2>Worked example: one practice round</h2><div class="card"><h3>Motion: This house would ban smartphones in secondary schools</h3><p><strong>Side and format:</strong> Proposition, run as a School 4-6-6-3 Sparring round.</p><p><strong>First contention:</strong> Phones fragment attention in class, and attention is the input every other kind of learning depends on.</p><p><strong>AI opponent&#x27;s response:</strong> Schools already confiscate phones during lessons, so a ban changes only break times, where the harm you described does not happen.</p><p><strong>What the verdict flagged:</strong> Proposition never explained what a ban adds over existing classroom rules, so the opposition&#x27;s mitigation stood unanswered.</p><p><strong>The drill:</strong> Ask Attack to find the gap in the contention, then rewrite it around breaks: social exclusion, cyberbullying during the school day, and the cost of teachers enforcing rules lesson by lesson.</p><p><strong>Second attempt:</strong> The R1 speech now opens with the comparison: classroom rules depend on every teacher enforcing them every hour, while a ban sets one rule at the school gate. The opponent&#x27;s mitigation becomes a point in your favour.</p></div><p>The example shows the pattern to look for. The first version was not wrong; it was incomplete in a way only a responsive opponent exposes. That is the gap AI practice fills between team practices.</p><h2>Format-specific practice tips</h2><h3>World Schools (WSDC)</h3><p>WSDC rounds reward a consistent team line, so practise as a team even when you use AI. Agree the line in one sentence, then have each speaker run their own section against the AI and check that the line survives. Points of Information matter in every substantive speech: use Crossfire with the AI asking the questions to rehearse taking a POI, answering in under fifteen seconds, and returning to your structure. Sparring does not run a WSDC round, so time the eight-minute substantives and four-minute reply yourself.</p><h3>British Parliamentary (BP)</h3><p>In BP, two teams on each bench compete with each other as well as with the other side. Practise both halves. For opening, generate a case with the Current Debate&#x27;s format set to <a href="/british-parliamentary-debate">British Parliamentary</a> and drill a clear definition and model in the first two minutes. For closing, take an opening case you have already generated and practise finding an extension it does not contain, then deliver it in seven minutes without repeating opening material.</p><h3>Public Forum (PF)</h3><p>Sparring runs <a href="/public-forum-debate">Public Forum</a> with four-minute constructives and rebuttals, three-minute summaries and two-minute final focuses. Use the round to practise the hardest skill in PF: keeping summary and final focus consistent. Before each summary, write the two issues you will collapse on, and check after the round whether your final focus extended exactly those issues and nothing new.</p><h3>Lincoln-Douglas (LD)</h3><p>The <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> round follows the standard times: six-minute affirmative constructive, seven-minute negative constructive, four-minute first affirmative rebuttal, six-minute negative rebuttal and three-minute second affirmative rebuttal. The 1AR is where most affirmatives lose. Run it repeatedly against the same negative constructive and practise grouping responses and cross-applying your framework, so four minutes covers seven.</p><h2>How to tell whether practice is working</h2><p>Keep a short log for each session on paper or in a document. Track the same four things every time:</p><ul><li>Arguments you dropped: anything the opponent said that you never answered. This number should fall first.</li><li>Time use: whether you finished each speech within ten seconds of the limit without rushing the last point.</li><li>Weighing: whether your final speech compared impacts explicitly, or just repeated them.</li><li>Verdict reasons: whether the judge&#x27;s reason for the decision changes from session to session, or keeps naming the same weakness.</li></ul><p>If the same verdict reason appears three sessions in a row, stop running full rounds and drill that one skill in isolation until it changes.</p><h2>AI vs traditional prep</h2><p>AI and traditional preparation are good at different parts of the work. AI is fast at structure; reading, coaching and real rounds are where judgement comes from. Most strong debaters use both and give each the tasks it does well.</p><div class="table"><table><thead><tr><th scope="col">Task</th><th scope="col">AI does it well</th><th scope="col">Traditional prep does it better</th></tr></thead><tbody><tr><td data-label="Task">First case outline</td><td data-label="AI does it well">Drafts claims, warrants and a predicted opponent case in minutes</td><td data-label="Traditional prep does it better">Choosing which outline fits your team and your circuit</td></tr><tr><td data-label="Task">Rebuttal blocks</td><td data-label="AI does it well">Lists likely arguments and first-draft answers</td><td data-label="Traditional prep does it better">Testing answers against opponents you have actually met</td></tr><tr><td data-label="Task">Research</td><td data-label="AI does it well">Suggests evidence leads and search directions</td><td data-label="Traditional prep does it better">Reading the original source, checking dates and context</td></tr><tr><td data-label="Task">Practice rounds</td><td data-label="AI does it well">A responsive opponent at any hour, at real speech times</td><td data-label="Traditional prep does it better">Unpredictable opponents, panels and live crossfire</td></tr><tr><td data-label="Task">Feedback</td><td data-label="AI does it well">A consistent verdict that names a reason</td><td data-label="Traditional prep does it better">A coach who knows your habits and the judges you will face</td></tr></tbody></table></div><p>A simple split works for most teams: use AI to get from a blank page to a first draft and for extra practice volume, then spend coaching time and team practice on strategy, delivery and the arguments the AI draft got wrong. Never read AI-suggested evidence in round until you have opened the original source yourself.</p><h2>Where AI practice stops being enough</h2><p>An AI opponent is consistent and always available, which is exactly what makes it a good training partner and a limited judge. It will not reproduce the judge who dislikes speed, the panel that splits, or the opponent who asks a question you never anticipated. Use AI rounds for volume between real practices, and save team practices and coached rounds for adaptation, delivery and the feedback only an experienced person can give.</p></div>
+      <div class="article section"><h2>What a useful AI practice session looks like</h2><p>Most debaters improve through repetitions with feedback: give a speech, find out what failed, fix one thing, give it again. AI practice is valuable when it shortens that loop, not when it hands you a finished speech to read.</p><p>A chat window can produce arguments on request, but it does not hold a round together. It forgets which side you are on, does not time you, and rarely tells you which of your points the judge would have dropped. Practice needs a motion, a side, a format with real speech times, an opponent that responds to what you actually said, and a verdict that names the reason you lost or won.</p><p>DebateOwl is built around that loop. You start a Current Debate for one motion, and every case, source, round and debrief you create stays filed under it. That means the AI opponent in your third practice round argues the same motion you wrote your case for, and your History shows how the debate developed across sessions.</p><h2>A 45-minute practice session, step by step</h2><p>This plan fits a weeknight. It assumes you have a motion but no case yet.</p><ol><li>Start a Current Debate with the motion written exactly as it will be announced (2 minutes). Add any articles or notes you already trust to the Library so later answers are grounded in them.</li><li>Run Brainstorm on the motion and pick the two or three angles you can explain in one sentence each (5 minutes). Discard angles that need evidence you do not have.</li><li>Generate a case for your side (10 minutes). Read its &quot;If they say…&quot; answers before your own arguments: they tell you what you will have to answer.</li><li>Run a Sparring round in your format (15 minutes). Give every speech in full, at time, without pausing to edit. Voice mode lets you speak instead of type.</li><li>Read the verdict and write down the single reason it gives for the decision (3 minutes).</li><li>Rebuild only that part (5 minutes): ask Attack to stress-test the rewritten argument, or regenerate the one case section that failed.</li><li>Give the rebuilt speech again against the timer (5 minutes). Compare it with the first attempt.</li></ol><p>The discipline is in step six. Fixing one problem per session sticks; rewriting the whole case after every round mostly produces new problems.</p><h2>Worked example: one practice round</h2><div class="card"><h3>Motion: This house would ban smartphones in secondary schools</h3><p><strong>Side and format:</strong> Proposition, run as a School 4-6-6-3 Sparring round.</p><p><strong>First argument:</strong> Phones fragment attention in class, and attention is the input every other kind of learning depends on.</p><p><strong>AI opponent&#x27;s response:</strong> Schools already confiscate phones during lessons, so a ban changes only break times, where the harm you described does not happen.</p><p><strong>What the verdict flagged:</strong> Proposition never explained what a ban adds over existing classroom rules, so the opposition&#x27;s mitigation stood unanswered.</p><p><strong>The drill:</strong> Ask Attack to find the gap in the argument, then rewrite it around breaks: social exclusion, cyberbullying during the school day, and the cost of teachers enforcing rules lesson by lesson.</p><p><strong>Second attempt:</strong> The R1 speech now opens with the comparison: classroom rules depend on every teacher enforcing them every hour, while a ban sets one rule at the school gate. The opponent&#x27;s mitigation becomes a point in your favour.</p></div><p>The example shows the pattern to look for. The first version was not wrong; it was incomplete in a way only a responsive opponent exposes. That is the gap AI practice fills between team practices.</p><h2>Format-specific practice tips</h2><h3>World Schools (WSDC)</h3><p>WSDC rounds reward a consistent team line, so practise as a team even when you use AI. Agree the line in one sentence, then have each speaker run their own section against the AI and check that the line survives. Points of Information matter in every substantive speech: use Crossfire with the AI asking the questions to rehearse taking a POI, answering in under fifteen seconds, and returning to your structure. Sparring does not run a WSDC round, so time the eight-minute substantives and four-minute reply yourself.</p><h3>British Parliamentary (BP)</h3><p>In BP, two teams on each bench compete with each other as well as with the other side. Practise both halves. For opening, generate a case with the Current Debate&#x27;s format set to <a href="/british-parliamentary-debate">British Parliamentary</a> and drill a clear definition and model in the first two minutes. For closing, take an opening case you have already generated and practise finding an extension it does not contain, then deliver it in seven minutes without repeating opening material.</p><h3>Public Forum (PF)</h3><p>Sparring runs <a href="/public-forum-debate">Public Forum</a> with four-minute constructives and rebuttals, three-minute summaries and two-minute final focuses. Use the round to practise the hardest skill in PF: keeping summary and final focus consistent. Before each summary, write the two issues you will collapse on, and check after the round whether your final focus extended exactly those issues and nothing new.</p><h3>Lincoln-Douglas (LD)</h3><p>The <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> round follows the standard times: six-minute affirmative constructive, seven-minute negative constructive, four-minute first affirmative rebuttal, six-minute negative rebuttal and three-minute second affirmative rebuttal. The 1AR is where most affirmatives lose. Run it repeatedly against the same negative constructive and practise grouping responses and cross-applying your framework, so four minutes covers seven.</p><h2>How to tell whether practice is working</h2><p>Keep a short log for each session on paper or in a document. Track the same four things every time:</p><ul><li>Arguments you dropped: anything the opponent said that you never answered. This number should fall first.</li><li>Time use: whether you finished each speech within ten seconds of the limit without rushing the last point.</li><li>Weighing: whether your final speech compared impacts explicitly, or just repeated them.</li><li>Verdict reasons: whether the judge&#x27;s reason for the decision changes from session to session, or keeps naming the same weakness.</li></ul><p>If the same verdict reason appears three sessions in a row, stop running full rounds and drill that one skill in isolation until it changes.</p><h2>AI vs traditional prep</h2><p>AI and traditional preparation are good at different parts of the work. AI is fast at structure; reading, coaching and real rounds are where judgement comes from. Most strong debaters use both and give each the tasks it does well.</p><div class="table"><table><thead><tr><th scope="col">Task</th><th scope="col">AI does it well</th><th scope="col">Traditional prep does it better</th></tr></thead><tbody><tr><td data-label="Task">First case outline</td><td data-label="AI does it well">Drafts an opening, arguments with evidence and &quot;If they say…&quot; answers in minutes</td><td data-label="Traditional prep does it better">Choosing which outline fits your team and your circuit</td></tr><tr><td data-label="Task">Rebuttal blocks</td><td data-label="AI does it well">Lists likely arguments and first-draft answers</td><td data-label="Traditional prep does it better">Testing answers against opponents you have actually met</td></tr><tr><td data-label="Task">Research</td><td data-label="AI does it well">Suggests evidence leads and search directions</td><td data-label="Traditional prep does it better">Reading the original source, checking dates and context</td></tr><tr><td data-label="Task">Practice rounds</td><td data-label="AI does it well">A responsive opponent at any hour, at real speech times</td><td data-label="Traditional prep does it better">Unpredictable opponents, panels and live crossfire</td></tr><tr><td data-label="Task">Feedback</td><td data-label="AI does it well">A consistent verdict that names a reason</td><td data-label="Traditional prep does it better">A coach who knows your habits and the judges you will face</td></tr></tbody></table></div><p>A simple split works for most teams: use AI to get from a blank page to a first draft and for extra practice volume, then spend coaching time and team practice on strategy, delivery and the arguments the AI draft got wrong. Never read AI-suggested evidence in round until you have opened the original source yourself.</p><h2>Where AI practice stops being enough</h2><p>An AI opponent is consistent and always available, which is exactly what makes it a good training partner and a limited judge. It will not reproduce the judge who dislikes speed, the panel that splits, or the opponent who asks a question you never anticipated. Use AI rounds for volume between real practices, and save team practices and coached rounds for adaptation, delivery and the feedback only an experienced person can give.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>Which formats can I spar against the AI in?</summary><p>Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds with their speech order and times. For WSDC, British Parliamentary and other formats you can still generate cases, get coaching and drill rebuttals, and time speeches yourself.</p></details><details><summary>Can I give my practice speeches out loud?</summary><p>Yes. Sparring and Crossfire can run as spoken rounds in the browser, so you can practise delivery as well as content.</p></details><details><summary>How often should I practise against an AI opponent?</summary><p>Two or three focused sessions a week usually beats one long one. Each session should end with one specific fix that you drill before the next round.</p></details><details><summary>Does AI practice replace a coach or real rounds?</summary><p>No. It adds repetitions between team practices. Judge adaptation, delivery under pressure and strategic judgement still develop fastest with people.</p></details><details><summary>Is AI debate prep better than traditional prep?</summary><p>Neither is better on its own. AI is faster at outlines, block drafts and evidence leads; reading sources, coaching and real rounds build the judgement AI drafts lack.</p></details><details><summary>Are my practice rounds private?</summary><p>Yes. Rounds, verdicts and debriefs are saved to your account inside the Current Debate they belong to, behind sign-in. Search engines only see these public guides.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/ai-rebuttal-generator/index.html b/public/ai-rebuttal-generator/index.html
index 8b7782cd4..166f22789 100644
--- a/public/ai-rebuttal-generator/index.html
+++ b/public/ai-rebuttal-generator/index.html
@@ -23,14 +23,14 @@
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="AI Rebuttal Generator for Debate | DebateOwl" />
   <meta name="twitter:description" content="DebateOwl&#x27;s rebuttal generator finds the weak link in an opposing argument and drafts a response block you can practice before the round." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"AI Rebuttal Generator for Debate","name":"AI Rebuttal Generator for Debate | DebateOwl","url":"https://debateowl.com/ai-rebuttal-generator","description":"DebateOwl's rebuttal generator finds the weak link in an opposing argument and drafts a response block you can practice before the round.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Is an AI rebuttal generator worth using for debate prep?","acceptedAnswer":{"@type":"Answer","text":"It is worth it for preparation when the output is structured for a round: the exact words being attacked, the broken link, a response you can say, a cross-ex question and the missing weighing. A general chatbot tends to write a counter-essay instead, which is rarely usable. Run it on opposing cases and on your own case. It cannot hear how your opponent framed an argument or know what a judge will find persuasive, and most leagues restrict AI during rounds. Rewrite responses in your own words and check any evidence it cites."}},{"@type":"Question","name":"What does the AI rebuttal generator produce?","acceptedAnswer":{"@type":"Answer","text":"A ranked list of weaknesses, each quoting the attacked words with an explanation and a response to say in round, plus detected fallacies, cross-examination questions and a weighing analysis."}},{"@type":"Question","name":"Can I use it on my own case?","acceptedAnswer":{"@type":"Answer","text":"Yes, and you should. Set the intensity to Mild or Moderate to find your weak points before an opponent does, then fix them or prepare an answer."}},{"@type":"Question","name":"Is it allowed to use an AI rebuttal generator in a debate round?","acceptedAnswer":{"@type":"Answer","text":"Most leagues restrict or ban internet and AI use during rounds. Check your league's rules and use the tool to prepare blocks beforehand."}},{"@type":"Question","name":"Are the rebuttals backed by evidence?","acceptedAnswer":{"@type":"Answer","text":"Attack runs web research and can point to counter-evidence. Treat anything it cites as a lead and check the original source before using it."}},{"@type":"Question","name":"How is this different from asking a chatbot to rebut an argument?","acceptedAnswer":{"@type":"Answer","text":"The output is structured for a round: each response targets quoted words, names the broken link and comes with a cross-ex question and weighing, instead of a general essay against the other side."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"AI Rebuttal Generator for Debate","item":"https://debateowl.com/ai-rebuttal-generator"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"AI Rebuttal Generator for Debate","name":"AI Rebuttal Generator for Debate | DebateOwl","url":"https://debateowl.com/ai-rebuttal-generator","description":"DebateOwl's rebuttal generator finds the weak link in an opposing argument and drafts a response block you can practice before the round.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Is an AI rebuttal generator worth using for debate prep?","acceptedAnswer":{"@type":"Answer","text":"It is worth it for preparation when the output is structured for a round: the exact words being attacked, the broken link, a response you can say, a cross-ex question and the missing weighing. A general chatbot tends to write a counter-essay instead, which is rarely usable. Run it on opposing cases and on your own case. It cannot hear how your opponent framed an argument or know what a judge will find persuasive, and most leagues restrict AI during rounds. Rewrite responses in your own words and check any evidence it cites."}},{"@type":"Question","name":"What does the AI rebuttal generator produce?","acceptedAnswer":{"@type":"Answer","text":"A ranked list of weaknesses, each quoting the attacked words with an explanation and a response to say in round, plus detected fallacies, cross-examination questions and a weighing analysis."}},{"@type":"Question","name":"Can I use it on my own case?","acceptedAnswer":{"@type":"Answer","text":"Yes, and you should. Set the intensity to Mild or Moderate to find your weak points before an opponent does, then fix them or prepare an answer."}},{"@type":"Question","name":"Is it allowed to use an AI rebuttal generator in a debate round?","acceptedAnswer":{"@type":"Answer","text":"Most leagues restrict or ban internet and AI use during rounds. Check your league's rules and use the tool to prepare blocks beforehand."}},{"@type":"Question","name":"Are the rebuttals backed by evidence?","acceptedAnswer":{"@type":"Answer","text":"Attack runs web research and can point to counter-evidence. Treat anything it cites as a lead and check the original source before using it."}},{"@type":"Question","name":"How is this different from asking a chatbot to rebut an argument?","acceptedAnswer":{"@type":"Answer","text":"The output is structured for a round: each response targets quoted words, names the broken link and comes with a cross-ex question and weighing, instead of a general essay against the other side."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"AI Rebuttal Generator for Debate","item":"https://debateowl.com/ai-rebuttal-generator"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">AI Rebuttal Generator for Debate</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Tool guide</span><h1>AI Rebuttal Generator for Debate</h1><p class="lead">Find the weak link, build the block, and practice the response.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">Tool guide</span><h1>AI Rebuttal Generator for Debate</h1><p class="lead">Find the weak link, build the block, and practice the response.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Is an AI rebuttal generator worth using for debate prep?</h2><p>It is worth it for preparation when the output is structured for a round: the exact words being attacked, the broken link, a response you can say, a cross-ex question and the missing weighing. A general chatbot tends to write a counter-essay instead, which is rarely usable. Run it on opposing cases and on your own case. It cannot hear how your opponent framed an argument or know what a judge will find persuasive, and most leagues restrict AI during rounds. Rewrite responses in your own words and check any evidence it cites.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Weaknesses ranked by damage</h3><p class="muted">Attack quotes the exact words it is targeting, names the broken link and orders the weaknesses from critical to minor.</p></article><article class="card"><h3>Responses you can say</h3><p class="muted">Each weakness comes with one to three sentences written to be spoken in round, not a description of what you could argue.</p></article><article class="card"><h3>Cross-ex questions and weighing</h3><p class="muted">Get questions tied to each weakness, a check for fallacies and an analysis of the weighing the argument is missing.</p></article></section>
-      <div class="article section"><h2>What a good rebuttal generator should give you</h2><p>Generic AI tools answer the request to rebut an argument by writing a counter-essay: a few paragraphs on why the other side is wrong. That is rarely usable. In a round you need to know which part of the argument to attack, what the flaw is called, and what to say in the next forty seconds.</p><p>Attack in DebateOwl is built around that need. Paste an argument or a full case and it returns a structured critique. Every weakness has to do three jobs: quote the exact words it attacks, explain why the link fails and why that matters for the ballot, and give a response you can say word for word. If the argument has fewer real weaknesses, it returns fewer rather than inventing problems.</p><h2>What one Attack analysis contains</h2><ul><li>An overall assessment: a score out of 100, a short summary and what the argument does well, so you know which parts not to waste time on.</li><li>Weaknesses, usually three to six, each marked critical, major or minor and labelled as evidential, logical or structural.</li><li>For each weakness: the quoted words, why the link is weak (missing warrant, no evidence, no link, non-unique, turned or outweighed), and a response to say in round.</li><li>Fallacies detected, with where they appear and how to call them out without sounding like a textbook.</li><li><a href="/how-to-cross-examine-in-debate">Cross-examination</a> questions, each tied to one weakness and written so that a short honest answer exposes the gap.</li><li>A weighing analysis: the weighing the argument relies on, the comparisons it never makes, and how to out-weigh it.</li></ul><p>Attack also runs web research on the argument, so responses can point to counter-evidence. Treat any evidence it mentions as a lead and check the original source before you use it.</p><h2>Settings that change the output</h2><h3>Attack intensity</h3><p>Mild gives constructive criticism, useful when you are checking your own case. Moderate balances strengths and weaknesses. Ruthless looks hardest for anything a strong opponent could exploit, which is what you want when preparing against an opposing case.</p><h3>Judge paradigm</h3><p>Logic-Heavy prioritises broken reasoning and missing warrants. Values-Focused looks at framework and principle, which suits <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> and principled motions. Policy/Impact concentrates on links, probability and the size of impacts, which suits policy-style motions and <a href="/public-forum-debate">Public Forum</a>.</p><h3>Fallacies and weighing</h3><p>Both checks are on by default. Turn fallacy detection off when you only want substantive responses; keep weighing analysis on almost always, because unweighed rebuttal is the most common reason good responses do not win rounds.</p><h2>Worked example: one argument through Attack</h2><div class="card"><h3>Motion: This house would tax sugary drinks</h3><p><strong>Argument pasted:</strong> A sugar tax reduces consumption, because higher prices make people buy less. Lower consumption means less obesity, which saves lives and reduces the burden on public health systems.</p><p><strong>Critical weakness, logical:</strong> Quoted: lower consumption means less obesity. The argument assumes people who buy fewer sugary drinks do not replace those calories with other foods. Without that warrant, the impact does not follow from the mechanism.</p><p><strong>Response to say:</strong> Even if people buy fewer fizzy drinks, they can get the same sugar from sweets, juice and snacks that are not taxed. Cutting one source of calories is not the same as cutting calories.</p><p><strong>Major weakness, evidential:</strong> Quoted: saves lives. The argument gives no estimate of how much consumption falls or how that translates into health outcomes, so the judge cannot weigh the size of the benefit.</p><p><strong>Cross-ex question:</strong> If someone stops buying a sugary drink but buys a chocolate bar instead, has the tax reduced their sugar intake?</p><p><strong>Weighing gap:</strong> The argument never compares its health benefit with the cost to low-income households, who spend a larger share of their income on these drinks. That comparison is your weighing.</p></div><p>The useful part is not that the analysis disagrees with the argument. It identifies the one assumption the argument cannot survive without, gives you a sentence to attack it, and sets up a cross-ex question that makes the opponent concede it before your speech.</p><h2>From generated output to a rebuttal you own</h2><ol><li>Start from the right input. Use the opponent case predicted when you generated your own case, an argument you heard in a previous round, or your own case when you want to find its weak points first.</li><li>Read the critical weaknesses and pick one. In a short speech, one well-explained weakness beats four rushed ones.</li><li>Rewrite the suggested response in your own words. Keep the structure (quote, flaw, response, why it matters) and cut anything you would not naturally say.</li><li>Check any evidence it relies on against the original source.</li><li>Time the response. Most single responses should fit in forty-five seconds.</li><li>Import the cross-examination questions into Crossfire and practise asking them against the AI, which answers from the opposing side.</li><li>Keep the analysis in your Current Debate so the block sits next to the case it answers.</li></ol><h2>Using generated rebuttals by format</h2><h3>Public Forum (PF)</h3><p>Use Policy/Impact for most PF resolutions. Prepare the response and the cross-ex question together, because PF crossfire is where you get the opponent to commit to the assumption you attack in rebuttal.</p><h3>Lincoln-Douglas (LD)</h3><p>Run Values-Focused on the negative case to find where its contentions fail to link to its own criterion. That gap often lets you win under their framework as well as yours.</p><h3>World Schools and British Parliamentary</h3><p>Motions are often released shortly before the round, so use Attack in practice on likely arguments for motion areas you expect, and build a bank of responses to the reasoning that recurs across motions, such as slippery slopes, unproven behaviour change and ignored alternatives.</p><h2>What it cannot do</h2><p>Attack responds to the text you give it. It cannot hear how your opponent actually framed an argument, and it cannot tell you what a particular judge will find persuasive. Most leagues also do not allow internet or AI tools during rounds, so it is a preparation tool: build and practise the blocks before the tournament, then adapt them by ear in the round.</p></div>
+      <div class="article section"><h2>What a good rebuttal generator should give you</h2><p>Generic AI tools answer the request to rebut an argument by writing a counter-essay: a few paragraphs on why the other side is wrong. That is rarely usable. In a round you need to know which part of the argument to attack, what the flaw is called, and what to say in the next forty seconds.</p><p>Attack in DebateOwl is built around that need. Paste an argument or a full case and it returns a structured critique. Every weakness has to do three jobs: quote the exact words it attacks, explain why the link fails and why that matters for the ballot, and give a response you can say word for word. If the argument has fewer real weaknesses, it returns fewer rather than inventing problems.</p><h2>What one Attack analysis contains</h2><ul><li>An overall assessment: a score out of 100, a short summary and what the argument does well, so you know which parts not to waste time on.</li><li>Weaknesses, usually three to six, each marked critical, major or minor and labelled as evidential, logical or structural.</li><li>For each weakness: the quoted words, why the link is weak (missing warrant, no evidence, no link, non-unique, turned or outweighed), and a response to say in round.</li><li>Fallacies detected, with where they appear and how to call them out without sounding like a textbook.</li><li><a href="/how-to-cross-examine-in-debate">Cross-examination</a> questions, each tied to one weakness and written so that a short honest answer exposes the gap.</li><li>A weighing analysis: the weighing the argument relies on, the comparisons it never makes, and how to out-weigh it.</li></ul><p>Attack also runs web research on the argument, so responses can point to counter-evidence. Treat any evidence it mentions as a lead and check the original source before you use it.</p><h2>Settings that change the output</h2><h3>Attack intensity</h3><p>Mild gives constructive criticism, useful when you are checking your own case. Moderate balances strengths and weaknesses. Ruthless looks hardest for anything a strong opponent could exploit, which is what you want when preparing against an opposing case.</p><h3>Judge paradigm</h3><p>Logic-Heavy prioritises broken reasoning and missing warrants. Values-Focused looks at framework and principle, which suits <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> and principled motions. Policy/Impact concentrates on links, probability and the size of impacts, which suits policy-style motions and <a href="/public-forum-debate">Public Forum</a>.</p><h3>Fallacies and weighing</h3><p>Both checks are on by default. Turn fallacy detection off when you only want substantive responses; keep weighing analysis on almost always, because unweighed rebuttal is the most common reason good responses do not win rounds.</p><h2>Worked example: one argument through Attack</h2><div class="card"><h3>Motion: This house would tax sugary drinks</h3><p><strong>Argument pasted:</strong> A sugar tax reduces consumption, because higher prices make people buy less. Lower consumption means less obesity, which saves lives and reduces the burden on public health systems.</p><p><strong>Critical weakness, logical:</strong> Quoted: lower consumption means less obesity. The argument assumes people who buy fewer sugary drinks do not replace those calories with other foods. Without that warrant, the impact does not follow from the mechanism.</p><p><strong>Response to say:</strong> Even if people buy fewer fizzy drinks, they can get the same sugar from sweets, juice and snacks that are not taxed. Cutting one source of calories is not the same as cutting calories.</p><p><strong>Major weakness, evidential:</strong> Quoted: saves lives. The argument gives no estimate of how much consumption falls or how that translates into health outcomes, so the judge cannot weigh the size of the benefit.</p><p><strong>Cross-ex question:</strong> If someone stops buying a sugary drink but buys a chocolate bar instead, has the tax reduced their sugar intake?</p><p><strong>Weighing gap:</strong> The argument never compares its health benefit with the cost to low-income households, who spend a larger share of their income on these drinks. That comparison is your weighing.</p></div><p>The useful part is not that the analysis disagrees with the argument. It identifies the one assumption the argument cannot survive without, gives you a sentence to attack it, and sets up a cross-ex question that makes the opponent concede it before your speech.</p><h2>From generated output to a rebuttal you own</h2><ol><li>Start from the right input. Use a claim from the &quot;If they say…&quot; answers in a case you generated, an argument you heard in a previous round, or your own case when you want to find its weak points first.</li><li>Read the critical weaknesses and pick one. In a short speech, one well-explained weakness beats four rushed ones.</li><li>Rewrite the suggested response in your own words. Keep the structure (quote, flaw, response, why it matters) and cut anything you would not naturally say.</li><li>Check any evidence it relies on against the original source.</li><li>Time the response. Most single responses should fit in forty-five seconds.</li><li>Import the cross-examination questions into Crossfire and practise asking them against the AI, which answers from the opposing side.</li><li>Keep the analysis in your Current Debate so the block sits next to the case it answers.</li></ol><h2>Using generated rebuttals by format</h2><h3>Public Forum (PF)</h3><p>Use Policy/Impact for most PF resolutions. Prepare the response and the cross-ex question together, because PF crossfire is where you get the opponent to commit to the assumption you attack in rebuttal.</p><h3>Lincoln-Douglas (LD)</h3><p>Run Values-Focused on the negative case to find where its contentions fail to link to its own criterion. That gap often lets you win under their framework as well as yours.</p><h3>World Schools and British Parliamentary</h3><p>Motions are often released shortly before the round, so use Attack in practice on likely arguments for motion areas you expect, and build a bank of responses to the reasoning that recurs across motions, such as slippery slopes, unproven behaviour change and ignored alternatives.</p><h2>What it cannot do</h2><p>Attack responds to the text you give it. It cannot hear how your opponent actually framed an argument, and it cannot tell you what a particular judge will find persuasive. Most leagues also do not allow internet or AI tools during rounds, so it is a preparation tool: build and practise the blocks before the tournament, then adapt them by ear in the round.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>What does the AI rebuttal generator produce?</summary><p>A ranked list of weaknesses, each quoting the attacked words with an explanation and a response to say in round, plus detected fallacies, cross-examination questions and a weighing analysis.</p></details><details><summary>Can I use it on my own case?</summary><p>Yes, and you should. Set the intensity to Mild or Moderate to find your weak points before an opponent does, then fix them or prepare an answer.</p></details><details><summary>Is it allowed to use an AI rebuttal generator in a debate round?</summary><p>Most leagues restrict or ban internet and AI use during rounds. Check your league&#x27;s rules and use the tool to prepare blocks beforehand.</p></details><details><summary>Are the rebuttals backed by evidence?</summary><p>Attack runs web research and can point to counter-evidence. Treat anything it cites as a lead and check the original source before using it.</p></details><details><summary>How is this different from asking a chatbot to rebut an argument?</summary><p>The output is structured for a round: each response targets quoted words, names the broken link and comes with a cross-ex question and weighing, instead of a general essay against the other side.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/argument-flowchart/index.html b/public/argument-flowchart/index.html
index 6d6b82f9f..cb09e014e 100644
--- a/public/argument-flowchart/index.html
+++ b/public/argument-flowchart/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Argument Flowchart for Debate | DebateOwl</title>
-  <meta name="description" content="DebateOwl turns a debate case and its rebuttals into a flowchart of claims, warrants, impacts and weighing, so you can see where the clash is." />
+  <meta name="description" content="DebateOwl turns a debate case and its rebuttals into a flowchart of your arguments, their attacks and your answers, so you can see where the clash is." />
   <meta name="robots" content="index, follow, max-snippet:-1, max-image-preview:large" />
   <link rel="canonical" href="https://debateowl.com/argument-flowchart" />
   <meta name="author" content="DebateOwl" />
@@ -16,21 +16,21 @@
   <meta property="og:type" content="article" />
   <meta property="og:site_name" content="DebateOwl" />
   <meta property="og:title" content="Argument Flowchart for Debate | DebateOwl" />
-  <meta property="og:description" content="DebateOwl turns a debate case and its rebuttals into a flowchart of claims, warrants, impacts and weighing, so you can see where the clash is." />
+  <meta property="og:description" content="DebateOwl turns a debate case and its rebuttals into a flowchart of your arguments, their attacks and your answers, so you can see where the clash is." />
   <meta property="og:url" content="https://debateowl.com/argument-flowchart" />
   <meta property="og:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta property="og:image:width" content="1200" />
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="Argument Flowchart for Debate | DebateOwl" />
-  <meta name="twitter:description" content="DebateOwl turns a debate case and its rebuttals into a flowchart of claims, warrants, impacts and weighing, so you can see where the clash is." />
+  <meta name="twitter:description" content="DebateOwl turns a debate case and its rebuttals into a flowchart of your arguments, their attacks and your answers, so you can see where the clash is." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Map the Clash With an Argument Flowchart","name":"Argument Flowchart for Debate | DebateOwl","url":"https://debateowl.com/argument-flowchart","description":"DebateOwl turns a debate case and its rebuttals into a flowchart of claims, warrants, impacts and weighing, so you can see where the clash is.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"When is an argument flowchart useful for debate prep?","acceptedAnswer":{"@type":"Answer","text":"It is useful before and after a round, not during one. A flowchart maps your thesis, your arguments, the attacks on them and your rebuttals, so you can see which link breaks a chain and where two contentions rely on the same assumption. Build it from the motion outward, add the strongest attack to each contention, and note the weighing at each clash. During the round itself, a written flow on paper or a laptop is faster than any canvas, so keep your in-round notes there and use the map to plan and review."}},{"@type":"Question","name":"What is an argument flowchart in debate?","acceptedAnswer":{"@type":"Answer","text":"A diagram of a case: the thesis, the arguments that support it, the attacks on them and the responses, joined by links that show what depends on what."}},{"@type":"Question","name":"Is a flowchart the same as flowing?","acceptedAnswer":{"@type":"Answer","text":"No. Flowing is note-taking during a round, speech by speech. A flowchart is a map you build before or after a round to plan and review the clash."}},{"@type":"Question","name":"Can I save and share a flowchart?","acceptedAnswer":{"@type":"Answer","text":"Yes. Save it to the Current Debate to load it later, or export it as a PNG image to share with a partner or coach."}},{"@type":"Question","name":"How many arguments should a flowchart have?","acceptedAnswer":{"@type":"Answer","text":"As many as the case has, but the useful part is the two or three clashes that decide the round. If the map is too crowded to read, collapse it to those."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Map the Clash With an Argument Flowchart","item":"https://debateowl.com/argument-flowchart"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Map the Clash With an Argument Flowchart","name":"Argument Flowchart for Debate | DebateOwl","url":"https://debateowl.com/argument-flowchart","description":"DebateOwl turns a debate case and its rebuttals into a flowchart of your arguments, their attacks and your answers, so you can see where the clash is.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"When is an argument flowchart useful for debate prep?","acceptedAnswer":{"@type":"Answer","text":"It is useful before and after a round, not during one. A flowchart maps your case's main line, your arguments, the attacks on them and your answers, so you can see which link breaks a chain and where two arguments rely on the same assumption. Build it from the motion outward, add the strongest attack to each argument, and note at each clash why your side matters more. During the round itself, a written flow on paper or a laptop is faster than any canvas, so keep your in-round notes there and use the map to plan and review."}},{"@type":"Question","name":"What is an argument flowchart in debate?","acceptedAnswer":{"@type":"Answer","text":"A diagram of a case: its main line, the arguments that support it, the attacks on them and the answers, joined by links that show what depends on what."}},{"@type":"Question","name":"Is a flowchart the same as flowing?","acceptedAnswer":{"@type":"Answer","text":"No. Flowing is note-taking during a round, speech by speech. A flowchart is a map you build before or after a round to plan and review the clash."}},{"@type":"Question","name":"Can I save and share a flowchart?","acceptedAnswer":{"@type":"Answer","text":"Yes. Save it to the Current Debate to load it later, or export it as a PNG image to share with a partner or coach."}},{"@type":"Question","name":"How many arguments should a flowchart have?","acceptedAnswer":{"@type":"Answer","text":"As many as the case has, but the useful part is the two or three clashes that decide the round. If the map is too crowded to read, collapse it to those."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Map the Clash With an Argument Flowchart","item":"https://debateowl.com/argument-flowchart"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,12 +39,12 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">Map the Clash With an Argument Flowchart</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Flowing guide</span><h1>Map the Clash With an Argument Flowchart</h1><p class="lead">Turn cases and rebuttals into a visual map of claims, warrants, impacts, and weighing.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
-      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">When is an argument flowchart useful for debate prep?</h2><p>It is useful before and after a round, not during one. A flowchart maps your thesis, your arguments, the attacks on them and your rebuttals, so you can see which link breaks a chain and where two contentions rely on the same assumption. Build it from the motion outward, add the strongest attack to each contention, and note the weighing at each clash. During the round itself, a written flow on paper or a laptop is faster than any canvas, so keep your in-round notes there and use the map to plan and review.</p></section>
+      <header class="hero"><span class="eyebrow">Flowing guide</span><h1>Map the Clash With an Argument Flowchart</h1><p class="lead">Turn cases and rebuttals into a visual map of arguments, attacks, and answers.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">When is an argument flowchart useful for debate prep?</h2><p>It is useful before and after a round, not during one. A flowchart maps your case&#x27;s main line, your arguments, the attacks on them and your answers, so you can see which link breaks a chain and where two arguments rely on the same assumption. Build it from the motion outward, add the strongest attack to each argument, and note at each clash why your side matters more. During the round itself, a written flow on paper or a laptop is faster than any canvas, so keep your in-round notes there and use the map to plan and review.</p></section>
       
-      <section class="grid" aria-label="Highlights"><article class="card"><h3>Visual clash maps</h3><p class="muted">Put the thesis, each argument, the attacks on it and your rebuttals on one canvas, so you can see where the round will be decided.</p></article><article class="card"><h3>Link and strength tracking</h3><p class="muted">Mark each argument strong, moderate or weak, and connect nodes with support, attack and rebuttal links.</p></article><article class="card"><h3>Saved with your debate</h3><p class="muted">Flowcharts save to the Current Debate next to its case and rebuttals, and export as a PNG for teammates.</p></article></section>
-      <div class="article section"><h2>Why map arguments at all</h2><p>Arguments are chains: a claim depends on a warrant, the warrant on an assumption, and the impact on all of them. When one link breaks, the whole contention falls. A flowchart makes the chain visible, so you can see which link the other side will attack and which link of theirs you should attack.</p><p>A map also shows what a written case hides. Two contentions that rely on the same assumption look independent on paper; on a map they share a node, and one good response takes out both.</p><h2>How the DebateOwl flowchart works</h2><p>A new flowchart starts with a thesis, three example arguments, an opponent attack and a rebuttal, all of which you can edit or delete. Each node has a label, a description and a type:</p><ul><li>Thesis: the position your side has to prove.</li><li>Argument: a contention, rated strong, moderate or weak.</li><li>Attack: an opposing response to one of your arguments.</li><li>Rebuttal: your answer to an attack.</li><li>Dropped: an argument nobody answered.</li></ul><p>Links between nodes are support, attack or rebuttal, each drawn in its own style. Save the chart to the Current Debate, load it again later, or export it as an image.</p><h2>Build from the motion outward</h2><ol><li>Write the thesis as one sentence: what your side must prove for the motion.</li><li>Add each contention as an argument node and link it to the thesis. Rate it honestly; a weak node is one to fix or cut.</li><li>For each contention, add the strongest attack you expect. If you have generated a case, the predicted opponent case is the place to find them.</li><li>Add your rebuttal to each attack. Where you cannot write one, the map has found your gap.</li><li>Mark <a href="/how-to-weigh-in-debate">weighing</a> at each clash in a node&#x27;s description: why your side of that clash matters more.</li></ol><p>Build the opposing case the same way on a second chart. Most rounds turn on two or three clashes, and the two maps side by side show which ones.</p><h2>Worked example: mapping one clash</h2><div class="card"><h3>Motion: This house would ban single-use plastics</h3><p><strong>Thesis:</strong> A ban cuts plastic pollution at its largest source.</p><p><strong>Argument (strong):</strong> Single-use items are a large share of plastic waste and are rarely recycled.</p><p><strong>Attack:</strong> Substitutes such as paper and glass have a higher carbon footprint per use.</p><p><strong>Rebuttal:</strong> The comparison only holds if reusable items are used a few times; reuse, not substitution, is the goal of the ban.</p><p><strong>Weighing note:</strong> Plastic pollution lasts for centuries and cannot be reversed, while the footprint of substitutes falls with every reuse.</p></div><p>The map makes it obvious that the round turns on the substitution clash. That is where the rebuttal speech and the weighing should go.</p><h2>Use the map in your speeches</h2><p>Before you speak, look for the path that wins: the strongest argument still standing after the attacks, and the weighing that makes it outweigh. Speak to that path and <a href="/debate-clash-points">drop the rest</a>. A good map helps you collapse instead of spreading yourself thin.</p><p>During a round, a written flow is faster than any canvas. Use the flowchart to prepare before the round and to review the clashes after it, and keep your in-round flow on paper or a laptop.</p></div>
-      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>What is an argument flowchart in debate?</summary><p>A diagram of a case: the thesis, the arguments that support it, the attacks on them and the responses, joined by links that show what depends on what.</p></details><details><summary>Is a flowchart the same as flowing?</summary><p>No. Flowing is note-taking during a round, speech by speech. A flowchart is a map you build before or after a round to plan and review the clash.</p></details><details><summary>Can I save and share a flowchart?</summary><p>Yes. Save it to the Current Debate to load it later, or export it as a PNG image to share with a partner or coach.</p></details><details><summary>How many arguments should a flowchart have?</summary><p>As many as the case has, but the useful part is the two or three clashes that decide the round. If the map is too crowded to read, collapse it to those.</p></details></section>
+      <section class="grid" aria-label="Highlights"><article class="card"><h3>Visual clash maps</h3><p class="muted">Put your case&#x27;s main line, each argument, the attacks on it and your answers on one canvas, so you can see where the round will be decided.</p></article><article class="card"><h3>Link and strength tracking</h3><p class="muted">Mark each argument strong, moderate or weak, and connect nodes with support, attack and rebuttal links.</p></article><article class="card"><h3>Saved with your debate</h3><p class="muted">Flowcharts save to the Current Debate next to its case and rebuttals, and export as a PNG for teammates.</p></article></section>
+      <div class="article section"><h2>Why map arguments at all</h2><p>Arguments are chains: a point depends on its explanation, the explanation on an assumption, and why it matters on all of them. When one link breaks, the whole argument falls. A flowchart makes the chain visible, so you can see which link the other side will attack and which link of theirs you should attack.</p><p>A map also shows what a written case hides. Two arguments that rely on the same assumption look independent on paper; on a map they share a node, and one good response takes out both.</p><h2>How the DebateOwl flowchart works</h2><p>A new flowchart starts with a top node for your case&#x27;s main line, three example arguments, an opponent attack and a rebuttal, all of which you can edit or delete. Each node has a label, a description and a type:</p><ul><li>Thesis: your case&#x27;s main line, the one sentence your side has to prove.</li><li>Argument: one of your arguments, rated strong, moderate or weak.</li><li>Attack: an opposing response to one of your arguments.</li><li>Rebuttal: your answer to an attack.</li><li>Dropped: an argument nobody answered.</li></ul><p>Links between nodes are support, attack or rebuttal, each drawn in its own style. Save the chart to the Current Debate, load it again later, or export it as an image.</p><p>A generated case can build the map for you. Choose Flowcharts under the case: the opening&#x27;s &quot;we will show&quot; line goes at the top, each argument becomes a node with its point and <a href="/debate-evidence-finder">evidence</a>, each &quot;If they say…&quot; claim becomes an attack, and our answer becomes the rebuttal to it.</p><h2>Build from the motion outward</h2><ol><li>Write the main line as one sentence: what your side must prove for the motion.</li><li>Add each argument as a node and link it to the main line. Rate it honestly; a weak node is one to fix or cut.</li><li>For each argument, add the strongest attack you expect. If you have generated a case, its &quot;If they say…&quot; claims are the place to find them.</li><li>Add your rebuttal to each attack. Where you cannot write one, the map has found your gap.</li><li>At each clash, note in a node&#x27;s description why your side of it matters more.</li></ol><p>Build the opposing case the same way on a second chart. Most rounds turn on two or three clashes, and the two maps side by side show which ones.</p><h2>Worked example: mapping one clash</h2><div class="card"><h3>Motion: This house would ban single-use plastics</h3><p><strong>Main line:</strong> A ban cuts plastic pollution at its largest source.</p><p><strong>Argument (strong):</strong> Single-use items are a large share of plastic waste and are rarely recycled.</p><p><strong>Attack:</strong> Substitutes such as paper and glass have a higher carbon footprint per use.</p><p><strong>Rebuttal:</strong> The comparison only holds if reusable items are used a few times; reuse, not substitution, is the goal of the ban.</p><p><strong>Why ours matters more:</strong> Plastic pollution lasts for centuries and cannot be reversed, while the footprint of substitutes falls with every reuse.</p></div><p>The map makes it obvious that the round turns on the substitution clash. That is where the rebuttal speech and the comparison should go.</p><h2>Use the map in your speeches</h2><p>Before you speak, look for the path that wins: the strongest argument still standing after the attacks, and the reason it matters more than theirs. Speak to that path and <a href="/debate-clash-points">drop the rest</a>. A good map helps you collapse instead of spreading yourself thin.</p><p>During a round, a written flow is faster than any canvas. Use the flowchart to prepare before the round and to review the clashes after it, and keep your in-round flow on paper or a laptop.</p></div>
+      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>What is an argument flowchart in debate?</summary><p>A diagram of a case: its main line, the arguments that support it, the attacks on them and the answers, joined by links that show what depends on what.</p></details><details><summary>Is a flowchart the same as flowing?</summary><p>No. Flowing is note-taking during a round, speech by speech. A flowchart is a map you build before or after a round to plan and review the clash.</p></details><details><summary>Can I save and share a flowchart?</summary><p>Yes. Save it to the Current Debate to load it later, or export it as a PNG image to share with a partner or coach.</p></details><details><summary>How many arguments should a flowchart have?</summary><p>As many as the case has, but the useful part is the two or three clashes that decide the round. If the map is too crowded to read, collapse it to those.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
     <section class="section article" aria-labelledby="related"><h2 id="related">Related DebateOwl guides</h2><nav class="links" aria-label="Related guides"><a href="/online-debate-timer">How Debate Speech Times Work in Each Format</a>
diff --git a/public/best-ai-debate-tools/index.html b/public/best-ai-debate-tools/index.html
index 3c54764f8..13093057b 100644
--- a/public/best-ai-debate-tools/index.html
+++ b/public/best-ai-debate-tools/index.html
@@ -23,14 +23,14 @@
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="Best AI Debate Tools Compared | DebateOwl" />
   <meta name="twitter:description" content="A comparison of AI debate tools on case generation, rebuttal practice, evidence research, practice rounds and pricing, to help you choose one." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Best AI Debate Tools Compared","name":"Best AI Debate Tools Compared | DebateOwl","url":"https://debateowl.com/best-ai-debate-tools","description":"A comparison of AI debate tools on case generation, rebuttal practice, evidence research, practice rounds and pricing, to help you choose one.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which AI debate tool should you use?","acceptedAnswer":{"@type":"Answer","text":"It depends on the job. For brainstorming or learning a topic, a general chatbot such as ChatGPT is flexible. For motion-by-motion prep plus timed practice rounds that end in a verdict, a dedicated platform such as DebateOwl fits. As of October 2026, debatelab.ai, a separate product, says it is free and runs World Schools and Asian Parliamentary practice, and WinDebate adds round replay and progress tracking from $19.99/month. Give each tool the same motion and tasks before you decide."}},{"@type":"Question","name":"What is the best AI tool for debate?","acceptedAnswer":{"@type":"Answer","text":"It depends on the job. General chatbots are flexible for brainstorming, research tools find sources, and dedicated debate platforms add structure, opponents and practice. Most debaters do best with a dedicated platform plus a way to verify sources."}},{"@type":"Question","name":"Is a general chatbot good enough for debate prep?","acceptedAnswer":{"@type":"Answer","text":"For brainstorming and explaining concepts, often yes. It is weaker at keeping a motion, side and format in context, predicting the opposing case, timing speeches and giving round-style feedback."}},{"@type":"Question","name":"Are free AI debate tools enough?","acceptedAnswer":{"@type":"Answer","text":"Free tiers are a good way to run the comparison test. Check the daily or monthly limits against how many practice sessions you plan before a tournament."}},{"@type":"Question","name":"Can I use AI tools during a debate round?","acceptedAnswer":{"@type":"Answer","text":"Usually not. Most leagues restrict or ban internet access and electronic help during rounds. Check your league's rules, and use AI tools for preparation."}},{"@type":"Question","name":"What are the alternatives to DebateOwl?","acceptedAnswer":{"@type":"Answer","text":"General chatbots, AI research assistants, other dedicated debate platforms, and simple practice utilities such as timers and flowing templates. Run the one-hour test above on DebateOwl and on each alternative you are considering."}},{"@type":"Question","name":"How should I compare AI debate tools fairly?","acceptedAnswer":{"@type":"Answer","text":"Give every tool the same motion and the same tasks, such as a case, the strongest counter, feedback on your speech and evidence for one claim, then score each answer against the same criteria."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Best AI Debate Tools Compared","item":"https://debateowl.com/best-ai-debate-tools"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Best AI Debate Tools Compared","name":"Best AI Debate Tools Compared | DebateOwl","url":"https://debateowl.com/best-ai-debate-tools","description":"A comparison of AI debate tools on case generation, rebuttal practice, evidence research, practice rounds and pricing, to help you choose one.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which AI debate tool should you use?","acceptedAnswer":{"@type":"Answer","text":"It depends on the job. For brainstorming or learning a topic, a general chatbot such as ChatGPT is flexible. For motion-by-motion prep plus timed practice rounds that end in a verdict, a dedicated platform such as DebateOwl fits. As of October 2026, debatelab.ai, a separate product, says it is free and runs World Schools and Asian Parliamentary practice, and WinDebate adds round replay and progress tracking from $19.99/month. Give each tool the same motion and tasks before you decide."}},{"@type":"Question","name":"What is the best AI tool for debate?","acceptedAnswer":{"@type":"Answer","text":"It depends on the job. General chatbots are flexible for brainstorming, research tools find sources, and dedicated debate platforms add structure, opponents and practice. Most debaters do best with a dedicated platform plus a way to verify sources."}},{"@type":"Question","name":"Is a general chatbot good enough for debate prep?","acceptedAnswer":{"@type":"Answer","text":"For brainstorming and explaining concepts, often yes. It is weaker at keeping a motion, side and format in context, predicting the opposing case, timing speeches and giving round-style feedback."}},{"@type":"Question","name":"Are free AI debate tools enough?","acceptedAnswer":{"@type":"Answer","text":"Free tiers are a good way to run the comparison test. Check the daily or monthly limits against how many practice sessions you plan before a tournament."}},{"@type":"Question","name":"Can I use AI tools during a debate round?","acceptedAnswer":{"@type":"Answer","text":"Usually not. Most leagues restrict or ban internet access and electronic help during rounds. Check your league's rules, and use AI tools for preparation."}},{"@type":"Question","name":"What are the alternatives to DebateOwl?","acceptedAnswer":{"@type":"Answer","text":"General chatbots, AI research assistants, other dedicated debate platforms, and simple practice utilities such as timers and flowing templates. Run the one-hour test above on DebateOwl and on each alternative you are considering."}},{"@type":"Question","name":"How should I compare AI debate tools fairly?","acceptedAnswer":{"@type":"Answer","text":"Give every tool the same motion and the same tasks, such as a case, the strongest counter, feedback on your speech and evidence for one claim, then score each answer against the same criteria."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Best AI Debate Tools Compared","item":"https://debateowl.com/best-ai-debate-tools"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">Best AI Debate Tools Compared</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Comparison</span><h1>Best AI Debate Tools Compared</h1><p class="lead">See how AI debate tools compare on features, formats, and prep workflows.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">Comparison</span><h1>Best AI Debate Tools Compared</h1><p class="lead">See how AI debate tools compare on features, formats, and prep workflows.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Which AI debate tool should you use?</h2><p>It depends on the job. For brainstorming or learning a topic, a general chatbot such as ChatGPT is flexible. For motion-by-motion prep plus timed practice rounds that end in a verdict, a dedicated platform such as DebateOwl fits. As of October 2026, debatelab.ai, a separate product, says it is free and runs World Schools and Asian Parliamentary practice, and WinDebate adds round replay and progress tracking from $19.99/month. Give each tool the same motion and tasks before you decide.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Feature comparison</h3><p class="muted">What each kind of tool does well: general chatbots, research assistants, dedicated debate platforms, and timers or flowing tools.</p></article><article class="card"><h3>Format coverage</h3><p class="muted">Which formats a tool actually models, from Public Forum and Lincoln-Douglas to WSDC and British Parliamentary, and where you still prep by hand.</p></article><article class="card"><h3>Workflow differences</h3><p class="muted">Whether cases, sources, practice rounds and feedback stay connected to one motion, or end up scattered across chats and documents.</p></article></section>
-      <div class="article section"><h2>The four kinds of AI debate tool</h2><p>Debaters use AI tools for different jobs, and the categories overlap less than the marketing suggests. Most prep setups combine at least two of these.</p><h3>General AI chatbots</h3><p>Assistants such as ChatGPT, Claude and Gemini are flexible and good at brainstorming, explaining a concept or tightening a paragraph. Their weakness for debate is structure: they do not hold a motion, side and format across sessions unless you rebuild the context each time, and they will produce confident claims without sources unless you ask.</p><h3>Research and citation tools</h3><p>AI search and research assistants are strongest at finding sources quickly. They help with evidence but not with turning evidence into arguments, rebuttals or speeches.</p><h3>Dedicated debate platforms</h3><p>These are built around debate concepts: cases with contentions, rebuttals, opponents and verdicts. They vary a great deal in which formats they model and whether they let you practise or only generate text.</p><h3>Practice utilities</h3><p>Timers, flowing templates and argument maps. Often simple, sometimes not AI-based at all, and still essential for practice that matches tournament conditions.</p><h2>Eight criteria for comparing AI debate tools</h2><ol><li>Structure: does the output separate claim, warrant and impact, or is it a wall of text?</li><li>Format awareness: does it know your speech order, times and roles, or treat every debate as an essay?</li><li>Sources: can you see where a claim comes from, and can you add your own material for it to use?</li><li>Opposition: does it predict and argue the other side, or only help with yours?</li><li>Practice: can you deliver a speech and get a response to it, not just read generated text?</li><li>Feedback: does it tell you why an argument failed, with something specific to fix?</li><li>Continuity: does work stay organised by motion, or do you lose it in a long chat history?</li><li>Limits and privacy: what is the daily or monthly allowance, and who can see your prep?</li></ol><p>Weight the criteria by what you need. A novice benefits most from structure and feedback; an experienced competitor often cares most about sources, opposition and practice.</p><h2>A one-hour test you can run on any tool</h2><p>Reviews and feature lists only go so far. The fairest comparison is to give every tool the same motion and the same tasks:</p><ol><li>Pick a motion in your format that you know well, so you can judge the quality of the answers.</li><li>Ask each tool for a case on one side. Score it on structure and on whether the warrants actually prove the claims.</li><li>Ask each tool for the strongest argument against that case. Score whether it found the real weak point or a generic objection.</li><li>Paste one of your own past speeches and ask what it would change. Score how specific the feedback is.</li><li>Ask for evidence on one factual claim. Open every source and score how many check out.</li><li>Note how much context you had to repeat between steps.</li></ol><p>Fifteen minutes per tool is enough to see the difference. Keep the scores; they are more useful than any ranking list, including this one.</p><h2>Worked example: scoring answers to one motion</h2><div class="card"><h3>Motion: This house would make voting compulsory</h3><p><strong>Task:</strong> Find the weakest link in the proposition argument that compulsory voting produces a more representative government.</p><p><strong>Strong answer:</strong> Points out that turnout and representation are different: compelled voters who know little about the candidates may vote randomly or for the first name on the ballot, so higher turnout may not mean preferences are better represented.</p><p><strong>Weak answer:</strong> Says compulsory voting violates freedom. That is an opposition argument, not an attack on the proposition&#x27;s link, and it does not engage with representation at all.</p><p><strong>How to score it:</strong> Give the point only if the tool attacked the warrant (why more voters means better representation) rather than changing the subject.</p></div><p>Running the same task through several tools shows quickly which ones understand debate structure and which ones produce plausible but generic text.</p><h2>Which tools fit which format</h2><h3>World Schools (WSDC)</h3><p>WSDC prep is team prep under time pressure, often for impromptu motions. Prioritise fast brainstorming and motion analysis, plus a way to practise Points of Information. Few tools model the full WSDC round, so expect to time speeches yourself.</p><h3>British Parliamentary (BP)</h3><p>BP rewards role knowledge and extensions. Look for tools that let you set the format and your team position, and that can show you what the opening half is likely to say so <a href="/british-parliamentary-debate">closing teams</a> can plan something new.</p><h3>Public Forum (PF)</h3><p>PF depends on evidence and on keeping summary and <a href="/public-forum-debate">final focus</a> consistent. Strong source handling matters more here than in most formats, along with practice rounds that use real PF speech times.</p><h3>Lincoln-Douglas (LD)</h3><p>LD needs tools that handle <a href="/lincoln-douglas-debate">value and criterion</a>, not just policy arguments. Test whether a tool can defend a framework and link contentions to it, and whether it can practise the time-pressured 1AR.</p><h2>Where DebateOwl fits</h2><p>DebateOwl is a dedicated debate platform that keeps every case, source, round and debrief inside one Current Debate. It covers case generation with a predicted opponent case, Library sources that ground its answers, Attack for finding weak links, Brainstorm, Factoids for checking claims, an Ask coaching chat with optional citations, Crossfire and full Sparring rounds with a verdict, a speech timer and an argument flowchart.</p><p>Its limits are worth stating plainly. Sparring currently runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, so WSDC and BP practice uses the prep and coaching tools rather than a full simulated round. Like every AI tool, its evidence leads need checking against the original source. Run the one-hour test above and decide on your own results.</p></div>
+      <div class="article section"><h2>The four kinds of AI debate tool</h2><p>Debaters use AI tools for different jobs, and the categories overlap less than the marketing suggests. Most prep setups combine at least two of these.</p><h3>General AI chatbots</h3><p>Assistants such as ChatGPT, Claude and Gemini are flexible and good at brainstorming, explaining a concept or tightening a paragraph. Their weakness for debate is structure: they do not hold a motion, side and format across sessions unless you rebuild the context each time, and they will produce confident claims without sources unless you ask.</p><h3>Research and citation tools</h3><p>AI search and research assistants are strongest at finding sources quickly. They help with evidence but not with turning evidence into arguments, rebuttals or speeches.</p><h3>Dedicated debate platforms</h3><p>These are built around debate concepts: cases with contentions, rebuttals, opponents and verdicts. They vary a great deal in which formats they model and whether they let you practise or only generate text.</p><h3>Practice utilities</h3><p>Timers, flowing templates and argument maps. Often simple, sometimes not AI-based at all, and still essential for practice that matches tournament conditions.</p><h2>Eight criteria for comparing AI debate tools</h2><ol><li>Structure: does the output separate claim, warrant and impact, or is it a wall of text?</li><li>Format awareness: does it know your speech order, times and roles, or treat every debate as an essay?</li><li>Sources: can you see where a claim comes from, and can you add your own material for it to use?</li><li>Opposition: does it predict and argue the other side, or only help with yours?</li><li>Practice: can you deliver a speech and get a response to it, not just read generated text?</li><li>Feedback: does it tell you why an argument failed, with something specific to fix?</li><li>Continuity: does work stay organised by motion, or do you lose it in a long chat history?</li><li>Limits and privacy: what is the daily or monthly allowance, and who can see your prep?</li></ol><p>Weight the criteria by what you need. A novice benefits most from structure and feedback; an experienced competitor often cares most about sources, opposition and practice.</p><h2>A one-hour test you can run on any tool</h2><p>Reviews and feature lists only go so far. The fairest comparison is to give every tool the same motion and the same tasks:</p><ol><li>Pick a motion in your format that you know well, so you can judge the quality of the answers.</li><li>Ask each tool for a case on one side. Score it on structure and on whether the warrants actually prove the claims.</li><li>Ask each tool for the strongest argument against that case. Score whether it found the real weak point or a generic objection.</li><li>Paste one of your own past speeches and ask what it would change. Score how specific the feedback is.</li><li>Ask for evidence on one factual claim. Open every source and score how many check out.</li><li>Note how much context you had to repeat between steps.</li></ol><p>Fifteen minutes per tool is enough to see the difference. Keep the scores; they are more useful than any ranking list, including this one.</p><h2>Worked example: scoring answers to one motion</h2><div class="card"><h3>Motion: This house would make voting compulsory</h3><p><strong>Task:</strong> Find the weakest link in the proposition argument that compulsory voting produces a more representative government.</p><p><strong>Strong answer:</strong> Points out that turnout and representation are different: compelled voters who know little about the candidates may vote randomly or for the first name on the ballot, so higher turnout may not mean preferences are better represented.</p><p><strong>Weak answer:</strong> Says compulsory voting violates freedom. That is an opposition argument, not an attack on the proposition&#x27;s link, and it does not engage with representation at all.</p><p><strong>How to score it:</strong> Give the point only if the tool attacked the warrant (why more voters means better representation) rather than changing the subject.</p></div><p>Running the same task through several tools shows quickly which ones understand debate structure and which ones produce plausible but generic text.</p><h2>Which tools fit which format</h2><h3>World Schools (WSDC)</h3><p>WSDC prep is team prep under time pressure, often for impromptu motions. Prioritise fast brainstorming and motion analysis, plus a way to practise Points of Information. Few tools model the full WSDC round, so expect to time speeches yourself.</p><h3>British Parliamentary (BP)</h3><p>BP rewards role knowledge and extensions. Look for tools that let you set the format and your team position, and that can show you what the opening half is likely to say so <a href="/british-parliamentary-debate">closing teams</a> can plan something new.</p><h3>Public Forum (PF)</h3><p>PF depends on evidence and on keeping summary and <a href="/public-forum-debate">final focus</a> consistent. Strong source handling matters more here than in most formats, along with practice rounds that use real PF speech times.</p><h3>Lincoln-Douglas (LD)</h3><p>LD needs tools that handle <a href="/lincoln-douglas-debate">value and criterion</a>, not just policy arguments. Test whether a tool can defend a framework and link contentions to it, and whether it can practise the time-pressured 1AR.</p><h2>Where DebateOwl fits</h2><p>DebateOwl is a dedicated debate platform that keeps every case, source, round and debrief inside one Current Debate. It covers case generation with &quot;If they say…&quot; answers to the other side, Library sources that ground its answers, Attack for finding weak links, Brainstorm, Factoids for checking claims, an Ask coaching chat with optional citations, Crossfire and full Sparring rounds with a verdict, a speech timer and an argument flowchart.</p><p>Its limits are worth stating plainly. Sparring currently runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, so WSDC and BP practice uses the prep and coaching tools rather than a full simulated round. Like every AI tool, its evidence leads need checking against the original source. Run the one-hour test above and decide on your own results.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>What is the best AI tool for debate?</summary><p>It depends on the job. General chatbots are flexible for brainstorming, research tools find sources, and dedicated debate platforms add structure, opponents and practice. Most debaters do best with a dedicated platform plus a way to verify sources.</p></details><details><summary>Is a general chatbot good enough for debate prep?</summary><p>For brainstorming and explaining concepts, often yes. It is weaker at keeping a motion, side and format in context, predicting the opposing case, timing speeches and giving round-style feedback.</p></details><details><summary>Are free AI debate tools enough?</summary><p>Free tiers are a good way to run the comparison test. Check the daily or monthly limits against how many practice sessions you plan before a tournament.</p></details><details><summary>Can I use AI tools during a debate round?</summary><p>Usually not. Most leagues restrict or ban internet access and electronic help during rounds. Check your league&#x27;s rules, and use AI tools for preparation.</p></details><details><summary>What are the alternatives to DebateOwl?</summary><p>General chatbots, AI research assistants, other dedicated debate platforms, and simple practice utilities such as timers and flowing templates. Run the one-hour test above on DebateOwl and on each alternative you are considering.</p></details><details><summary>How should I compare AI debate tools fairly?</summary><p>Give every tool the same motion and the same tasks, such as a case, the strongest counter, feedback on your speech and evidence for one claim, then score each answer against the same criteria.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/debate-evidence-finder/index.html b/public/debate-evidence-finder/index.html
index 7afad12fb..b7e8ed1fb 100644
--- a/public/debate-evidence-finder/index.html
+++ b/public/debate-evidence-finder/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Debate Evidence Finder | DebateOwl</title>
-  <meta name="description" content="DebateOwl finds cited evidence leads for your debate case so you can open the original source and check the warrant before you read it in a round." />
+  <meta name="description" content="DebateOwl finds cited evidence leads for your debate case so you can open the original source and check it backs your point before a round." />
   <meta name="robots" content="index, follow, max-snippet:-1, max-image-preview:large" />
   <link rel="canonical" href="https://debateowl.com/debate-evidence-finder" />
   <meta name="author" content="DebateOwl" />
@@ -16,21 +16,21 @@
   <meta property="og:type" content="article" />
   <meta property="og:site_name" content="DebateOwl" />
   <meta property="og:title" content="Debate Evidence Finder | DebateOwl" />
-  <meta property="og:description" content="DebateOwl finds cited evidence leads for your debate case so you can open the original source and check the warrant before you read it in a round." />
+  <meta property="og:description" content="DebateOwl finds cited evidence leads for your debate case so you can open the original source and check it backs your point before a round." />
   <meta property="og:url" content="https://debateowl.com/debate-evidence-finder" />
   <meta property="og:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta property="og:image:width" content="1200" />
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="Debate Evidence Finder | DebateOwl" />
-  <meta name="twitter:description" content="DebateOwl finds cited evidence leads for your debate case so you can open the original source and check the warrant before you read it in a round." />
+  <meta name="twitter:description" content="DebateOwl finds cited evidence leads for your debate case so you can open the original source and check it backs your point before a round." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Find Better Debate Evidence Without Losing the Argument","name":"Debate Evidence Finder | DebateOwl","url":"https://debateowl.com/debate-evidence-finder","description":"DebateOwl finds cited evidence leads for your debate case so you can open the original source and check the warrant before you read it in a round.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can AI find reliable evidence for a debate case?","acceptedAnswer":{"@type":"Answer","text":"AI can find leads, not reliable evidence on its own. It is good at suggesting where to look and which searches to run, but a summary can lose a qualification, mix up two studies or point to a page that says something different. Open every original, check the author, date, publication, method and the text around the quote, and record the full citation. If the evidence is weak, do not read it. Narrow your claim or make the argument analytically, because a clear warrant often beats a card that falls apart under one question."}},{"@type":"Question","name":"Can AI find evidence for debate?","acceptedAnswer":{"@type":"Answer","text":"It can find leads: sources and searches that may support a claim. You still need to open each source, read it in context and record the citation before using it."}},{"@type":"Question","name":"How do I verify debate evidence?","acceptedAnswer":{"@type":"Answer","text":"Check the author, date, publication and method, read the text around the quote, and confirm that it says what you claim. Record the full citation."}},{"@type":"Question","name":"What should I do if my evidence is weak?","acceptedAnswer":{"@type":"Answer","text":"Do not read it. Find a better source, narrow your claim, or make the argument analytically without the card."}},{"@type":"Question","name":"Where does DebateOwl keep my sources?","acceptedAnswer":{"@type":"Answer","text":"In the Library for your Current Debate. Sources you mark active are used by the other tools for that debate."}},{"@type":"Question","name":"Is a card better than an analytical argument?","acceptedAnswer":{"@type":"Answer","text":"Only if it is accurate and relevant. A strong warrant without a card often beats a weak card that does not survive a question."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Find Better Debate Evidence Without Losing the Argument","item":"https://debateowl.com/debate-evidence-finder"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Find Better Debate Evidence Without Losing the Argument","name":"Debate Evidence Finder | DebateOwl","url":"https://debateowl.com/debate-evidence-finder","description":"DebateOwl finds cited evidence leads for your debate case so you can open the original source and check it backs your point before a round.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Can AI find reliable evidence for a debate case?","acceptedAnswer":{"@type":"Answer","text":"AI can find leads, not reliable evidence on its own. It is good at suggesting where to look and which searches to run, but a summary can lose a qualification, mix up two studies or point to a page that says something different. Open every original, check the author, date, publication, method and the text around the quote, and record the full citation. If the evidence is weak, do not read it. Narrow your claim or make the argument analytically, because a clear warrant often beats a card that falls apart under one question."}},{"@type":"Question","name":"Can AI find evidence for debate?","acceptedAnswer":{"@type":"Answer","text":"It can find leads: sources and searches that may support a claim. You still need to open each source, read it in context and record the citation before using it."}},{"@type":"Question","name":"How do I verify debate evidence?","acceptedAnswer":{"@type":"Answer","text":"Check the author, date, publication and method, read the text around the quote, and confirm that it says what you claim. Record the full citation."}},{"@type":"Question","name":"What should I do if my evidence is weak?","acceptedAnswer":{"@type":"Answer","text":"Do not read it. Find a better source, narrow your claim, or make the argument analytically without the card."}},{"@type":"Question","name":"Where does DebateOwl keep my sources?","acceptedAnswer":{"@type":"Answer","text":"In the Library for your Current Debate. Sources you mark active are used by the other tools for that debate."}},{"@type":"Question","name":"Is a card better than an analytical argument?","acceptedAnswer":{"@type":"Answer","text":"Only if it is accurate and relevant. A strong warrant without a card often beats a weak card that does not survive a question."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Find Better Debate Evidence Without Losing the Argument","item":"https://debateowl.com/debate-evidence-finder"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">Find Better Debate Evidence Without Losing the Argument</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Research workflow</span><h1>Find Better Debate Evidence Without Losing the Argument</h1><p class="lead">Use AI to locate research directions, then verify sources and connect evidence to warrants.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">Research workflow</span><h1>Find Better Debate Evidence Without Losing the Argument</h1><p class="lead">Use AI to locate research directions, then verify sources and connect evidence to warrants.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Can AI find reliable evidence for a debate case?</h2><p>AI can find leads, not reliable evidence on its own. It is good at suggesting where to look and which searches to run, but a summary can lose a qualification, mix up two studies or point to a page that says something different. Open every original, check the author, date, publication, method and the text around the quote, and record the full citation. If the evidence is weak, do not read it. Narrow your claim or make the argument analytically, because a clear warrant often beats a card that falls apart under one question.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Evidence leads</h3><p class="muted">Research directions for a claim: the kinds of sources that could support it and searches you can run to confirm it.</p></article><article class="card"><h3>Citation checks</h3><p class="muted">A checklist for each source before it goes on a card: author, date, method and whether the quote says what you claim.</p></article><article class="card"><h3>Impact links</h3><p class="muted">Evidence tied to the warrant and the clash it supports, not added to a speech as decoration.</p></article></section>
-      <div class="article section"><h2>Evidence is not the argument</h2><p>Evidence wins rounds only when it supports a clear warrant. A source should answer a burden in the round, not decorate a speech. Before you look for a card, write the claim it needs to prove in one sentence. If you cannot, more research will not help.</p><p>The most useful evidence sits on a specific clash: solvency, harms, trade-offs, comparative examples and the <a href="/how-to-weigh-in-debate">weighing</a>.</p><h2>AI research is a starting point</h2><p>AI tools are good at suggesting where to look: which kinds of reports, journals or data sources might support a link. They are not a replacement for reading the source. A summary can lose a qualification, mix up two studies, or point to a page that says something different.</p><p>Treat every AI result as a lead. Open the original, read enough of it to understand the context, and only then decide whether it belongs in your case.</p><h2>Finding evidence with DebateOwl</h2><ol><li>Give Factoids a single statement from your case. It researches that statement and returns supporting factoids with citations, context and suggestions for how to use them.</li><li><a href="/ai-debate-case-generator">Generate a case</a>. DebateOwl researches the motion before it writes, so the draft comes with sources for its claims.</li><li>Save the sources you trust to the Library. Active Library sources that fit a request are used by the other prep tools for that debate, so later answers draw on material you have checked.</li><li>Ask for counter-evidence too. Attack runs research on an argument and can point to sources that cut against it, which tells you what the other side may read.</li></ol><h2>Verify before you read it aloud</h2><p>A bad card is worse than no card. If your evidence is challenged in <a href="/how-to-cross-examine-in-debate">cross-ex</a> and does not say what you claimed, you lose the point and some of the judge&#x27;s trust in the rest of your case. Check each source before it goes on a card:</p><ul><li>Author: who wrote it, and are they qualified to make this claim?</li><li>Date: is it recent enough for the claim, and has anything changed since?</li><li>Publication: a peer-reviewed journal, a government report, a newspaper or a blog all carry different weight.</li><li>Method: for a study, what was the sample, how was it measured, and does it show cause or only correlation?</li><li>Context: read the paragraphs around the quote. Make sure the author is not describing a view they go on to reject.</li><li>Citation: record the full citation, so you can produce the source if the other side or the judge asks.</li></ul><h2>What to do when the evidence is weak</h2><p>Do not read it. Look for a better source, narrow the claim so the evidence you have does prove it, or make the argument analytically: explain the reasoning without leaning on a card. A clear warrant with no card often beats a weak card that falls apart under one question.</p><h2>Worked example</h2><div class="card"><h3>Motion: This house would introduce a four-day school week</h3><p><strong>Claim:</strong> A four-day week improves teacher retention.</p><p><strong>Lead found:</strong> A summary says districts that moved to four days saw fewer teachers leave.</p><p><strong>Check:</strong> The original study covers a small number of rural districts, and the authors say they cannot separate the schedule from pay changes made at the same time.</p><p><strong>Decision:</strong> Narrow the claim to rural districts, say the evidence suggests but does not prove the effect, and support it with an analytical warrant about recruitment.</p></div><p>The weaker claim is easier to defend, and the honesty about the study removes the easiest cross-ex question the other side could ask.</p></div>
+      <div class="article section"><h2>Evidence is not the argument</h2><p>Evidence wins rounds only when it supports a clear warrant. A source should answer a burden in the round, not decorate a speech. Before you look for a card, write the claim it needs to prove in one sentence. If you cannot, more research will not help.</p><p>The most useful evidence sits on a specific clash: solvency, harms, trade-offs, comparative examples and the <a href="/how-to-weigh-in-debate">weighing</a>.</p><h2>AI research is a starting point</h2><p>AI tools are good at suggesting where to look: which kinds of reports, journals or data sources might support a link. They are not a replacement for reading the source. A summary can lose a qualification, mix up two studies, or point to a page that says something different.</p><p>Treat every AI result as a lead. Open the original, read enough of it to understand the context, and only then decide whether it belongs in your case.</p><h2>Finding evidence with DebateOwl</h2><ol><li>Give Factoids a single statement from your case. It researches that statement and returns supporting factoids with citations, context and suggestions for how to use them.</li><li><a href="/ai-debate-case-generator">Generate a case</a>. DebateOwl researches the motion before it writes, so each piece of evidence names its source and year, and the case ends with a source list: the organisation, the year, the claim it supports and the link.</li><li>Save the sources you trust to the Library. Active Library sources that fit a request are used by the other prep tools for that debate, so later answers draw on material you have checked.</li><li>Ask for counter-evidence too. Attack runs research on an argument and can point to sources that cut against it, which tells you what the other side may read.</li></ol><h2>Verify before you read it aloud</h2><p>A bad card is worse than no card. If your evidence is challenged in <a href="/how-to-cross-examine-in-debate">cross-ex</a> and does not say what you claimed, you lose the point and some of the judge&#x27;s trust in the rest of your case. Check each source before it goes on a card:</p><ul><li>Author: who wrote it, and are they qualified to make this claim?</li><li>Date: is it recent enough for the claim, and has anything changed since?</li><li>Publication: a peer-reviewed journal, a government report, a newspaper or a blog all carry different weight.</li><li>Method: for a study, what was the sample, how was it measured, and does it show cause or only correlation?</li><li>Context: read the paragraphs around the quote. Make sure the author is not describing a view they go on to reject.</li><li>Citation: record the full citation, so you can produce the source if the other side or the judge asks.</li></ul><h2>What to do when the evidence is weak</h2><p>Do not read it. Look for a better source, narrow the claim so the evidence you have does prove it, or make the argument analytically: explain the reasoning without leaning on a card. A clear warrant with no card often beats a weak card that falls apart under one question.</p><h2>Worked example</h2><div class="card"><h3>Motion: This house would introduce a four-day school week</h3><p><strong>Claim:</strong> A four-day week improves teacher retention.</p><p><strong>Lead found:</strong> A summary says districts that moved to four days saw fewer teachers leave.</p><p><strong>Check:</strong> The original study covers a small number of rural districts, and the authors say they cannot separate the schedule from pay changes made at the same time.</p><p><strong>Decision:</strong> Narrow the claim to rural districts, say the evidence suggests but does not prove the effect, and support it with an analytical warrant about recruitment.</p></div><p>The weaker claim is easier to defend, and the honesty about the study removes the easiest cross-ex question the other side could ask.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>Can AI find evidence for debate?</summary><p>It can find leads: sources and searches that may support a claim. You still need to open each source, read it in context and record the citation before using it.</p></details><details><summary>How do I verify debate evidence?</summary><p>Check the author, date, publication and method, read the text around the quote, and confirm that it says what you claim. Record the full citation.</p></details><details><summary>What should I do if my evidence is weak?</summary><p>Do not read it. Find a better source, narrow your claim, or make the argument analytically without the card.</p></details><details><summary>Where does DebateOwl keep my sources?</summary><p>In the Library for your Current Debate. Sources you mark active are used by the other tools for that debate.</p></details><details><summary>Is a card better than an analytical argument?</summary><p>Only if it is accurate and relevant. A strong warrant without a card often beats a weak card that does not survive a question.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/debate-rebuttal-practice/index.html b/public/debate-rebuttal-practice/index.html
index 599968b2e..39c9b6790 100644
--- a/public/debate-rebuttal-practice/index.html
+++ b/public/debate-rebuttal-practice/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Debate Rebuttal Practice | DebateOwl</title>
-  <meta name="description" content="Paste an opposing argument into DebateOwl to find its weak warrants, missing weighing and logic gaps, then practice the rebuttal you would give." />
+  <meta name="description" content="Paste an opposing argument into DebateOwl to find its weak links, missing evidence and logic gaps, then practice the rebuttal you would give." />
   <meta name="robots" content="index, follow, max-snippet:-1, max-image-preview:large" />
   <link rel="canonical" href="https://debateowl.com/debate-rebuttal-practice" />
   <meta name="author" content="DebateOwl" />
@@ -16,21 +16,21 @@
   <meta property="og:type" content="article" />
   <meta property="og:site_name" content="DebateOwl" />
   <meta property="og:title" content="Debate Rebuttal Practice | DebateOwl" />
-  <meta property="og:description" content="Paste an opposing argument into DebateOwl to find its weak warrants, missing weighing and logic gaps, then practice the rebuttal you would give." />
+  <meta property="og:description" content="Paste an opposing argument into DebateOwl to find its weak links, missing evidence and logic gaps, then practice the rebuttal you would give." />
   <meta property="og:url" content="https://debateowl.com/debate-rebuttal-practice" />
   <meta property="og:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta property="og:image:width" content="1200" />
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="Debate Rebuttal Practice | DebateOwl" />
-  <meta name="twitter:description" content="Paste an opposing argument into DebateOwl to find its weak warrants, missing weighing and logic gaps, then practice the rebuttal you would give." />
+  <meta name="twitter:description" content="Paste an opposing argument into DebateOwl to find its weak links, missing evidence and logic gaps, then practice the rebuttal you would give." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Practice Rebuttals Before Your Opponent Finds the Weakness","name":"Debate Rebuttal Practice | DebateOwl","url":"https://debateowl.com/debate-rebuttal-practice","description":"Paste an opposing argument into DebateOwl to find its weak warrants, missing weighing and logic gaps, then practice the rebuttal you would give.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"How do you find the weak link in an argument you need to rebut?","acceptedAnswer":{"@type":"Answer","text":"Start with the warrant, because a claim without a warrant gives the judge nothing to weigh, so the reason behind a claim is usually the link to attack. Then choose your move: deny the claim, attack the warrant, mitigate the impact, turn it or outweigh it. Write each answer as a short block with a tag line, the response and why it matters, and deliver it in under forty-five seconds. An AI analysis can point out missing warrants and overclaimed impacts, but in round you still adapt each block to what the opponent actually said."}},{"@type":"Question","name":"How can I practise rebuttals on my own?","acceptedAnswer":{"@type":"Answer","text":"Take the arguments you expect to face, find each one's weakest link with Attack, write a short block, and deliver it against a timer. Then ask the AI for the best reply to your block and prepare an answer."}},{"@type":"Question","name":"How long should a rebuttal response be?","acceptedAnswer":{"@type":"Answer","text":"Most single responses should take under a minute. Total rebuttal time depends on the format, from four minutes in Public Forum to most of an eight-minute WSDC speech."}},{"@type":"Question","name":"What is the difference between a rebuttal and a block?","acceptedAnswer":{"@type":"Answer","text":"A block is a rebuttal prepared before the round for an argument you expect. In the round you adapt the block to what the opponent actually said."}},{"@type":"Question","name":"Can the AI predict my opponent's arguments?","acceptedAnswer":{"@type":"Answer","text":"Yes. Each generated case includes a predicted opponent case, which is a practical list of arguments to prepare blocks against."}},{"@type":"Question","name":"How do I stop dropping arguments?","acceptedAnswer":{"@type":"Answer","text":"Flow every speech, mark each opposing argument as answered or not, and group similar arguments so one response covers several. Practise against a timer until it becomes routine."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Practice Rebuttals Before Your Opponent Finds the Weakness","item":"https://debateowl.com/debate-rebuttal-practice"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Practice Rebuttals Before Your Opponent Finds the Weakness","name":"Debate Rebuttal Practice | DebateOwl","url":"https://debateowl.com/debate-rebuttal-practice","description":"Paste an opposing argument into DebateOwl to find its weak links, missing evidence and logic gaps, then practice the rebuttal you would give.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"How do you find the weak link in an argument you need to rebut?","acceptedAnswer":{"@type":"Answer","text":"Start with the warrant, because a claim without a warrant gives the judge nothing to weigh, so the reason behind a claim is usually the link to attack. Then choose your move: deny the claim, attack the warrant, mitigate the impact, turn it or outweigh it. Write each answer as a short block with a tag line, the response and why it matters, and deliver it in under forty-five seconds. An AI analysis can point out missing warrants and overclaimed impacts, but in round you still adapt each block to what the opponent actually said."}},{"@type":"Question","name":"How can I practise rebuttals on my own?","acceptedAnswer":{"@type":"Answer","text":"Take the arguments you expect to face, find each one's weakest link with Attack, write a short block, and deliver it against a timer. Then ask the AI for the best reply to your block and prepare an answer."}},{"@type":"Question","name":"How long should a rebuttal response be?","acceptedAnswer":{"@type":"Answer","text":"Most single responses should take under a minute. Total rebuttal time depends on the format, from four minutes in Public Forum to most of an eight-minute WSDC speech."}},{"@type":"Question","name":"What is the difference between a rebuttal and a block?","acceptedAnswer":{"@type":"Answer","text":"A block is a rebuttal prepared before the round for an argument you expect. In the round you adapt the block to what the opponent actually said."}},{"@type":"Question","name":"Can the AI predict my opponent's arguments?","acceptedAnswer":{"@type":"Answer","text":"Yes. Each generated case includes \"If they say…\" answers: the claims the other side is likely to make, each with a reply, which is a practical list of arguments to prepare blocks against."}},{"@type":"Question","name":"How do I stop dropping arguments?","acceptedAnswer":{"@type":"Answer","text":"Flow every speech, mark each opposing argument as answered or not, and group similar arguments so one response covers several. Practise against a timer until it becomes routine."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Practice Rebuttals Before Your Opponent Finds the Weakness","item":"https://debateowl.com/debate-rebuttal-practice"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,12 +39,12 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">Practice Rebuttals Before Your Opponent Finds the Weakness</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Feature guide</span><h1>Practice Rebuttals Before Your Opponent Finds the Weakness</h1><p class="lead">Choose the link to attack, explain why it matters, and turn pressure into round-winning collapse.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">Feature guide</span><h1>Practice Rebuttals Before Your Opponent Finds the Weakness</h1><p class="lead">Choose the link to attack, explain why it matters, and turn pressure into round-winning collapse.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">How do you find the weak link in an argument you need to rebut?</h2><p>Start with the warrant, because a claim without a warrant gives the judge nothing to weigh, so the reason behind a claim is usually the link to attack. Then choose your move: deny the claim, attack the warrant, mitigate the impact, turn it or outweigh it. Write each answer as a short block with a tag line, the response and why it matters, and deliver it in under forty-five seconds. An AI analysis can point out missing warrants and overclaimed impacts, but in round you still adapt each block to what the opponent actually said.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Find weak warrants</h3><p class="muted">Paste an argument into Attack and get the links that fail: missing warrants, overclaimed impacts and assumptions the other side never proved.</p></article><article class="card"><h3>Build targeted blocks</h3><p class="muted">Each weakness comes with why it is weak, how the other side will attack it and a stronger version. Turn that into a short block; the analysis stays in your Current Debate.</p></article><article class="card"><h3>Practice weighing and collapse</h3><p class="muted">Deliver rebuttals in a Sparring round and see in the verdict whether your weighing changed the outcome.</p></article></section>
-      <div class="article section"><h2>The five ways to answer an argument</h2><p>Every rebuttal is one of a small number of moves. Naming the move before you speak keeps the response short and makes it obvious to the judge what you have done:</p><ul><li>Deny the claim: show the thing they say happens does not happen.</li><li>Attack the warrant: accept the claim could be true, but show their reason for it does not prove it.</li><li>Mitigate the impact: concede the mechanism but show the effect is smaller, rarer or slower than they said.</li><li>Turn it: show their argument actually supports your side.</li><li>Outweigh it: concede the point and show your impact matters more.</li></ul><p>Attacking the warrant is usually the strongest choice, because a claim without a warrant gives the judge nothing to weigh. Turns are the most powerful when they work and the most dangerous when they do not, so practise them before using them in a round.</p><h2>A 20-minute rebuttal drill</h2><ol><li>Choose one opposing argument you expect to face. If you have generated a case, take it from the predicted opponent case.</li><li>Paste it into Attack and read the weaknesses it finds. Pick the one that breaks the argument, not the one that is easiest to say.</li><li>Write a block: a five-word tag line, the response in two or three sentences, and one sentence on why it matters for the round.</li><li>Time yourself delivering the block in under forty-five seconds.</li><li>Ask the coach for the best answer to your block, and add a one-sentence reply to the bottom.</li><li>Repeat with the next most likely argument. Three tested blocks per session is a good pace.</li></ol><p>Your Attack analyses stay in the same Current Debate, so your rebuttals sit next to the case they answer.</p><h2>Worked example: rebutting one argument</h2><div class="card"><h3>Motion: This house would ban zoos</h3><p><strong>Opposition argument:</strong> Zoos protect endangered species through captive breeding programmes, so a ban would push some species closer to extinction.</p><p><strong>Weak link:</strong> The argument assumes that captive breeding requires zoos as they exist now, with public display, rather than conservation centres run for that purpose.</p><p><strong>Response (attack the warrant):</strong> Breeding programmes need specialist facilities and genetic management, not visitors. A ban on zoos as public attractions does not stop sanctuaries and conservation centres from running them.</p><p><strong>Response (mitigate):</strong> Most animals kept in zoos are not part of reintroduction programmes, so even if some breeding is lost, the protection the opposition claims is far smaller than their argument suggests.</p><p><strong>Weighing:</strong> Even at full strength, their benefit applies to a small number of species. Our harm, keeping animals in conditions that do not meet their needs for public entertainment, applies to every animal in every zoo.</p><p><strong>Forty-five second version:</strong> Their benefit is breeding, but breeding does not need an audience. Ban the attraction, keep the conservation centres, and their argument disappears.</p></div><p>The response does not argue about whether conservation matters. It targets the one assumption the argument needs, which is faster and harder to answer.</p><h2>Rebuttal tips by format</h2><h3>World Schools (WSDC)</h3><p>Rebuttal grows through the bench: the first opposition speaker begins it, the second speaker does the bulk of it, and the third speaker organises the debate into its main clashes and should not add new arguments. Practise third-speaker rebuttal by taking a full set of opposing points and grouping them under two or three questions, then answering each question once.</p><h3>British Parliamentary (BP)</h3><p><a href="/british-parliamentary-debate">Closing teams</a> must rebut and extend at the same time, so practise blocks that answer the opening bench across from you and then lead straight into your extension. Whips should rebut by clash, not speaker by speaker, and avoid new material.</p><h3>Public Forum (PF)</h3><p>In a four-minute rebuttal, the second-speaking team should answer the attacks made on its own case as well as attacking the opponent&#x27;s, or those arguments will be hard to bring back in summary. Practise splitting the four minutes, and remember that what is not in summary should not appear in <a href="/public-forum-debate">final focus</a>.</p><h3>Lincoln-Douglas (LD)</h3><p>The 1AR has four minutes to answer seven minutes of negative material. Practise grouping similar responses, cross-applying your framework to several arguments at once, and saying the important responses first so the 2AR has something to extend. For the negative rebuttal, drill collapsing onto the one or two arguments that best outweigh.</p><h2>Use cross-examination to set up your rebuttal</h2><p>The best rebuttals often start in <a href="/how-to-cross-examine-in-debate">cross-examination</a>. If an argument rests on an assumption, ask a question that gets the speaker to commit to it, then attack the assumption in your speech. Crossfire lets you practise this against the AI, asking questions or answering them, and each Crossfire ends with a debrief you can turn into new blocks.</p><h2>Common rebuttal mistakes</h2><ul><li>Answering every sentence instead of the argument the round depends on.</li><li>Restating your own case rather than engaging with theirs.</li><li>Giving a response without saying why it matters for the decision.</li><li>Leaving the weighing to the final speech, when the judge has already started deciding.</li><li>Losing track of what has been dropped. Keep a flow, or map the clash in the argument flowchart, so nothing important goes unanswered.</li></ul></div>
-      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>How can I practise rebuttals on my own?</summary><p>Take the arguments you expect to face, find each one&#x27;s weakest link with Attack, write a short block, and deliver it against a timer. Then ask the AI for the best reply to your block and prepare an answer.</p></details><details><summary>How long should a rebuttal response be?</summary><p>Most single responses should take under a minute. Total rebuttal time depends on the format, from four minutes in Public Forum to most of an eight-minute WSDC speech.</p></details><details><summary>What is the difference between a rebuttal and a block?</summary><p>A block is a rebuttal prepared before the round for an argument you expect. In the round you adapt the block to what the opponent actually said.</p></details><details><summary>Can the AI predict my opponent&#x27;s arguments?</summary><p>Yes. Each generated case includes a predicted opponent case, which is a practical list of arguments to prepare blocks against.</p></details><details><summary>How do I stop dropping arguments?</summary><p>Flow every speech, mark each opposing argument as answered or not, and group similar arguments so one response covers several. Practise against a timer until it becomes routine.</p></details></section>
+      <div class="article section"><h2>The five ways to answer an argument</h2><p>Every rebuttal is one of a small number of moves. Naming the move before you speak keeps the response short and makes it obvious to the judge what you have done:</p><ul><li>Deny the claim: show the thing they say happens does not happen.</li><li>Attack the warrant: accept the claim could be true, but show their reason for it does not prove it.</li><li>Mitigate the impact: concede the mechanism but show the effect is smaller, rarer or slower than they said.</li><li>Turn it: show their argument actually supports your side.</li><li>Outweigh it: concede the point and show your impact matters more.</li></ul><p>Attacking the warrant is usually the strongest choice, because a claim without a warrant gives the judge nothing to weigh. Turns are the most powerful when they work and the most dangerous when they do not, so practise them before using them in a round.</p><h2>A 20-minute rebuttal drill</h2><ol><li>Choose one opposing argument you expect to face. If you have generated a case, take it from its &quot;If they say…&quot; answers.</li><li>Paste it into Attack and read the weaknesses it finds. Pick the one that breaks the argument, not the one that is easiest to say.</li><li>Write a block: a five-word tag line, the response in two or three sentences, and one sentence on why it matters for the round.</li><li>Time yourself delivering the block in under forty-five seconds.</li><li>Ask the coach for the best answer to your block, and add a one-sentence reply to the bottom.</li><li>Repeat with the next most likely argument. Three tested blocks per session is a good pace.</li></ol><p>Your Attack analyses stay in the same Current Debate, so your rebuttals sit next to the case they answer.</p><h2>Worked example: rebutting one argument</h2><div class="card"><h3>Motion: This house would ban zoos</h3><p><strong>Opposition argument:</strong> Zoos protect endangered species through captive breeding programmes, so a ban would push some species closer to extinction.</p><p><strong>Weak link:</strong> The argument assumes that captive breeding requires zoos as they exist now, with public display, rather than conservation centres run for that purpose.</p><p><strong>Response (attack the warrant):</strong> Breeding programmes need specialist facilities and genetic management, not visitors. A ban on zoos as public attractions does not stop sanctuaries and conservation centres from running them.</p><p><strong>Response (mitigate):</strong> Most animals kept in zoos are not part of reintroduction programmes, so even if some breeding is lost, the protection the opposition claims is far smaller than their argument suggests.</p><p><strong>Weighing:</strong> Even at full strength, their benefit applies to a small number of species. Our harm, keeping animals in conditions that do not meet their needs for public entertainment, applies to every animal in every zoo.</p><p><strong>Forty-five second version:</strong> Their benefit is breeding, but breeding does not need an audience. Ban the attraction, keep the conservation centres, and their argument disappears.</p></div><p>The response does not argue about whether conservation matters. It targets the one assumption the argument needs, which is faster and harder to answer.</p><h2>Rebuttal tips by format</h2><h3>World Schools (WSDC)</h3><p>Rebuttal grows through the bench: the first opposition speaker begins it, the second speaker does the bulk of it, and the third speaker organises the debate into its main clashes and should not add new arguments. Practise third-speaker rebuttal by taking a full set of opposing points and grouping them under two or three questions, then answering each question once.</p><h3>British Parliamentary (BP)</h3><p><a href="/british-parliamentary-debate">Closing teams</a> must rebut and extend at the same time, so practise blocks that answer the opening bench across from you and then lead straight into your extension. Whips should rebut by clash, not speaker by speaker, and avoid new material.</p><h3>Public Forum (PF)</h3><p>In a four-minute rebuttal, the second-speaking team should answer the attacks made on its own case as well as attacking the opponent&#x27;s, or those arguments will be hard to bring back in summary. Practise splitting the four minutes, and remember that what is not in summary should not appear in <a href="/public-forum-debate">final focus</a>.</p><h3>Lincoln-Douglas (LD)</h3><p>The 1AR has four minutes to answer seven minutes of negative material. Practise grouping similar responses, cross-applying your framework to several arguments at once, and saying the important responses first so the 2AR has something to extend. For the negative rebuttal, drill collapsing onto the one or two arguments that best outweigh.</p><h2>Use cross-examination to set up your rebuttal</h2><p>The best rebuttals often start in <a href="/how-to-cross-examine-in-debate">cross-examination</a>. If an argument rests on an assumption, ask a question that gets the speaker to commit to it, then attack the assumption in your speech. Crossfire lets you practise this against the AI, asking questions or answering them, and each Crossfire ends with a debrief you can turn into new blocks.</p><h2>Common rebuttal mistakes</h2><ul><li>Answering every sentence instead of the argument the round depends on.</li><li>Restating your own case rather than engaging with theirs.</li><li>Giving a response without saying why it matters for the decision.</li><li>Leaving the weighing to the final speech, when the judge has already started deciding.</li><li>Losing track of what has been dropped. Keep a flow, or map the clash in the argument flowchart, so nothing important goes unanswered.</li></ul></div>
+      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>How can I practise rebuttals on my own?</summary><p>Take the arguments you expect to face, find each one&#x27;s weakest link with Attack, write a short block, and deliver it against a timer. Then ask the AI for the best reply to your block and prepare an answer.</p></details><details><summary>How long should a rebuttal response be?</summary><p>Most single responses should take under a minute. Total rebuttal time depends on the format, from four minutes in Public Forum to most of an eight-minute WSDC speech.</p></details><details><summary>What is the difference between a rebuttal and a block?</summary><p>A block is a rebuttal prepared before the round for an argument you expect. In the round you adapt the block to what the opponent actually said.</p></details><details><summary>Can the AI predict my opponent&#x27;s arguments?</summary><p>Yes. Each generated case includes &quot;If they say…&quot; answers: the claims the other side is likely to make, each with a reply, which is a practical list of arguments to prepare blocks against.</p></details><details><summary>How do I stop dropping arguments?</summary><p>Flow every speech, mark each opposing argument as answered or not, and group similar arguments so one response covers several. Practise against a timer until it becomes routine.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
     <section class="section article" aria-labelledby="related"><h2 id="related">Related DebateOwl guides</h2><nav class="links" aria-label="Related guides"><a href="/debate-evidence-finder">Find Better Debate Evidence Without Losing the Argument</a>
diff --git a/public/debate-topics-for-students/index.html b/public/debate-topics-for-students/index.html
index 627eafa48..a740fbe35 100644
--- a/public/debate-topics-for-students/index.html
+++ b/public/debate-topics-for-students/index.html
@@ -23,14 +23,14 @@
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="Debate Topics for Students | DebateOwl" />
   <meta name="twitter:description" content="Debate topics for students sorted by format, difficulty and subject, with a way to brainstorm both sides of a case and start preparing with AI." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Debate Topics for Students","name":"Debate Topics for Students | DebateOwl","url":"https://debateowl.com/debate-topics-for-students","description":"Debate topics for students sorted by format, difficulty and subject, with a way to brainstorm both sides of a case and start preparing with AI.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What are good debate topics for students?","acceptedAnswer":{"@type":"Answer","text":"It depends on level. Beginners do best with topics from daily life, such as banning homework in primary schools, optional school uniforms or a four-day school week, so they can focus on structure instead of research. Intermediate debaters can take on lowering the voting age to 16 or taxing sugary drinks. Advanced teams can handle universal basic income or autonomous weapons. At any level, a good practice topic is balanced, has real clash and stakes, and is accessible without specialist knowledge. Competitive leagues set their own topics."}},{"@type":"Question","name":"What are good debate topics for beginners?","acceptedAnswer":{"@type":"Answer","text":"Topics students already know from daily life, such as homework, school uniforms, smartphones in school or a four-day school week. They let new debaters focus on structure instead of research."}},{"@type":"Question","name":"How do I know if a debate topic is balanced?","acceptedAnswer":{"@type":"Answer","text":"Try writing a short case for each side. If one side struggles to find two serious arguments, the topic is unbalanced and will make a poor practice round."}},{"@type":"Question","name":"What is the difference between a motion and a resolution?","acceptedAnswer":{"@type":"Answer","text":"They mean the same thing in different formats. BP and World Schools use motions such as This house would; Public Forum and Lincoln-Douglas use resolutions beginning Resolved."}},{"@type":"Question","name":"Where do competition debate topics come from?","acceptedAnswer":{"@type":"Answer","text":"Each league or tournament sets its own. Some publish topics in advance for prepared formats; others release motions shortly before each round. Practise with your league's past topics when they are available."}},{"@type":"Question","name":"Can AI help me prepare for a debate topic?","acceptedAnswer":{"@type":"Answer","text":"Yes, for brainstorming angles, drafting a first case structure and predicting the other side. Check any facts against original sources and write the final case in your own words."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Debate Topics for Students","item":"https://debateowl.com/debate-topics-for-students"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"Debate Topics for Students","name":"Debate Topics for Students | DebateOwl","url":"https://debateowl.com/debate-topics-for-students","description":"Debate topics for students sorted by format, difficulty and subject, with a way to brainstorm both sides of a case and start preparing with AI.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What are good debate topics for students?","acceptedAnswer":{"@type":"Answer","text":"It depends on level. Beginners do best with topics from daily life, such as banning homework in primary schools, optional school uniforms or a four-day school week, so they can focus on structure instead of research. Intermediate debaters can take on lowering the voting age to 16 or taxing sugary drinks. Advanced teams can handle universal basic income or autonomous weapons. At any level, a good practice topic is balanced, has real clash and stakes, and is accessible without specialist knowledge. Competitive leagues set their own topics."}},{"@type":"Question","name":"What are good debate topics for beginners?","acceptedAnswer":{"@type":"Answer","text":"Topics students already know from daily life, such as homework, school uniforms, smartphones in school or a four-day school week. They let new debaters focus on structure instead of research."}},{"@type":"Question","name":"How do I know if a debate topic is balanced?","acceptedAnswer":{"@type":"Answer","text":"Try writing a short case for each side. If one side struggles to find two serious arguments, the topic is unbalanced and will make a poor practice round."}},{"@type":"Question","name":"What is the difference between a motion and a resolution?","acceptedAnswer":{"@type":"Answer","text":"They mean the same thing in different formats. BP and World Schools use motions such as This house would; Public Forum and Lincoln-Douglas use resolutions beginning Resolved."}},{"@type":"Question","name":"Where do competition debate topics come from?","acceptedAnswer":{"@type":"Answer","text":"Each league or tournament sets its own. Some publish topics in advance for prepared formats; others release motions shortly before each round. Practise with your league's past topics when they are available."}},{"@type":"Question","name":"Can AI help me prepare for a debate topic?","acceptedAnswer":{"@type":"Answer","text":"Yes, for brainstorming angles, drafting a first case structure and predicting the other side. Check any facts against original sources and write the final case in your own words."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"Debate Topics for Students","item":"https://debateowl.com/debate-topics-for-students"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">Debate Topics for Students</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Resource</span><h1>Debate Topics for Students</h1><p class="lead">Find topics, brainstorm cases, and start preparing with AI-guided prompts.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">Resource</span><h1>Debate Topics for Students</h1><p class="lead">Find topics, brainstorm cases, and start preparing with AI-guided prompts.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">What are good debate topics for students?</h2><p>It depends on level. Beginners do best with topics from daily life, such as banning homework in primary schools, optional school uniforms or a four-day school week, so they can focus on structure instead of research. Intermediate debaters can take on lowering the voting age to 16 or taxing sugary drinks. Advanced teams can handle universal basic income or autonomous weapons. At any level, a good practice topic is balanced, has real clash and stakes, and is accessible without specialist knowledge. Competitive leagues set their own topics.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Topics by level</h3><p class="muted">Starter motions for new debaters, intermediate motions with more technical clash, and advanced motions for experienced teams.</p></article><article class="card"><h3>Topics by format</h3><p class="muted">Motion wording for BP and WSDC, resolutions for Public Forum and value resolutions for Lincoln-Douglas.</p></article><article class="card"><h3>From topic to first case</h3><p class="muted">How to tell a good practice motion from a weak one, and how to turn it into a case in one session.</p></article></section>
-      <div class="article section"><h2>What makes a good debate topic</h2><p>A good practice topic gives both sides real arguments. If one side has an obviously better case, the round teaches the losing side to cope with a bad position and the winning side very little. Before using a topic, check four things:</p><ul><li>Balance: could you write a strong case for either side in an hour?</li><li>Clash: do the two sides disagree about the same thing, or will they talk past each other?</li><li>Stakes: is there a real effect on real people, so impacts can be weighed?</li><li>Access: can students at this level understand the topic without specialist knowledge, or find material quickly?</li></ul><p>The motions below are written to pass those checks. They are for practice; competitive leagues set their own topics, and the wording matters, so keep it exactly as written when you practise.</p><h2>Starter topics for new debaters</h2><p>These rely on everyday experience, so students can argue them without research and focus on structure.</p><ul><li>This house would ban homework in primary schools. Clash: learning time against rest and family time.</li><li>This house would make school uniforms optional. Clash: equality and belonging against individual expression and cost.</li><li>This house would ban smartphones in secondary schools. Clash: attention and wellbeing against safety and digital skills.</li><li>This house believes that zoos do more harm than good. Clash: conservation against animal welfare.</li><li>This house would introduce a four-day school week. Clash: teacher retention and focus against childcare and lost instruction.</li><li>This house would require all students to learn a musical instrument. Clash: cultural and cognitive benefits against choice and resources.</li><li>This house believes that video games are good for young people. Clash: skills and community against time use and harm.</li></ul><h2>Intermediate topics</h2><p>These need some background knowledge and reward weighing between competing values.</p><ul><li>This house would lower the voting age to 16.</li><li>This house would make voting compulsory.</li><li>This house would tax sugary drinks.</li><li>This house would make public transport free.</li><li>This house believes that social media companies should be legally liable for misinformation on their platforms.</li><li>This house would ban advertising aimed at children.</li><li>This house would replace exams with continuous assessment.</li><li>This house believes that wealthy countries should accept more climate refugees.</li></ul><h2>Advanced topics</h2><p>These have technical clash, contested evidence and principled arguments on both sides.</p><ul><li>This house would introduce a universal basic income.</li><li>This house believes that developing countries should prioritise economic growth over environmental protection.</li><li>This house would ban the development of autonomous weapons.</li><li>This house believes that the rise of artificial intelligence will do more harm than good to workers.</li><li>This house would allow parents to genetically edit their children to prevent disease.</li><li>This house believes that international institutions should have the power to override national governments on climate policy.</li></ul><h2>Topics written for specific formats</h2><h3>British Parliamentary and World Schools</h3><p>Both use motions starting with This house would (a policy), This house believes that (a value judgment) or This house regrets (a judgment on something that has happened). Practise all three types, because each changes the burden. A regret motion such as This house regrets the rise of influencer culture asks you to compare the world as it is with a world where that thing never happened.</p><h3>Public Forum</h3><p>PF uses resolutions that name an actor and a policy, written to be argued by a general audience. Practice examples: Resolved: Schools should replace letter grades with pass or fail grading. Resolved: The benefits of nuclear energy outweigh the harms. Resolved: Governments should ban single-use plastics.</p><h3>Lincoln-Douglas</h3><p>LD resolutions ask about values and obligations. Practice examples: Resolved: Individuals have a moral obligation to help those in need. Resolved: A just society ought to prioritise equality over liberty. Resolved: Civil disobedience in a democracy is morally justified.</p><h2>Worked example: turning a topic into a first case</h2><div class="card"><h3>Motion: This house would replace exams with continuous assessment</h3><p><strong>Key terms:</strong> Continuous assessment means grades built from coursework, projects and regular tests across the year, instead of one final exam.</p><p><strong>Proposition burden:</strong> Show continuous assessment measures learning more fairly or more accurately than exams, without new harms that outweigh that.</p><p><strong>Proposition angle:</strong> Exams reward performance on one day, so anxiety, illness or a bad night&#x27;s sleep can outweigh a year of work.</p><p><strong>Opposition angle:</strong> Coursework is easier to get help with at home, so it favours students with educated or wealthy parents.</p><p><strong>The clash:</strong> Which system is the more accurate measure of what a student can do on their own?</p><p><strong>Weighing question:</strong> Is the unfairness of a single bad day larger or smaller than the unfairness of unequal help at home?</p></div><p>Ten minutes of this analysis gives a team enough to start writing contentions. The clash and the weighing question tell both sides where the round will be decided.</p><h2>How to use a topic list in practice</h2><ol><li>Pick a topic and flip a coin for sides, so students practise arguing positions they do not hold.</li><li>Give fifteen minutes of preparation for impromptu formats, or a week for prepared formats.</li><li>Run the round with real <a href="/online-debate-timer">speech times</a>.</li><li>Debrief on one question: where was the clash, and who won it?</li><li>Rerun the same topic with sides swapped. The second round is usually much better, because each team now knows the other side&#x27;s best arguments.</li></ol><p>For a quick random pick, the <a href="/tools/debate-motion-generator">free debate motion generator</a> draws a practice motion by topic and difficulty, with no account.</p><p>In DebateOwl, start a Current Debate with the motion and run Brainstorm to see angles for both sides, <a href="/ai-debate-case-generator">generate a case</a> with its predicted opposing case, or run a <a href="/ai-debate-practice">Sparring round</a> against the AI when there is no second team available.</p></div>
+      <div class="article section"><h2>What makes a good debate topic</h2><p>A good practice topic gives both sides real arguments. If one side has an obviously better case, the round teaches the losing side to cope with a bad position and the winning side very little. Before using a topic, check four things:</p><ul><li>Balance: could you write a strong case for either side in an hour?</li><li>Clash: do the two sides disagree about the same thing, or will they talk past each other?</li><li>Stakes: is there a real effect on real people, so impacts can be weighed?</li><li>Access: can students at this level understand the topic without specialist knowledge, or find material quickly?</li></ul><p>The motions below are written to pass those checks. They are for practice; competitive leagues set their own topics, and the wording matters, so keep it exactly as written when you practise.</p><h2>Starter topics for new debaters</h2><p>These rely on everyday experience, so students can argue them without research and focus on structure.</p><ul><li>This house would ban homework in primary schools. Clash: learning time against rest and family time.</li><li>This house would make school uniforms optional. Clash: equality and belonging against individual expression and cost.</li><li>This house would ban smartphones in secondary schools. Clash: attention and wellbeing against safety and digital skills.</li><li>This house believes that zoos do more harm than good. Clash: conservation against animal welfare.</li><li>This house would introduce a four-day school week. Clash: teacher retention and focus against childcare and lost instruction.</li><li>This house would require all students to learn a musical instrument. Clash: cultural and cognitive benefits against choice and resources.</li><li>This house believes that video games are good for young people. Clash: skills and community against time use and harm.</li></ul><h2>Intermediate topics</h2><p>These need some background knowledge and reward weighing between competing values.</p><ul><li>This house would lower the voting age to 16.</li><li>This house would make voting compulsory.</li><li>This house would tax sugary drinks.</li><li>This house would make public transport free.</li><li>This house believes that social media companies should be legally liable for misinformation on their platforms.</li><li>This house would ban advertising aimed at children.</li><li>This house would replace exams with continuous assessment.</li><li>This house believes that wealthy countries should accept more climate refugees.</li></ul><h2>Advanced topics</h2><p>These have technical clash, contested evidence and principled arguments on both sides.</p><ul><li>This house would introduce a universal basic income.</li><li>This house believes that developing countries should prioritise economic growth over environmental protection.</li><li>This house would ban the development of autonomous weapons.</li><li>This house believes that the rise of artificial intelligence will do more harm than good to workers.</li><li>This house would allow parents to genetically edit their children to prevent disease.</li><li>This house believes that international institutions should have the power to override national governments on climate policy.</li></ul><h2>Topics written for specific formats</h2><h3>British Parliamentary and World Schools</h3><p>Both use motions starting with This house would (a policy), This house believes that (a value judgment) or This house regrets (a judgment on something that has happened). Practise all three types, because each changes the burden. A regret motion such as This house regrets the rise of influencer culture asks you to compare the world as it is with a world where that thing never happened.</p><h3>Public Forum</h3><p>PF uses resolutions that name an actor and a policy, written to be argued by a general audience. Practice examples: Resolved: Schools should replace letter grades with pass or fail grading. Resolved: The benefits of nuclear energy outweigh the harms. Resolved: Governments should ban single-use plastics.</p><h3>Lincoln-Douglas</h3><p>LD resolutions ask about values and obligations. Practice examples: Resolved: Individuals have a moral obligation to help those in need. Resolved: A just society ought to prioritise equality over liberty. Resolved: Civil disobedience in a democracy is morally justified.</p><h2>Worked example: turning a topic into a first case</h2><div class="card"><h3>Motion: This house would replace exams with continuous assessment</h3><p><strong>Key terms:</strong> Continuous assessment means grades built from coursework, projects and regular tests across the year, instead of one final exam.</p><p><strong>Proposition burden:</strong> Show continuous assessment measures learning more fairly or more accurately than exams, without new harms that outweigh that.</p><p><strong>Proposition angle:</strong> Exams reward performance on one day, so anxiety, illness or a bad night&#x27;s sleep can outweigh a year of work.</p><p><strong>Opposition angle:</strong> Coursework is easier to get help with at home, so it favours students with educated or wealthy parents.</p><p><strong>The clash:</strong> Which system is the more accurate measure of what a student can do on their own?</p><p><strong>Weighing question:</strong> Is the unfairness of a single bad day larger or smaller than the unfairness of unequal help at home?</p></div><p>Ten minutes of this analysis gives a team enough to start writing contentions. The clash and the weighing question tell both sides where the round will be decided.</p><h2>How to use a topic list in practice</h2><ol><li>Pick a topic and flip a coin for sides, so students practise arguing positions they do not hold.</li><li>Give fifteen minutes of preparation for impromptu formats, or a week for prepared formats.</li><li>Run the round with real <a href="/online-debate-timer">speech times</a>.</li><li>Debrief on one question: where was the clash, and who won it?</li><li>Rerun the same topic with sides swapped. The second round is usually much better, because each team now knows the other side&#x27;s best arguments.</li></ol><p>For a quick random pick, the <a href="/tools/debate-motion-generator">free debate motion generator</a> draws a practice motion by topic and difficulty, with no account.</p><p>In DebateOwl, start a Current Debate with the motion and run Brainstorm to see angles for both sides, <a href="/ai-debate-case-generator">generate a case</a> with &quot;If they say…&quot; answers to the other side, or run a <a href="/ai-debate-practice">Sparring round</a> against the AI when there is no second team available.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>What are good debate topics for beginners?</summary><p>Topics students already know from daily life, such as homework, school uniforms, smartphones in school or a four-day school week. They let new debaters focus on structure instead of research.</p></details><details><summary>How do I know if a debate topic is balanced?</summary><p>Try writing a short case for each side. If one side struggles to find two serious arguments, the topic is unbalanced and will make a poor practice round.</p></details><details><summary>What is the difference between a motion and a resolution?</summary><p>They mean the same thing in different formats. BP and World Schools use motions such as This house would; Public Forum and Lincoln-Douglas use resolutions beginning Resolved.</p></details><details><summary>Where do competition debate topics come from?</summary><p>Each league or tournament sets its own. Some publish topics in advance for prepared formats; others release motions shortly before each round. Practise with your league&#x27;s past topics when they are available.</p></details><details><summary>Can AI help me prepare for a debate topic?</summary><p>Yes, for brainstorming angles, drafting a first case structure and predicting the other side. Check any facts against original sources and write the final case in your own words.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/debateowl-vs-chatgpt/index.html b/public/debateowl-vs-chatgpt/index.html
index 4e7880595..55b133a89 100644
--- a/public/debateowl-vs-chatgpt/index.html
+++ b/public/debateowl-vs-chatgpt/index.html
@@ -23,14 +23,14 @@
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="DebateOwl vs ChatGPT for Debate Prep | DebateOwl" />
   <meta name="twitter:description" content="How DebateOwl and ChatGPT compare for debate prep, from structured case and rebuttal workflows to evidence research and timed practice rounds." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"DebateOwl vs ChatGPT for Debate Prep","name":"DebateOwl vs ChatGPT for Debate Prep | DebateOwl","url":"https://debateowl.com/debateowl-vs-chatgpt","description":"How DebateOwl and ChatGPT compare for debate prep, from structured case and rebuttal workflows to evidence research and timed practice rounds.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which is better for debate prep, DebateOwl or ChatGPT?","acceptedAnswer":{"@type":"Answer","text":"It depends on the task. ChatGPT is better for learning a new topic, open brainstorming and general writing help, and it works for any subject. DebateOwl is better when you are preparing a specific motion: it keeps your cases, sources and practice rounds together, predicts the opposing case, times your speeches and gives a verdict on practice rounds. Many debaters use both, ChatGPT for background and DebateOwl for motion prep and practice. Neither replaces checking original sources."}},{"@type":"Question","name":"Is DebateOwl better than ChatGPT for debate?","acceptedAnswer":{"@type":"Answer","text":"For motion-specific preparation and practice rounds, a dedicated workspace saves setup and adds timing, an AI opponent and verdicts. For open-ended learning and general writing, ChatGPT is more flexible. Many debaters use both."}},{"@type":"Question","name":"Can I practise a debate round with ChatGPT?","acceptedAnswer":{"@type":"Answer","text":"You can ask it to role-play an opponent, but you have to manage the format, the speech order and the timing yourself, and there is no built-in verdict. DebateOwl's Sparring runs the round structure for you."}},{"@type":"Question","name":"Does DebateOwl keep my debate prep organised?","acceptedAnswer":{"@type":"Answer","text":"Yes. Cases, sources, analyses and practice rounds are saved inside the Current Debate they belong to, behind sign-in."}},{"@type":"Question","name":"Do I still need to check evidence from either tool?","acceptedAnswer":{"@type":"Answer","text":"Yes. Any AI tool can produce errors or misread sources. Open the original and confirm the exact claim before you use it in a round."}},{"@type":"Question","name":"Which formats does DebateOwl support?","acceptedAnswer":{"@type":"Answer","text":"Case generation, Attack, Ask and Crossfire work for any motion. Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, and the timer adds a Policy preset."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"DebateOwl vs ChatGPT for Debate Prep","item":"https://debateowl.com/debateowl-vs-chatgpt"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"DebateOwl vs ChatGPT for Debate Prep","name":"DebateOwl vs ChatGPT for Debate Prep | DebateOwl","url":"https://debateowl.com/debateowl-vs-chatgpt","description":"How DebateOwl and ChatGPT compare for debate prep, from structured case and rebuttal workflows to evidence research and timed practice rounds.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which is better for debate prep, DebateOwl or ChatGPT?","acceptedAnswer":{"@type":"Answer","text":"It depends on the task. ChatGPT is better for learning a new topic, open brainstorming and general writing help, and it works for any subject. DebateOwl is better when you are preparing a specific motion: it keeps your cases, sources and practice rounds together, drafts answers to what the other side will say, times your speeches and gives a verdict on practice rounds. Many debaters use both, ChatGPT for background and DebateOwl for motion prep and practice. Neither replaces checking original sources."}},{"@type":"Question","name":"Is DebateOwl better than ChatGPT for debate?","acceptedAnswer":{"@type":"Answer","text":"For motion-specific preparation and practice rounds, a dedicated workspace saves setup and adds timing, an AI opponent and verdicts. For open-ended learning and general writing, ChatGPT is more flexible. Many debaters use both."}},{"@type":"Question","name":"Can I practise a debate round with ChatGPT?","acceptedAnswer":{"@type":"Answer","text":"You can ask it to role-play an opponent, but you have to manage the format, the speech order and the timing yourself, and there is no built-in verdict. DebateOwl's Sparring runs the round structure for you."}},{"@type":"Question","name":"Does DebateOwl keep my debate prep organised?","acceptedAnswer":{"@type":"Answer","text":"Yes. Cases, sources, analyses and practice rounds are saved inside the Current Debate they belong to, behind sign-in."}},{"@type":"Question","name":"Do I still need to check evidence from either tool?","acceptedAnswer":{"@type":"Answer","text":"Yes. Any AI tool can produce errors or misread sources. Open the original and confirm the exact claim before you use it in a round."}},{"@type":"Question","name":"Which formats does DebateOwl support?","acceptedAnswer":{"@type":"Answer","text":"Case generation, Attack, Ask and Crossfire work for any motion. Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, and the timer adds a Policy preset."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"DebateOwl vs ChatGPT for Debate Prep","item":"https://debateowl.com/debateowl-vs-chatgpt"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">DebateOwl vs ChatGPT for Debate Prep</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Comparison</span><h1>DebateOwl vs ChatGPT for Debate Prep</h1><p class="lead">ChatGPT is a general chatbot. DebateOwl is a debate practice workspace.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
-      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Which is better for debate prep, DebateOwl or ChatGPT?</h2><p>It depends on the task. ChatGPT is better for learning a new topic, open brainstorming and general writing help, and it works for any subject. DebateOwl is better when you are preparing a specific motion: it keeps your cases, sources and practice rounds together, predicts the opposing case, times your speeches and gives a verdict on practice rounds. Many debaters use both, ChatGPT for background and DebateOwl for motion prep and practice. Neither replaces checking original sources.</p></section>
+      <header class="hero"><span class="eyebrow">Comparison</span><h1>DebateOwl vs ChatGPT for Debate Prep</h1><p class="lead">ChatGPT is a general chatbot. DebateOwl is a debate practice workspace.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Which is better for debate prep, DebateOwl or ChatGPT?</h2><p>It depends on the task. ChatGPT is better for learning a new topic, open brainstorming and general writing help, and it works for any subject. DebateOwl is better when you are preparing a specific motion: it keeps your cases, sources and practice rounds together, drafts answers to what the other side will say, times your speeches and gives a verdict on practice rounds. Many debaters use both, ChatGPT for background and DebateOwl for motion prep and practice. Neither replaces checking original sources.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>A general assistant</h3><p class="muted">ChatGPT can brainstorm, explain, draft and revise on any subject, including debate.</p></article><article class="card"><h3>A debate workspace</h3><p class="muted">DebateOwl organises prep around one motion at a time, with structured cases, an AI opponent, a timer and judged practice rounds.</p></article><article class="card"><h3>Using both</h3><p class="muted">Where each tool fits in a week of debate preparation, and how to move work between them.</p></article></section>
-      <div class="article section"><h2>The short answer</h2><p>ChatGPT is a general-purpose AI assistant. DebateOwl is a debate practice workspace. Both use large language models, but they are designed for different jobs. If you want to explore an idea, learn background on a topic or tighten a paragraph, a general assistant is flexible and fast. If you want to prepare a specific motion, practise against an opponent at real speech times and get a verdict on your round, a tool built around debate structure saves the setup you would otherwise do by hand in every conversation.</p><p>Many debaters use both. This page explains where each is stronger so you can decide what fits your preparation.</p><div class="table"><table><caption>DebateOwl vs ChatGPT for debate prep (as of October 2026)</caption><thead><tr><th scope="col">Feature</th><th scope="col">DebateOwl</th><th scope="col">ChatGPT</th></tr></thead><tbody><tr><td data-label="Feature">Structured case output</td><td data-label="DebateOwl">Every case has a thesis, a framework, contentions with warrants and impacts, the likely opposing case and counters</td><td data-label="ChatGPT">Whatever structure you ask for, in each conversation</td></tr><tr><td data-label="Feature">Saved sources (Library)</td><td data-label="DebateOwl">Sources you add to a debate&#x27;s Library are given to its prep tools</td><td data-label="ChatGPT">You paste the motion and your sources into each new conversation</td></tr><tr><td data-label="Feature">Web research with a source list</td><td data-label="DebateOwl">Generate researches the motion on the web and lists the sources it found; Ask can answer with citations</td><td data-label="ChatGPT">Not tied to one debate; nothing is saved to a Library</td></tr><tr><td data-label="Feature">Timed practice round with a verdict</td><td data-label="DebateOwl">Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, times each speech and ends with a verdict</td><td data-label="ChatGPT">No built-in round, timing or verdict; you role-play and keep time yourself</td></tr><tr><td data-label="Feature">Cross-examination drill</td><td data-label="DebateOwl">Crossfire drills cross-examination in either direction</td><td data-label="ChatGPT">Role-play on request</td></tr><tr><td data-label="Feature">Debate timer</td><td data-label="DebateOwl">A <a href="/tools/debate-timer">free debate timer</a> for seven formats, plus a speech timer in the app</td><td data-label="ChatGPT">None built in</td></tr><tr><td data-label="Feature">Formats</td><td data-label="DebateOwl">Case generation, Attack, Ask and Crossfire work for any motion; Sparring has three formats</td><td data-label="ChatGPT">Any format you describe</td></tr><tr><td data-label="Feature">Languages</td><td data-label="DebateOwl">English, Spanish and Hungarian</td><td data-label="ChatGPT">Not compared here</td></tr><tr><td data-label="Feature">Price</td><td data-label="DebateOwl">3-day free trial, then $5/month + tax</td><td data-label="ChatGPT">Free tier and paid plans; prices not compared here</td></tr></tbody></table></div><h2>What ChatGPT does well for debaters</h2><ul><li>Background learning: explaining an unfamiliar topic, the main positions in a policy area or a philosophical idea behind a value resolution.</li><li>Open brainstorming: generating many possible angles quickly, including unusual ones.</li><li>Writing help: tightening a sentence, simplifying a paragraph for a lay judge or suggesting a clearer tag line.</li><li>Flexibility: it handles any request, so you can use it for tasks no debate tool was built for.</li></ul><p>Those are real strengths. The limits come from the same flexibility: a general chat does not know which motion you are preparing, which side you are on, what format you debate or what sources you trust, unless you tell it again, and it has no concept of a round to practise in.</p><h2>What a debate workspace adds</h2><h3>One motion, one place</h3><p>In DebateOwl, everything belongs to a Current Debate: the motion, the Library sources you have added, generated cases, Attack analyses, practice rounds and debriefs. The prep tools read that context, so you never paste the motion and your research into a new conversation.</p><h3>Structured output</h3><p>Generated cases always have the same parts: thesis, framework, contentions with warrants and impacts, the case the other side is likely to run, and counters to it. Attack always returns ranked weaknesses that quote the attacked words, with a response to say in round, <a href="/how-to-cross-examine-in-debate">cross-examination</a> questions and a weighing analysis. Fixed structure makes the output easier to check and to turn into speeches.</p><h3>Timed practice rounds</h3><p>Sparring runs full rounds against an AI opponent in School 4-6-6-3, <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> and <a href="/public-forum-debate">Public Forum</a>, with each speech timed, and ends with a verdict that names the reason for the decision. Crossfire drills cross-examination in either direction. A speech timer covers Standard, Lincoln-Douglas, Public Forum and Policy speech orders.</p><h3>Sources you control</h3><p>Sources you add to the Library and mark active are given to the prep tools for that debate, which use the ones that fit each request. Ask can answer with citations, and Factoids researches a single claim. Evidence still needs checking against the original, as with any AI tool.</p><h2>Worked example: the same task in both tools</h2><div class="card"><h3>Task: prepare to answer the opposition on This house would make voting compulsory</h3><p><strong>In a general chat:</strong> You describe the motion, your side and your format, then ask for the opposition&#x27;s arguments. You get a useful list. To get responses, you ask again; to check one argument in depth, you paste it back; to practise, you would need to role-play a round and keep track of time yourself.</p><p><strong>In DebateOwl:</strong> You start a Current Debate with the motion, generate your proposition case and read the predicted opposition case it includes. You paste the strongest opposition argument into Attack, which returns its weakest link, a response to say and a cross-ex question. You import the questions into Crossfire to practise them, then run a timed Sparring round and read the verdict.</p><p><strong>The difference:</strong> Individual sentences can be similar in quality. What changes is how much setup you repeat, and whether you end up practising a round or only reading text.</p></div><h2>Which should you use?</h2><ul><li>Learning about a topic from scratch: a general assistant is a good start.</li><li>Writing a case for a specific motion: a debate workspace gives a consistent structure and a predicted opposing case.</li><li>Finding the weak point in an opposing argument: a tool that returns structured weaknesses and responses is faster to use in prep.</li><li>Practising speeches and rounds: you need timing, an opponent and a verdict, which a general chat does not provide.</li><li>Polishing wording: either works; use the one you are already in.</li></ul><p>A practical split is to use a general assistant for open-ended learning and DebateOwl for motion-specific preparation and practice.</p><h2>Things that are true of both</h2><p>Both can state things confidently that are not true, so neither replaces reading original sources before you quote them. Neither should be used during a round where your league forbids electronic help, which is most leagues. And neither replaces a coach or teammates who have watched you debate.</p></div>
+      <div class="article section"><h2>The short answer</h2><p>ChatGPT is a general-purpose AI assistant. DebateOwl is a debate practice workspace. Both use large language models, but they are designed for different jobs. If you want to explore an idea, learn background on a topic or tighten a paragraph, a general assistant is flexible and fast. If you want to prepare a specific motion, practise against an opponent at real speech times and get a verdict on your round, a tool built around debate structure saves the setup you would otherwise do by hand in every conversation.</p><p>Many debaters use both. This page explains where each is stronger so you can decide what fits your preparation.</p><div class="table"><table><caption>DebateOwl vs ChatGPT for debate prep (as of October 2026)</caption><thead><tr><th scope="col">Feature</th><th scope="col">DebateOwl</th><th scope="col">ChatGPT</th></tr></thead><tbody><tr><td data-label="Feature">Structured case output</td><td data-label="DebateOwl">Every case has an opening, arguments with explanation, evidence and why it matters, &quot;If they say… we answer…&quot; replies, a closing line and sources</td><td data-label="ChatGPT">Whatever structure you ask for, in each conversation</td></tr><tr><td data-label="Feature">Saved sources (Library)</td><td data-label="DebateOwl">Sources you add to a debate&#x27;s Library are given to its prep tools</td><td data-label="ChatGPT">You paste the motion and your sources into each new conversation</td></tr><tr><td data-label="Feature">Web research with a source list</td><td data-label="DebateOwl">Generate researches the motion on the web and lists the sources it found; Ask can answer with citations</td><td data-label="ChatGPT">Not tied to one debate; nothing is saved to a Library</td></tr><tr><td data-label="Feature">Timed practice round with a verdict</td><td data-label="DebateOwl">Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, times each speech and ends with a verdict</td><td data-label="ChatGPT">No built-in round, timing or verdict; you role-play and keep time yourself</td></tr><tr><td data-label="Feature">Cross-examination drill</td><td data-label="DebateOwl">Crossfire drills cross-examination in either direction</td><td data-label="ChatGPT">Role-play on request</td></tr><tr><td data-label="Feature">Debate timer</td><td data-label="DebateOwl">A <a href="/tools/debate-timer">free debate timer</a> for seven formats, plus a speech timer in the app</td><td data-label="ChatGPT">None built in</td></tr><tr><td data-label="Feature">Formats</td><td data-label="DebateOwl">Case generation, Attack, Ask and Crossfire work for any motion; Sparring has three formats</td><td data-label="ChatGPT">Any format you describe</td></tr><tr><td data-label="Feature">Languages</td><td data-label="DebateOwl">English, Spanish and Hungarian</td><td data-label="ChatGPT">Not compared here</td></tr><tr><td data-label="Feature">Price</td><td data-label="DebateOwl">3-day free trial, then $5/month + tax</td><td data-label="ChatGPT">Free tier and paid plans; prices not compared here</td></tr></tbody></table></div><h2>What ChatGPT does well for debaters</h2><ul><li>Background learning: explaining an unfamiliar topic, the main positions in a policy area or a philosophical idea behind a value resolution.</li><li>Open brainstorming: generating many possible angles quickly, including unusual ones.</li><li>Writing help: tightening a sentence, simplifying a paragraph for a lay judge or suggesting a clearer tag line.</li><li>Flexibility: it handles any request, so you can use it for tasks no debate tool was built for.</li></ul><p>Those are real strengths. The limits come from the same flexibility: a general chat does not know which motion you are preparing, which side you are on, what format you debate or what sources you trust, unless you tell it again, and it has no concept of a round to practise in.</p><h2>What a debate workspace adds</h2><h3>One motion, one place</h3><p>In DebateOwl, everything belongs to a Current Debate: the motion, the Library sources you have added, generated cases, Attack analyses, practice rounds and debriefs. The prep tools read that context, so you never paste the motion and your research into a new conversation.</p><h3>Structured output</h3><p>Generated cases always have the same parts: an opening, arguments with explanation, evidence and why each matters, &quot;If they say… we answer…&quot; replies to the other side, a closing line and a source list. Attack always returns ranked weaknesses that quote the attacked words, with a response to say in round, <a href="/how-to-cross-examine-in-debate">cross-examination</a> questions and a weighing analysis. Fixed structure makes the output easier to check and to turn into speeches.</p><h3>Timed practice rounds</h3><p>Sparring runs full rounds against an AI opponent in School 4-6-6-3, <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> and <a href="/public-forum-debate">Public Forum</a>, with each speech timed, and ends with a verdict that names the reason for the decision. Crossfire drills cross-examination in either direction. A speech timer covers Standard, Lincoln-Douglas, Public Forum and Policy speech orders.</p><h3>Sources you control</h3><p>Sources you add to the Library and mark active are given to the prep tools for that debate, which use the ones that fit each request. Ask can answer with citations, and Factoids researches a single claim. Evidence still needs checking against the original, as with any AI tool.</p><h2>Worked example: the same task in both tools</h2><div class="card"><h3>Task: prepare to answer the opposition on This house would make voting compulsory</h3><p><strong>In a general chat:</strong> You describe the motion, your side and your format, then ask for the opposition&#x27;s arguments. You get a useful list. To get responses, you ask again; to check one argument in depth, you paste it back; to practise, you would need to role-play a round and keep track of time yourself.</p><p><strong>In DebateOwl:</strong> You start a Current Debate with the motion, generate your proposition case and read its &quot;If they say…&quot; answers to the opposition. You paste the strongest opposition argument into Attack, which returns its weakest link, a response to say and a cross-ex question. You import the questions into Crossfire to practise them, then run a timed Sparring round and read the verdict.</p><p><strong>The difference:</strong> Individual sentences can be similar in quality. What changes is how much setup you repeat, and whether you end up practising a round or only reading text.</p></div><h2>Which should you use?</h2><ul><li>Learning about a topic from scratch: a general assistant is a good start.</li><li>Writing a case for a specific motion: a debate workspace gives a consistent structure and answers to what the other side will say.</li><li>Finding the weak point in an opposing argument: a tool that returns structured weaknesses and responses is faster to use in prep.</li><li>Practising speeches and rounds: you need timing, an opponent and a verdict, which a general chat does not provide.</li><li>Polishing wording: either works; use the one you are already in.</li></ul><p>A practical split is to use a general assistant for open-ended learning and DebateOwl for motion-specific preparation and practice.</p><h2>Things that are true of both</h2><p>Both can state things confidently that are not true, so neither replaces reading original sources before you quote them. Neither should be used during a round where your league forbids electronic help, which is most leagues. And neither replaces a coach or teammates who have watched you debate.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>Is DebateOwl better than ChatGPT for debate?</summary><p>For motion-specific preparation and practice rounds, a dedicated workspace saves setup and adds timing, an AI opponent and verdicts. For open-ended learning and general writing, ChatGPT is more flexible. Many debaters use both.</p></details><details><summary>Can I practise a debate round with ChatGPT?</summary><p>You can ask it to role-play an opponent, but you have to manage the format, the speech order and the timing yourself, and there is no built-in verdict. DebateOwl&#x27;s Sparring runs the round structure for you.</p></details><details><summary>Does DebateOwl keep my debate prep organised?</summary><p>Yes. Cases, sources, analyses and practice rounds are saved inside the Current Debate they belong to, behind sign-in.</p></details><details><summary>Do I still need to check evidence from either tool?</summary><p>Yes. Any AI tool can produce errors or misread sources. Open the original and confirm the exact claim before you use it in a round.</p></details><details><summary>Which formats does DebateOwl support?</summary><p>Case generation, Attack, Ask and Crossfire work for any motion. Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, and the timer adds a Policy preset.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/debateowl-vs-debateclub/index.html b/public/debateowl-vs-debateclub/index.html
index 25c341b70..c5c2ea373 100644
--- a/public/debateowl-vs-debateclub/index.html
+++ b/public/debateowl-vs-debateclub/index.html
@@ -23,14 +23,14 @@
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="DebateOwl vs DebateClub | DebateOwl" />
   <meta name="twitter:description" content="How DebateOwl and DebateClub compare for debate practice, from voice sparring to structured case prep, rebuttal drills and evidence research." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"DebateOwl vs DebateClub","name":"DebateOwl vs DebateClub | DebateOwl","url":"https://debateowl.com/debateowl-vs-debateclub","description":"How DebateOwl and DebateClub compare for debate practice, from voice sparring to structured case prep, rebuttal drills and evidence research.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which is better, DebateOwl or DebateClub?","acceptedAnswer":{"@type":"Answer","text":"They solve different problems. As of October 2026, DebateClub is voice-only sparring for high-stakes conversations such as negotiations, pitches and meetings, with opponent personas and rhetorical technique scoring, and Pro costs $19/month. It names no competitive debate formats. DebateOwl is built for school and competitive debate: cases, rebuttals, evidence, a timer and timed rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum, at $5/month + tax after a 3-day trial. Choose DebateClub for workplace persuasion practice and DebateOwl for tournament prep."}},{"@type":"Question","name":"Is DebateClub for competitive debate?","acceptedAnswer":{"@type":"Answer","text":"As of October 2026, DebateClub's site describes training for high-stakes conversations such as negotiations and pitches and does not name competitive debate formats."}},{"@type":"Question","name":"Does DebateOwl support voice practice?","acceptedAnswer":{"@type":"Answer","text":"Yes. Sparring has a voice mode, so you can speak your speeches instead of typing them."}},{"@type":"Question","name":"Which is cheaper?","acceptedAnswer":{"@type":"Answer","text":"As of October 2026, DebateOwl Pro is $5/month + tax and DebateClub Pro is $19/month. DebateClub also has a free tier with one debate credit; DebateOwl has a 3-day trial and no permanent free plan."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"DebateOwl vs DebateClub","item":"https://debateowl.com/debateowl-vs-debateclub"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"DebateOwl vs DebateClub","name":"DebateOwl vs DebateClub | DebateOwl","url":"https://debateowl.com/debateowl-vs-debateclub","description":"How DebateOwl and DebateClub compare for debate practice, from voice sparring to structured case prep, rebuttal drills and evidence research.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which is better, DebateOwl or DebateClub?","acceptedAnswer":{"@type":"Answer","text":"They solve different problems. As of October 2026, DebateClub is voice-only sparring for high-stakes conversations such as negotiations, pitches and meetings, with opponent personas and rhetorical technique scoring, and Pro costs $19/month. It names no competitive debate formats. DebateOwl is built for school and competitive debate: cases, rebuttals, evidence, a timer and timed rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum, at $5/month + tax after a 3-day trial. Choose DebateClub for workplace persuasion practice and DebateOwl for tournament prep."}},{"@type":"Question","name":"Is DebateClub for competitive debate?","acceptedAnswer":{"@type":"Answer","text":"As of October 2026, DebateClub's site describes training for high-stakes conversations such as negotiations and pitches and does not name competitive debate formats."}},{"@type":"Question","name":"Does DebateOwl support voice practice?","acceptedAnswer":{"@type":"Answer","text":"Yes. Sparring has a voice mode, so you can speak your speeches instead of typing them."}},{"@type":"Question","name":"Which is cheaper?","acceptedAnswer":{"@type":"Answer","text":"As of October 2026, DebateOwl Pro is $5/month + tax and DebateClub Pro is $19/month. DebateClub also has a free tier with one debate credit; DebateOwl has a 3-day trial and no permanent free plan."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"DebateOwl vs DebateClub","item":"https://debateowl.com/debateowl-vs-debateclub"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">DebateOwl vs DebateClub</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Comparison</span><h1>DebateOwl vs DebateClub</h1><p class="lead">Voice sparring vs structured prep: two approaches to AI debate practice.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">Comparison</span><h1>DebateOwl vs DebateClub</h1><p class="lead">Voice sparring vs structured prep: two approaches to AI debate practice.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Which is better, DebateOwl or DebateClub?</h2><p>They solve different problems. As of October 2026, DebateClub is voice-only sparring for high-stakes conversations such as negotiations, pitches and meetings, with opponent personas and rhetorical technique scoring, and Pro costs $19/month. It names no competitive debate formats. DebateOwl is built for school and competitive debate: cases, rebuttals, evidence, a timer and timed rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum, at $5/month + tax after a 3-day trial. Choose DebateClub for workplace persuasion practice and DebateOwl for tournament prep.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Audience</h3><p class="muted">As of October 2026, DebateClub describes itself as training for high-stakes conversations such as negotiations, pitches and meetings. DebateOwl is built for school and competitive debate.</p></article><article class="card"><h3>Practice style</h3><p class="muted">DebateClub is voice-only sparring with opponent personas. DebateOwl combines case prep tools with timed Sparring rounds you can type or speak.</p></article><article class="card"><h3>Price</h3><p class="muted">DebateClub has a free tier with one debate credit and Pro at $19/month. DebateOwl has a 3-day free trial, then Pro at $5/month + tax.</p></article></section>
-      <div class="article section"><h2>What DebateClub offers</h2><p>DebateClub (debateclub.app) calls itself a training platform for high-stakes conversations: you speak out loud and an AI sparring partner responds in real time. Its site lists opponent personas such as a skeptical investor or a hostile critic, detection and scoring of rhetorical techniques, session recordings and a prep screen for openings and counters. It does not name school or competitive debate formats.</p><p>As of October 2026, its plans are Free ($0, one debate credit) and Pro ($19/month or $149/year). These details come from DebateClub&#x27;s own site; check it for current terms.</p><h2>What DebateOwl offers</h2><p>DebateOwl is an AI debate prep and practice app for students and competitive debaters, with 8 prep modes. It builds structured cases with a predicted opponent case, finds weak links with Attack, researches claims with Factoids, drills <a href="/how-to-cross-examine-in-debate">cross-examination</a> in Crossfire and runs timed Sparring rounds in School 4-6-6-3, <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> and <a href="/public-forum-debate">Public Forum</a> that end in a verdict. Voice mode lets you speak your speeches instead of typing them.</p><p>As of October 2026, DebateOwl has a 3-day free trial with no credit card, then Pro at $5/month + tax. The app is available in English, Spanish and Hungarian.</p><h2>Side by side</h2><div class="table"><table><caption>DebateOwl vs DebateClub (as of October 2026, from each product&#x27;s own site)</caption><thead><tr><th scope="col">Feature</th><th scope="col">DebateOwl</th><th scope="col">DebateClub</th></tr></thead><tbody><tr><td data-label="Feature">Built for</td><td data-label="DebateOwl">School and competitive debate</td><td data-label="DebateClub">High-stakes conversations such as negotiations, pitches and meetings</td></tr><tr><td data-label="Feature">Formats named</td><td data-label="DebateOwl">Sparring rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum</td><td data-label="DebateClub">None</td></tr><tr><td data-label="Feature">Practice style</td><td data-label="DebateOwl">Timed Sparring rounds you can type or speak, ending in a verdict</td><td data-label="DebateClub">Voice-only sparring with opponent personas and rhetorical technique scoring</td></tr><tr><td data-label="Feature">Prep tools</td><td data-label="DebateOwl">Cases with a predicted opponent case, Attack, Factoids, Crossfire and a timer</td><td data-label="DebateClub">A prep screen for openings and counters</td></tr><tr><td data-label="Feature">Price</td><td data-label="DebateOwl">3-day free trial, then $5/month + tax</td><td data-label="DebateClub">Free tier with one debate credit; Pro $19/month or $149/year</td></tr></tbody></table></div><h2>Which fits you</h2><ul><li>Preparing for a negotiation, pitch, interview or meeting: DebateClub is built for that.</li><li>Practising out loud against interruptions and difficult personas: DebateClub.</li><li>Preparing cases, rebuttals and evidence for a debate tournament: DebateOwl.</li><li>Practising full rounds in a school debate format with speech times and a verdict: DebateOwl.</li></ul></div>
+      <div class="article section"><h2>What DebateClub offers</h2><p>DebateClub (debateclub.app) calls itself a training platform for high-stakes conversations: you speak out loud and an AI sparring partner responds in real time. Its site lists opponent personas such as a skeptical investor or a hostile critic, detection and scoring of rhetorical techniques, session recordings and a prep screen for openings and counters. It does not name school or competitive debate formats.</p><p>As of October 2026, its plans are Free ($0, one debate credit) and Pro ($19/month or $149/year). These details come from DebateClub&#x27;s own site; check it for current terms.</p><h2>What DebateOwl offers</h2><p>DebateOwl is an AI debate prep and practice app for students and competitive debaters, with 8 prep modes. It builds ready-to-read cases with &quot;If they say…&quot; answers to the other side, finds weak links with Attack, researches claims with Factoids, drills <a href="/how-to-cross-examine-in-debate">cross-examination</a> in Crossfire and runs timed Sparring rounds in School 4-6-6-3, <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> and <a href="/public-forum-debate">Public Forum</a> that end in a verdict. Voice mode lets you speak your speeches instead of typing them.</p><p>As of October 2026, DebateOwl has a 3-day free trial with no credit card, then Pro at $5/month + tax. The app is available in English, Spanish and Hungarian.</p><h2>Side by side</h2><div class="table"><table><caption>DebateOwl vs DebateClub (as of October 2026, from each product&#x27;s own site)</caption><thead><tr><th scope="col">Feature</th><th scope="col">DebateOwl</th><th scope="col">DebateClub</th></tr></thead><tbody><tr><td data-label="Feature">Built for</td><td data-label="DebateOwl">School and competitive debate</td><td data-label="DebateClub">High-stakes conversations such as negotiations, pitches and meetings</td></tr><tr><td data-label="Feature">Formats named</td><td data-label="DebateOwl">Sparring rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum</td><td data-label="DebateClub">None</td></tr><tr><td data-label="Feature">Practice style</td><td data-label="DebateOwl">Timed Sparring rounds you can type or speak, ending in a verdict</td><td data-label="DebateClub">Voice-only sparring with opponent personas and rhetorical technique scoring</td></tr><tr><td data-label="Feature">Prep tools</td><td data-label="DebateOwl">Cases with &quot;If they say…&quot; answers, Attack, Factoids, Crossfire and a timer</td><td data-label="DebateClub">A prep screen for openings and counters</td></tr><tr><td data-label="Feature">Price</td><td data-label="DebateOwl">3-day free trial, then $5/month + tax</td><td data-label="DebateClub">Free tier with one debate credit; Pro $19/month or $149/year</td></tr></tbody></table></div><h2>Which fits you</h2><ul><li>Preparing for a negotiation, pitch, interview or meeting: DebateClub is built for that.</li><li>Practising out loud against interruptions and difficult personas: DebateClub.</li><li>Preparing cases, rebuttals and evidence for a debate tournament: DebateOwl.</li><li>Practising full rounds in a school debate format with speech times and a verdict: DebateOwl.</li></ul></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>Is DebateClub for competitive debate?</summary><p>As of October 2026, DebateClub&#x27;s site describes training for high-stakes conversations such as negotiations and pitches and does not name competitive debate formats.</p></details><details><summary>Does DebateOwl support voice practice?</summary><p>Yes. Sparring has a voice mode, so you can speak your speeches instead of typing them.</p></details><details><summary>Which is cheaper?</summary><p>As of October 2026, DebateOwl Pro is $5/month + tax and DebateClub Pro is $19/month. DebateClub also has a free tier with one debate credit; DebateOwl has a 3-day trial and no permanent free plan.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/debateowl-vs-windebate/index.html b/public/debateowl-vs-windebate/index.html
index 590b80504..d7ce7f4d0 100644
--- a/public/debateowl-vs-windebate/index.html
+++ b/public/debateowl-vs-windebate/index.html
@@ -23,14 +23,14 @@
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="DebateOwl vs WinDebate | DebateOwl" />
   <meta name="twitter:description" content="How DebateOwl and WinDebate compare on case generation, rebuttal drills, evidence research, supported formats, pricing and day-to-day workflow." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"DebateOwl vs WinDebate","name":"DebateOwl vs WinDebate | DebateOwl","url":"https://debateowl.com/debateowl-vs-windebate","description":"How DebateOwl and WinDebate compare on case generation, rebuttal drills, evidence research, supported formats, pricing and day-to-day workflow.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which is better, DebateOwl or WinDebate?","acceptedAnswer":{"@type":"Answer","text":"It depends on your format, budget and how you practise. As of October 2026, WinDebate names six formats including Congressional, Policy and British Parliamentary, has a free tier with monthly limits, and adds live-round capture, replay review and progress tracking, with paid plans from $19.99/month. DebateOwl costs $5/month + tax after a 3-day trial, runs full practice rounds against an AI opponent in School 4-6-6-3, Lincoln-Douglas and Public Forum, and works in English, Spanish and Hungarian. Choose WinDebate for Policy, Congress or season tracking, and DebateOwl for low-cost case building and sparring."}},{"@type":"Question","name":"Is DebateOwl cheaper than WinDebate?","acceptedAnswer":{"@type":"Answer","text":"As of October 2026, DebateOwl Pro is $5/month + tax and WinDebate's paid plans start at $19.99/month. WinDebate also has a free tier with monthly limits; DebateOwl has a 3-day trial and no permanent free plan."}},{"@type":"Question","name":"Which formats does each tool support?","acceptedAnswer":{"@type":"Answer","text":"WinDebate names Public Forum, Lincoln-Douglas, Congressional, Policy, World Schools and British Parliamentary. DebateOwl's case, Attack, Ask and Crossfire tools work for any motion, and Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds."}},{"@type":"Question","name":"Can I use both?","acceptedAnswer":{"@type":"Answer","text":"Yes. They are separate products, and some debaters use one for prep and another for review."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"DebateOwl vs WinDebate","item":"https://debateowl.com/debateowl-vs-windebate"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"DebateOwl vs WinDebate","name":"DebateOwl vs WinDebate | DebateOwl","url":"https://debateowl.com/debateowl-vs-windebate","description":"How DebateOwl and WinDebate compare on case generation, rebuttal drills, evidence research, supported formats, pricing and day-to-day workflow.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which is better, DebateOwl or WinDebate?","acceptedAnswer":{"@type":"Answer","text":"It depends on your format, budget and how you practise. As of October 2026, WinDebate names six formats including Congressional, Policy and British Parliamentary, has a free tier with monthly limits, and adds live-round capture, replay review and progress tracking, with paid plans from $19.99/month. DebateOwl costs $5/month + tax after a 3-day trial, runs full practice rounds against an AI opponent in School 4-6-6-3, Lincoln-Douglas and Public Forum, and works in English, Spanish and Hungarian. Choose WinDebate for Policy, Congress or season tracking, and DebateOwl for low-cost case building and sparring."}},{"@type":"Question","name":"Is DebateOwl cheaper than WinDebate?","acceptedAnswer":{"@type":"Answer","text":"As of October 2026, DebateOwl Pro is $5/month + tax and WinDebate's paid plans start at $19.99/month. WinDebate also has a free tier with monthly limits; DebateOwl has a 3-day trial and no permanent free plan."}},{"@type":"Question","name":"Which formats does each tool support?","acceptedAnswer":{"@type":"Answer","text":"WinDebate names Public Forum, Lincoln-Douglas, Congressional, Policy, World Schools and British Parliamentary. DebateOwl's case, Attack, Ask and Crossfire tools work for any motion, and Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds."}},{"@type":"Question","name":"Can I use both?","acceptedAnswer":{"@type":"Answer","text":"Yes. They are separate products, and some debaters use one for prep and another for review."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"DebateOwl vs WinDebate","item":"https://debateowl.com/debateowl-vs-windebate"}]},{"@type":"SoftwareApplication","@id":"https://debateowl.com/#software","name":"DebateOwl","alternateName":"Debate Owl","description":"DebateOwl is an AI debate prep and practice app for students and competitive debaters that builds structured cases, finds the weak points in arguments, researches evidence with citations and runs timed practice rounds against an AI opponent.","applicationCategory":"EducationalApplication","operatingSystem":"Web","url":"https://debateowl.com/","inLanguage":["en","es","hu"],"featureList":["Case generator","Brainstorm","Factoids","Flowchart","Case attacker","Ask coach","Crossfire","Sparring","Library","Debate timer","History"],"offers":[{"@type":"Offer","name":"Free trial","price":"0","priceCurrency":"USD","description":"3-day free trial, no credit card required."},{"@type":"Offer","name":"Pro","price":"5","priceCurrency":"USD","description":"Monthly subscription, billed plus tax.","priceSpecification":{"@type":"UnitPriceSpecification","price":"5","priceCurrency":"USD","billingDuration":"P1M","valueAddedTaxIncluded":false}}],"publisher":{"@id":"https://debateowl.com/#organization"}}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">DebateOwl vs WinDebate</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">Comparison</span><h1>DebateOwl vs WinDebate</h1><p class="lead">Two AI debate prep platforms compared on features and workflows.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">Comparison</span><h1>DebateOwl vs WinDebate</h1><p class="lead">Two AI debate prep platforms compared on features and workflows.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">Which is better, DebateOwl or WinDebate?</h2><p>It depends on your format, budget and how you practise. As of October 2026, WinDebate names six formats including Congressional, Policy and British Parliamentary, has a free tier with monthly limits, and adds live-round capture, replay review and progress tracking, with paid plans from $19.99/month. DebateOwl costs $5/month + tax after a 3-day trial, runs full practice rounds against an AI opponent in School 4-6-6-3, Lincoln-Douglas and Public Forum, and works in English, Spanish and Hungarian. Choose WinDebate for Policy, Congress or season tracking, and DebateOwl for low-cost case building and sparring.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>Formats</h3><p class="muted">As of October 2026, WinDebate names six formats: Public Forum, Lincoln-Douglas, Congressional, Policy, World Schools and British Parliamentary. DebateOwl&#x27;s Sparring rounds cover School 4-6-6-3, Lincoln-Douglas and Public Forum.</p></article><article class="card"><h3>Price</h3><p class="muted">WinDebate has a free tier with monthly limits and paid plans from $19.99/month. DebateOwl has a 3-day free trial, then Pro at $5/month + tax.</p></article><article class="card"><h3>Workflow</h3><p class="muted">WinDebate is organised as prep, practice, live round and review. DebateOwl keeps cases, sources, practice rounds and debriefs together in one Current Debate.</p></article></section>
-      <div class="article section"><h2>What WinDebate offers</h2><p>WinDebate (windebate.ai) describes itself as a debate training platform with four stages: prep, practice, live and review. Its site lists research on both sides with evidence and rebuttal trees, targeted drills for attack, defense, weighing and speeches, a Live Round Assistant that captures speeches and builds response cards, replay review that turns a round into drills, and progress tracking.</p><p>As of October 2026, its plans are Free ($0, with 1 research session, 10 drills and 1 Live Assistant round a month), Plus ($19.99/month, which adds voice input and playback and weekly progress) and Pro ($39.99/month). These details come from WinDebate&#x27;s own site; check it for current terms.</p><h2>What DebateOwl offers</h2><p>DebateOwl is an AI debate prep and practice app with 8 prep modes. You start a Current Debate for one motion, add sources to its Library, generate a structured case with a predicted opponent case, find weak links with Attack, research claims with Factoids, ask the Ask coach, drill cross-examination in Crossfire, and run timed Sparring rounds against an AI opponent that end in a verdict. A speech timer and an argument flowchart round it out.</p><p>As of October 2026, DebateOwl has a 3-day free trial with no credit card, then Pro at $5/month + tax. The app is available in English, Spanish and Hungarian.</p><h2>Side by side</h2><div class="table"><table><caption>DebateOwl vs WinDebate (as of October 2026, from each product&#x27;s own site)</caption><thead><tr><th scope="col">Feature</th><th scope="col">DebateOwl</th><th scope="col">WinDebate</th></tr></thead><tbody><tr><td data-label="Feature">Formats named</td><td data-label="DebateOwl">Sparring rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum; prep tools work for any motion</td><td data-label="WinDebate">Public Forum, Lincoln-Douglas, Congressional, Policy, World Schools and British Parliamentary</td></tr><tr><td data-label="Feature">Practice</td><td data-label="DebateOwl">Timed rounds against an AI opponent that end in a verdict, plus Crossfire drills</td><td data-label="WinDebate">Targeted drills for attack, defense, weighing and speeches</td></tr><tr><td data-label="Feature">Review</td><td data-label="DebateOwl">Cases, sources, rounds and debriefs kept in one Current Debate</td><td data-label="WinDebate">Live Round Assistant, replay review and progress tracking</td></tr><tr><td data-label="Feature">Free plan</td><td data-label="DebateOwl">3-day free trial, no permanent free plan</td><td data-label="WinDebate">Free tier with 1 research session, 10 drills and 1 Live Assistant round a month</td></tr><tr><td data-label="Feature">Paid price</td><td data-label="DebateOwl">$5/month + tax</td><td data-label="WinDebate">Plus $19.99/month, Pro $39.99/month</td></tr></tbody></table></div><h2>How to choose</h2><ul><li>You debate Policy, Congress or <a href="/british-parliamentary-debate">British Parliamentary</a> and want a tool that names your format: WinDebate lists all three.</li><li>You want to track progress across a season or review recorded rounds: WinDebate lists progress tracking and replay review.</li><li>You want a free tier you can keep using: WinDebate has one; DebateOwl does not.</li><li>You want full practice rounds against an AI opponent in School 4-6-6-3, <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> or <a href="/public-forum-debate">Public Forum</a>, with a verdict: DebateOwl.</li><li>You prepare in Spanish or Hungarian, or want the lowest paid price: DebateOwl.</li></ul><p>The fairest test is to run the same motion through both during DebateOwl&#x27;s trial and WinDebate&#x27;s free tier, then compare the cases, the feedback and how much setup each needed.</p></div>
+      <div class="article section"><h2>What WinDebate offers</h2><p>WinDebate (windebate.ai) describes itself as a debate training platform with four stages: prep, practice, live and review. Its site lists research on both sides with evidence and rebuttal trees, targeted drills for attack, defense, weighing and speeches, a Live Round Assistant that captures speeches and builds response cards, replay review that turns a round into drills, and progress tracking.</p><p>As of October 2026, its plans are Free ($0, with 1 research session, 10 drills and 1 Live Assistant round a month), Plus ($19.99/month, which adds voice input and playback and weekly progress) and Pro ($39.99/month). These details come from WinDebate&#x27;s own site; check it for current terms.</p><h2>What DebateOwl offers</h2><p>DebateOwl is an AI debate prep and practice app with 8 prep modes. You start a Current Debate for one motion, add sources to its Library, generate a ready-to-read case with &quot;If they say…&quot; answers to the other side, find weak links with Attack, research claims with Factoids, ask the Ask coach, drill cross-examination in Crossfire, and run timed Sparring rounds against an AI opponent that end in a verdict. A speech timer and an argument flowchart round it out.</p><p>As of October 2026, DebateOwl has a 3-day free trial with no credit card, then Pro at $5/month + tax. The app is available in English, Spanish and Hungarian.</p><h2>Side by side</h2><div class="table"><table><caption>DebateOwl vs WinDebate (as of October 2026, from each product&#x27;s own site)</caption><thead><tr><th scope="col">Feature</th><th scope="col">DebateOwl</th><th scope="col">WinDebate</th></tr></thead><tbody><tr><td data-label="Feature">Formats named</td><td data-label="DebateOwl">Sparring rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum; prep tools work for any motion</td><td data-label="WinDebate">Public Forum, Lincoln-Douglas, Congressional, Policy, World Schools and British Parliamentary</td></tr><tr><td data-label="Feature">Practice</td><td data-label="DebateOwl">Timed rounds against an AI opponent that end in a verdict, plus Crossfire drills</td><td data-label="WinDebate">Targeted drills for attack, defense, weighing and speeches</td></tr><tr><td data-label="Feature">Review</td><td data-label="DebateOwl">Cases, sources, rounds and debriefs kept in one Current Debate</td><td data-label="WinDebate">Live Round Assistant, replay review and progress tracking</td></tr><tr><td data-label="Feature">Free plan</td><td data-label="DebateOwl">3-day free trial, no permanent free plan</td><td data-label="WinDebate">Free tier with 1 research session, 10 drills and 1 Live Assistant round a month</td></tr><tr><td data-label="Feature">Paid price</td><td data-label="DebateOwl">$5/month + tax</td><td data-label="WinDebate">Plus $19.99/month, Pro $39.99/month</td></tr></tbody></table></div><h2>How to choose</h2><ul><li>You debate Policy, Congress or <a href="/british-parliamentary-debate">British Parliamentary</a> and want a tool that names your format: WinDebate lists all three.</li><li>You want to track progress across a season or review recorded rounds: WinDebate lists progress tracking and replay review.</li><li>You want a free tier you can keep using: WinDebate has one; DebateOwl does not.</li><li>You want full practice rounds against an AI opponent in School 4-6-6-3, <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> or <a href="/public-forum-debate">Public Forum</a>, with a verdict: DebateOwl.</li><li>You prepare in Spanish or Hungarian, or want the lowest paid price: DebateOwl.</li></ul><p>The fairest test is to run the same motion through both during DebateOwl&#x27;s trial and WinDebate&#x27;s free tier, then compare the cases, the feedback and how much setup each needed.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>Is DebateOwl cheaper than WinDebate?</summary><p>As of October 2026, DebateOwl Pro is $5/month + tax and WinDebate&#x27;s paid plans start at $19.99/month. WinDebate also has a free tier with monthly limits; DebateOwl has a 3-day trial and no permanent free plan.</p></details><details><summary>Which formats does each tool support?</summary><p>WinDebate names Public Forum, Lincoln-Douglas, Congressional, Policy, World Schools and British Parliamentary. DebateOwl&#x27;s case, Attack, Ask and Crossfire tools work for any motion, and Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds.</p></details><details><summary>Can I use both?</summary><p>Yes. They are separate products, and some debaters use one for prep and another for review.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/how-to-practice-rebuttals/index.html b/public/how-to-practice-rebuttals/index.html
index 07cbaa930..895356908 100644
--- a/public/how-to-practice-rebuttals/index.html
+++ b/public/how-to-practice-rebuttals/index.html
@@ -23,14 +23,14 @@
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="How to Practice Debate Rebuttals | DebateOwl" />
   <meta name="twitter:description" content="Drills for practicing debate rebuttals one skill at a time, from attacking warrants and evidence to weighing impacts and collapsing your last speech." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"How to Practice Debate Rebuttals","name":"How to Practice Debate Rebuttals | DebateOwl","url":"https://debateowl.com/how-to-practice-rebuttals","description":"Drills for practicing debate rebuttals one skill at a time, from attacking warrants and evidence to weighing impacts and collapsing your last speech.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is the best way to practise debate rebuttals?","acceptedAnswer":{"@type":"Answer","text":"Use short, frequent drills that copy the pressure of a round: arguments you did not write, a clock, and feedback on one thing. Three or four sessions of 20 to 30 minutes a week, each training one skill, beat one long session. New debaters should start with selection, picking the argument that decides the round, then move on to warrant attacks, grouping and weighing under time. Shadow rebuttals and flipping your own case work alone, while one-sentence answers and rapid fire need a partner. Score each speech on the same five questions to track progress."}},{"@type":"Question","name":"How often should I practise rebuttals?","acceptedAnswer":{"@type":"Answer","text":"Short, frequent sessions work better than one long one. Three or four sessions of 20 to 30 minutes a week, each focused on one skill, will improve a rebuttal faster than a single full practice round."}},{"@type":"Question","name":"Can I practise rebuttals without a partner?","acceptedAnswer":{"@type":"Answer","text":"Yes. Shadow rebuttals from recorded rounds, flipping your own case and answering a predicted opponent case all work alone. An AI opponent adds a responsive voice when no partner is available."}},{"@type":"Question","name":"What should I practise first as a new debater?","acceptedAnswer":{"@type":"Answer","text":"Selection. Learn to pick the one or two arguments that decide the round before you work on speed or style. Answering the right argument badly still beats answering the wrong one well."}},{"@type":"Question","name":"How do I know if my rebuttal practice is working?","acceptedAnswer":{"@type":"Answer","text":"Score each practice speech on the same five questions: right argument first, warrant attacked, arguments grouped, impact explained, finished on time. Rising scores over a few weeks mean the drills are working."}},{"@type":"Question","name":"How should I structure a rebuttal speech?","acceptedAnswer":{"@type":"Answer","text":"Answer the clash that decides the round first, attack the warrants rather than the claims, extend your own strongest argument, and finish by telling the judge why your side wins."}},{"@type":"Question","name":"Should I memorise rebuttals?","acceptedAnswer":{"@type":"Answer","text":"Memorise the structure and a few strong lines, not whole speeches. In round you need to adapt each response to what the opponent actually said."}},{"@type":"Question","name":"What is a block file?","acceptedAnswer":{"@type":"Answer","text":"A collection of short prepared answers to the arguments you expect, organised by clash and written for both sides, so rebuttals start from tested material."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"How to Practice Debate Rebuttals","item":"https://debateowl.com/how-to-practice-rebuttals"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"How to Practice Debate Rebuttals","name":"How to Practice Debate Rebuttals | DebateOwl","url":"https://debateowl.com/how-to-practice-rebuttals","description":"Drills for practicing debate rebuttals one skill at a time, from attacking warrants and evidence to weighing impacts and collapsing your last speech.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is the best way to practise debate rebuttals?","acceptedAnswer":{"@type":"Answer","text":"Use short, frequent drills that copy the pressure of a round: arguments you did not write, a clock, and feedback on one thing. Three or four sessions of 20 to 30 minutes a week, each training one skill, beat one long session. New debaters should start with selection, picking the argument that decides the round, then move on to warrant attacks, grouping and weighing under time. Shadow rebuttals and flipping your own case work alone, while one-sentence answers and rapid fire need a partner. Score each speech on the same five questions to track progress."}},{"@type":"Question","name":"How often should I practise rebuttals?","acceptedAnswer":{"@type":"Answer","text":"Short, frequent sessions work better than one long one. Three or four sessions of 20 to 30 minutes a week, each focused on one skill, will improve a rebuttal faster than a single full practice round."}},{"@type":"Question","name":"Can I practise rebuttals without a partner?","acceptedAnswer":{"@type":"Answer","text":"Yes. Shadow rebuttals from recorded rounds, flipping your own case and answering a predicted opponent case all work alone. An AI opponent adds a responsive voice when no partner is available."}},{"@type":"Question","name":"What should I practise first as a new debater?","acceptedAnswer":{"@type":"Answer","text":"Selection. Learn to pick the one or two arguments that decide the round before you work on speed or style. Answering the right argument badly still beats answering the wrong one well."}},{"@type":"Question","name":"How do I know if my rebuttal practice is working?","acceptedAnswer":{"@type":"Answer","text":"Score each practice speech on the same five questions: right argument first, warrant attacked, arguments grouped, impact explained, finished on time. Rising scores over a few weeks mean the drills are working."}},{"@type":"Question","name":"How should I structure a rebuttal speech?","acceptedAnswer":{"@type":"Answer","text":"Answer the clash that decides the round first, attack the warrants rather than the claims, extend your own strongest argument, and finish by telling the judge why your side wins."}},{"@type":"Question","name":"Should I memorise rebuttals?","acceptedAnswer":{"@type":"Answer","text":"Memorise the structure and a few strong lines, not whole speeches. In round you need to adapt each response to what the opponent actually said."}},{"@type":"Question","name":"What is a block file?","acceptedAnswer":{"@type":"Answer","text":"A collection of short prepared answers to the arguments you expect, organised by clash and written for both sides, so rebuttals start from tested material."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"How to Practice Debate Rebuttals","item":"https://debateowl.com/how-to-practice-rebuttals"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,11 +39,11 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">How to Practice Debate Rebuttals</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">How-to guide</span><h1>How to Practice Debate Rebuttals</h1><p class="lead">Build sharper responses by attacking warrants, evidence, impacts, and weighing one drill at a time.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <header class="hero"><span class="eyebrow">How-to guide</span><h1>How to Practice Debate Rebuttals</h1><p class="lead">Build sharper responses by attacking warrants, evidence, impacts, and weighing one drill at a time.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
       <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">What is the best way to practise debate rebuttals?</h2><p>Use short, frequent drills that copy the pressure of a round: arguments you did not write, a clock, and feedback on one thing. Three or four sessions of 20 to 30 minutes a week, each training one skill, beat one long session. New debaters should start with selection, picking the argument that decides the round, then move on to warrant attacks, grouping and weighing under time. Shadow rebuttals and flipping your own case work alone, while one-sentence answers and rapid fire need a partner. Score each speech on the same five questions to track progress.</p></section>
       
       <section class="grid" aria-label="Highlights"><article class="card"><h3>A weekly drill plan</h3><p class="muted">Four short sessions a week, each training one rebuttal skill: selection, warrant attacks, grouping, and weighing under time.</p></article><article class="card"><h3>Drills that work alone or with a partner</h3><p class="muted">Shadow rebuttals, flip-the-flow, one-sentence answers and rapid-fire rounds, with a version for solo practice and one for teams.</p></article><article class="card"><h3>A way to measure progress</h3><p class="muted">A five-point checklist to score each practice rebuttal, so you can tell whether the drills are changing your speeches.</p></article></section>
-      <div class="article section"><h2>Why rebuttal is a separate skill</h2><p>Most debaters can write a decent case with enough time. Rebuttal is harder because it happens live: you hear an argument once, decide whether it matters, find the flaw, and explain it in under a minute while the judge is still listening. None of those steps improve by reading more about debate. They improve with repetitions that copy the pressure of a round.</p><p>Good <a href="/debate-rebuttal-practice">rebuttal practice</a> therefore has three features. It uses arguments you did not write, so you cannot rely on knowing the answer in advance. It runs against a clock, so you learn to choose. And it ends with feedback on one specific thing, so the next repetition is different from the last. The drills below are built around those three rules.</p><h2>The shape of a rebuttal speech</h2><p>The drills train four moves, and a finished rebuttal speech makes all four in this order:</p><ol><li>Select. Name the clash that decides the round and answer it first. Do not try to answer every argument.</li><li>Attack the warrant. A claim without a warrant is an assertion, so break the reason they gave, not the conclusion they drew.</li><li>Extend. Bring back your own strongest argument, show it survived their responses, and say what it still proves.</li><li>Frame the ballot. End by telling the judge why your side wins the clash that matters. If you do not give them that story, they will write their own.</li></ol><h2>A four-session weekly plan</h2><p>Each session takes 20 to 30 minutes. Run them in this order, because each one depends on the skill before it.</p><ol><li>Selection (Monday). Read or listen to a full opposing constructive. Without answering anything, write down the one argument that decides the round if it stands, and one sentence saying why. Repeat with three different speeches. The goal is to stop treating every argument as equally important.</li><li>Warrant attacks (Tuesday). Take five opposing claims and, for each, write the reason the other side gives for it. Then write one sentence attacking that reason, not the claim. If you cannot find their warrant, your rebuttal is that they never gave one.</li><li>Grouping (Thursday). Take a speech with six or more arguments and sort them into two or three groups that share an assumption. Answer each group once. This is the skill that saves the shortest rebuttal speeches in every format.</li><li>Weighing under time (Friday). Give a full rebuttal speech against the clock, and finish with thirty seconds that compare your impact with theirs on one measure: probability, magnitude, timeframe or who is affected.</li></ol><p>If you have a fifth session, use it for a full practice round so the separate skills come together in one speech.</p><h2>Seven rebuttal drills</h2><h3>Shadow rebuttal</h3><p>Watch a recorded round or read a transcript, pause after each constructive, and give the rebuttal you would have given. Then compare it with what the real speaker said. You get high-level opposing arguments without needing an opponent.</p><h3>Flip the flow</h3><p>Take your own case and rebut it as if you were on the other side. The weak points you find are the ones a good opponent will find too, so fix them before the round instead of during it.</p><h3>One-sentence answers</h3><p>A partner reads a claim; you have ten seconds to answer in one sentence. The drill trains you to lead with the response instead of with a long setup. Keep a list of the sentences that worked.</p><h3>Rapid fire</h3><p>A partner reads eight short arguments in two minutes. You have two minutes to answer them all. Most debaters run out of time on the first three, which is exactly the habit the drill is meant to break: group, prioritise, move on.</p><h3>Response ladder</h3><p>For one argument, write five different responses: deny the claim, attack the warrant, mitigate the impact, turn it and outweigh it. Then rank them. Practising all five shows you which kind of response you lean on too much.</p><h3>Drop audit</h3><p>After a practice round, go through your flow and circle every opposing argument you did not answer. For each one, decide whether dropping it was a choice or an accident. Accidents are what you drill next.</p><h3>Spar the predicted case</h3><p>In DebateOwl, generate a case on your side and read the predicted opponent case. Paste the strongest opposing argument into Attack to see where it breaks, then run a Sparring round and answer it live. The verdict tells you whether your answer changed the outcome.</p><h2>Worked example: from first attempt to clean rebuttal</h2><div class="card"><h3>Motion: This house would lower the voting age to 16</h3><p><strong>Opposing argument:</strong> Sixteen-year-olds lack the life experience to make informed political choices, so lowering the voting age would worsen the quality of democratic decisions.</p><p><strong>First attempt:</strong> That is not true, plenty of sixteen-year-olds are very mature and some adults are not informed either, so it is unfair to single out young people.</p><p><strong>What went wrong:</strong> The answer is a counter-assertion followed by a fairness point. It never names the opponent&#x27;s warrant (experience produces better choices) or explains why the judge should doubt it.</p><p><strong>Rebuilt response:</strong> Their argument needs experience to be the thing that makes a vote informed. But we do not test experience for any other voter. Information comes from education, and sixteen-year-olds are still in school, studying the systems they would vote on.</p><p><strong>Weighing line:</strong> Even if some young voters are less informed, that harm is small and spread thin, while excluding a whole age group from decisions that affect them for longest is certain and lasting.</p><p><strong>Timed version:</strong> Forty seconds: name their warrant, show it is not applied to anyone else, give the alternative mechanism, close with the weighing.</p></div><p>The rebuilt version is not more clever than the first attempt. It is more organised: it names what the opponent needs, explains why they do not have it, and tells the judge what that means for the round.</p><h2>Build a block file</h2><p>A block is a short prepared answer to an argument you expect, and a block file is your collection of them. Good blocks make rebuttals faster and more precise, because the thinking happens before the round and the speech only has to adapt it.</p><ol><li>Organise by clash, not by source. Put every answer to &quot;the policy costs too much&quot; under one heading, whichever card it uses.</li><li>Write blocks for both sides of each clash, since you will usually debate both.</li><li>Give each block a tag, two to four numbered answers, the evidence for each, and a closing weighing line.</li><li>Keep each block short enough to read in under a minute, so you can use two or three in one speech.</li><li>After every tournament, rewrite the blocks that failed and add the arguments you did not expect.</li></ol><div class="card"><h3>Example block: answering &quot;a four-day school week saves money&quot;</h3><p><strong>1.</strong> Savings are small: buses and some staff costs fall, but salaries, which are most of a school budget, do not.</p><p><strong>2.</strong> Costs move to families, who pay for childcare on the fifth day.</p><p><strong>3.</strong> Even if the school saves money, it is buying the saving with less teaching time, which is the thing schools exist to provide.</p><p><strong>Weighing line:</strong> A small budget saving does not outweigh a lasting loss of learning time.</p></div><p>AI is useful for the first draft of a block file: ask for the arguments you are likely to face and a first answer to each. Then check every factual claim against an original source and rewrite the answers in your own words, so you can deliver them without reading.</p><h2>How to judge your own practice</h2><p>Record your practice rebuttals, or have a partner listen, and score each speech on five questions. Give one point for each yes.</p><ul><li>Did I answer the argument that decided the round first?</li><li>Did each response attack a warrant, or at least say which part of the argument it targets?</li><li>Did I group similar arguments instead of answering them one by one?</li><li>Did I explain why my response matters for the decision, not just that it is true?</li><li>Did I finish inside the time without rushing the last point?</li></ul><p>A score of three is a solid novice rebuttal; five is what you are aiming for <a href="/how-to-prepare-for-a-debate-tournament">before a tournament</a>. Track the scores across a few weeks. If one question keeps getting a no, drop the other drills and run the one that trains it.</p><h2>Format notes for timing practice</h2><h3>Public Forum (PF)</h3><p>Rebuttals are four minutes. The second-speaking team usually spends part of that time answering responses to its own case, so practise a split: about two and a half minutes on offence and a minute and a half rebuilding. The DebateOwl timer has a <a href="/public-forum-debate">Public Forum</a> preset for the full speech order.</p><h3>Lincoln-Douglas (LD)</h3><p>The four-minute first affirmative rebuttal must answer a seven-minute negative constructive. Practise grouping and cross-applying your framework until you can cover every major argument with time left for one extension.</p><h3>World Schools (WSDC)</h3><p>Rebuttal runs through every substantive speech. Practise opening each speech with ninety seconds to two minutes of rebuttal before your own material, and for third speakers, practise organising the whole debate into two or three clashes.</p><h3>British Parliamentary (BP)</h3><p>With seven-minute speeches and four teams, the drill that matters most is selection: which of the previous speeches&#x27; arguments actually need an answer from your position. Practise naming the bench you are responding to before each response.</p></div>
+      <div class="article section"><h2>Why rebuttal is a separate skill</h2><p>Most debaters can write a decent case with enough time. Rebuttal is harder because it happens live: you hear an argument once, decide whether it matters, find the flaw, and explain it in under a minute while the judge is still listening. None of those steps improve by reading more about debate. They improve with repetitions that copy the pressure of a round.</p><p>Good <a href="/debate-rebuttal-practice">rebuttal practice</a> therefore has three features. It uses arguments you did not write, so you cannot rely on knowing the answer in advance. It runs against a clock, so you learn to choose. And it ends with feedback on one specific thing, so the next repetition is different from the last. The drills below are built around those three rules.</p><h2>The shape of a rebuttal speech</h2><p>The drills train four moves, and a finished rebuttal speech makes all four in this order:</p><ol><li>Select. Name the clash that decides the round and answer it first. Do not try to answer every argument.</li><li>Attack the warrant. A claim without a warrant is an assertion, so break the reason they gave, not the conclusion they drew.</li><li>Extend. Bring back your own strongest argument, show it survived their responses, and say what it still proves.</li><li>Frame the ballot. End by telling the judge why your side wins the clash that matters. If you do not give them that story, they will write their own.</li></ol><h2>A four-session weekly plan</h2><p>Each session takes 20 to 30 minutes. Run them in this order, because each one depends on the skill before it.</p><ol><li>Selection (Monday). Read or listen to a full opposing constructive. Without answering anything, write down the one argument that decides the round if it stands, and one sentence saying why. Repeat with three different speeches. The goal is to stop treating every argument as equally important.</li><li>Warrant attacks (Tuesday). Take five opposing claims and, for each, write the reason the other side gives for it. Then write one sentence attacking that reason, not the claim. If you cannot find their warrant, your rebuttal is that they never gave one.</li><li>Grouping (Thursday). Take a speech with six or more arguments and sort them into two or three groups that share an assumption. Answer each group once. This is the skill that saves the shortest rebuttal speeches in every format.</li><li>Weighing under time (Friday). Give a full rebuttal speech against the clock, and finish with thirty seconds that compare your impact with theirs on one measure: probability, magnitude, timeframe or who is affected.</li></ol><p>If you have a fifth session, use it for a full practice round so the separate skills come together in one speech.</p><h2>Seven rebuttal drills</h2><h3>Shadow rebuttal</h3><p>Watch a recorded round or read a transcript, pause after each constructive, and give the rebuttal you would have given. Then compare it with what the real speaker said. You get high-level opposing arguments without needing an opponent.</p><h3>Flip the flow</h3><p>Take your own case and rebut it as if you were on the other side. The weak points you find are the ones a good opponent will find too, so fix them before the round instead of during it.</p><h3>One-sentence answers</h3><p>A partner reads a claim; you have ten seconds to answer in one sentence. The drill trains you to lead with the response instead of with a long setup. Keep a list of the sentences that worked.</p><h3>Rapid fire</h3><p>A partner reads eight short arguments in two minutes. You have two minutes to answer them all. Most debaters run out of time on the first three, which is exactly the habit the drill is meant to break: group, prioritise, move on.</p><h3>Response ladder</h3><p>For one argument, write five different responses: deny the claim, attack the warrant, mitigate the impact, turn it and outweigh it. Then rank them. Practising all five shows you which kind of response you lean on too much.</p><h3>Drop audit</h3><p>After a practice round, go through your flow and circle every opposing argument you did not answer. For each one, decide whether dropping it was a choice or an accident. Accidents are what you drill next.</p><h3>Spar the &quot;If they say…&quot; claims</h3><p>In DebateOwl, generate a case on your side and read its &quot;If they say…&quot; answers. Paste the strongest opposing claim into Attack to see where it breaks, then run a Sparring round and answer it live. The verdict tells you whether your answer changed the outcome.</p><h2>Worked example: from first attempt to clean rebuttal</h2><div class="card"><h3>Motion: This house would lower the voting age to 16</h3><p><strong>Opposing argument:</strong> Sixteen-year-olds lack the life experience to make informed political choices, so lowering the voting age would worsen the quality of democratic decisions.</p><p><strong>First attempt:</strong> That is not true, plenty of sixteen-year-olds are very mature and some adults are not informed either, so it is unfair to single out young people.</p><p><strong>What went wrong:</strong> The answer is a counter-assertion followed by a fairness point. It never names the opponent&#x27;s warrant (experience produces better choices) or explains why the judge should doubt it.</p><p><strong>Rebuilt response:</strong> Their argument needs experience to be the thing that makes a vote informed. But we do not test experience for any other voter. Information comes from education, and sixteen-year-olds are still in school, studying the systems they would vote on.</p><p><strong>Weighing line:</strong> Even if some young voters are less informed, that harm is small and spread thin, while excluding a whole age group from decisions that affect them for longest is certain and lasting.</p><p><strong>Timed version:</strong> Forty seconds: name their warrant, show it is not applied to anyone else, give the alternative mechanism, close with the weighing.</p></div><p>The rebuilt version is not more clever than the first attempt. It is more organised: it names what the opponent needs, explains why they do not have it, and tells the judge what that means for the round.</p><h2>Build a block file</h2><p>A block is a short prepared answer to an argument you expect, and a block file is your collection of them. Good blocks make rebuttals faster and more precise, because the thinking happens before the round and the speech only has to adapt it.</p><ol><li>Organise by clash, not by source. Put every answer to &quot;the policy costs too much&quot; under one heading, whichever card it uses.</li><li>Write blocks for both sides of each clash, since you will usually debate both.</li><li>Give each block a tag, two to four numbered answers, the evidence for each, and a closing weighing line.</li><li>Keep each block short enough to read in under a minute, so you can use two or three in one speech.</li><li>After every tournament, rewrite the blocks that failed and add the arguments you did not expect.</li></ol><div class="card"><h3>Example block: answering &quot;a four-day school week saves money&quot;</h3><p><strong>1.</strong> Savings are small: buses and some staff costs fall, but salaries, which are most of a school budget, do not.</p><p><strong>2.</strong> Costs move to families, who pay for childcare on the fifth day.</p><p><strong>3.</strong> Even if the school saves money, it is buying the saving with less teaching time, which is the thing schools exist to provide.</p><p><strong>Weighing line:</strong> A small budget saving does not outweigh a lasting loss of learning time.</p></div><p>AI is useful for the first draft of a block file: ask for the arguments you are likely to face and a first answer to each. Then check every factual claim against an original source and rewrite the answers in your own words, so you can deliver them without reading.</p><h2>How to judge your own practice</h2><p>Record your practice rebuttals, or have a partner listen, and score each speech on five questions. Give one point for each yes.</p><ul><li>Did I answer the argument that decided the round first?</li><li>Did each response attack a warrant, or at least say which part of the argument it targets?</li><li>Did I group similar arguments instead of answering them one by one?</li><li>Did I explain why my response matters for the decision, not just that it is true?</li><li>Did I finish inside the time without rushing the last point?</li></ul><p>A score of three is a solid novice rebuttal; five is what you are aiming for <a href="/how-to-prepare-for-a-debate-tournament">before a tournament</a>. Track the scores across a few weeks. If one question keeps getting a no, drop the other drills and run the one that trains it.</p><h2>Format notes for timing practice</h2><h3>Public Forum (PF)</h3><p>Rebuttals are four minutes. The second-speaking team usually spends part of that time answering responses to its own case, so practise a split: about two and a half minutes on offence and a minute and a half rebuilding. The DebateOwl timer has a <a href="/public-forum-debate">Public Forum</a> preset for the full speech order.</p><h3>Lincoln-Douglas (LD)</h3><p>The four-minute first affirmative rebuttal must answer a seven-minute negative constructive. Practise grouping and cross-applying your framework until you can cover every major argument with time left for one extension.</p><h3>World Schools (WSDC)</h3><p>Rebuttal runs through every substantive speech. Practise opening each speech with ninety seconds to two minutes of rebuttal before your own material, and for third speakers, practise organising the whole debate into two or three clashes.</p><h3>British Parliamentary (BP)</h3><p>With seven-minute speeches and four teams, the drill that matters most is selection: which of the previous speeches&#x27; arguments actually need an answer from your position. Practise naming the bench you are responding to before each response.</p></div>
       <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>How often should I practise rebuttals?</summary><p>Short, frequent sessions work better than one long one. Three or four sessions of 20 to 30 minutes a week, each focused on one skill, will improve a rebuttal faster than a single full practice round.</p></details><details><summary>Can I practise rebuttals without a partner?</summary><p>Yes. Shadow rebuttals from recorded rounds, flipping your own case and answering a predicted opponent case all work alone. An AI opponent adds a responsive voice when no partner is available.</p></details><details><summary>What should I practise first as a new debater?</summary><p>Selection. Learn to pick the one or two arguments that decide the round before you work on speed or style. Answering the right argument badly still beats answering the wrong one well.</p></details><details><summary>How do I know if my rebuttal practice is working?</summary><p>Score each practice speech on the same five questions: right argument first, warrant attacked, arguments grouped, impact explained, finished on time. Rising scores over a few weeks mean the drills are working.</p></details><details><summary>How should I structure a rebuttal speech?</summary><p>Answer the clash that decides the round first, attack the warrants rather than the claims, extend your own strongest argument, and finish by telling the judge why your side wins.</p></details><details><summary>Should I memorise rebuttals?</summary><p>Memorise the structure and a few strong lines, not whole speeches. In round you need to adapt each response to what the opponent actually said.</p></details><details><summary>What is a block file?</summary><p>A collection of short prepared answers to the arguments you expect, organised by clash and written for both sides, so rebuttals start from tested material.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
diff --git a/public/how-to-write-a-debate-case/index.html b/public/how-to-write-a-debate-case/index.html
index 7afafa51b..fdb602219 100644
--- a/public/how-to-write-a-debate-case/index.html
+++ b/public/how-to-write-a-debate-case/index.html
@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>How to Write a Debate Case | DebateOwl</title>
-  <meta name="description" content="A step-by-step guide to writing a debate case, from motion analysis and burdens to contentions with warrants, evidence, impacts and weighing." />
+  <meta name="description" content="A step-by-step guide to writing a debate case: motion analysis, an opening, arguments with evidence, answers to the other side and a closing line." />
   <meta name="robots" content="index, follow, max-snippet:-1, max-image-preview:large" />
   <link rel="canonical" href="https://debateowl.com/how-to-write-a-debate-case" />
   <meta name="author" content="DebateOwl" />
@@ -16,21 +16,21 @@
   <meta property="og:type" content="article" />
   <meta property="og:site_name" content="DebateOwl" />
   <meta property="og:title" content="How to Write a Debate Case | DebateOwl" />
-  <meta property="og:description" content="A step-by-step guide to writing a debate case, from motion analysis and burdens to contentions with warrants, evidence, impacts and weighing." />
+  <meta property="og:description" content="A step-by-step guide to writing a debate case: motion analysis, an opening, arguments with evidence, answers to the other side and a closing line." />
   <meta property="og:url" content="https://debateowl.com/how-to-write-a-debate-case" />
   <meta property="og:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta property="og:image:width" content="1200" />
   <meta property="og:image:height" content="630" />
   <meta property="og:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <meta property="article:published_time" content="2026-07-05" />
-  <meta property="article:modified_time" content="2026-10-27" />
+  <meta property="article:modified_time" content="2026-10-28" />
   <meta name="twitter:card" content="summary_large_image" />
   <meta name="twitter:title" content="How to Write a Debate Case | DebateOwl" />
-  <meta name="twitter:description" content="A step-by-step guide to writing a debate case, from motion analysis and burdens to contentions with warrants, evidence, impacts and weighing." />
+  <meta name="twitter:description" content="A step-by-step guide to writing a debate case: motion analysis, an opening, arguments with evidence, answers to the other side and a closing line." />
   <meta name="twitter:image" content="https://debateowl.com/hero-visual.jpg?v=2" />
   <meta name="twitter:image:alt" content="DebateOwl wordmark with the owl, for AI debate prep and practice" />
   <link rel="stylesheet" href="/seo-pages.css" />
-  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"How to Write a Debate Case","name":"How to Write a Debate Case | DebateOwl","url":"https://debateowl.com/how-to-write-a-debate-case","description":"A step-by-step guide to writing a debate case, from motion analysis and burdens to contentions with warrants, evidence, impacts and weighing.","inLanguage":"en","dateModified":"2026-10-27","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"How do you write a debate case?","acceptedAnswer":{"@type":"Answer","text":"Start with the motion, not the arguments. Read it word by word, define the key terms fairly and write your burden in one sentence. Brainstorm widely, then keep two to four contentions, each built as claim, warrant, evidence, impact and weighing. Add a framework telling the judge how to decide, pre-empt the obvious response inside each contention, and read the case aloud against a timer until it fits. The format changes the details: Public Forum constructives usually fit two contentions, Lincoln-Douglas cases centre on a value and criterion, and BP closing teams prepare an extension instead."}},{"@type":"Question","name":"How many contentions should a debate case have?","acceptedAnswer":{"@type":"Answer","text":"Usually two to four. Public Forum constructives often fit two; formats with longer speeches can take three or four. Fewer well-defended contentions beat many thin ones."}},{"@type":"Question","name":"What is the difference between a claim and a warrant?","acceptedAnswer":{"@type":"Answer","text":"The claim is what you say is true; the warrant is the reason it is true. Judges vote on warrants, so a claim without one is an assertion that the other side can dismiss."}},{"@type":"Question","name":"How long does it take to write a debate case?","acceptedAnswer":{"@type":"Answer","text":"A first draft can take an hour once you have researched the topic. Expect to revise it several times after practice rounds expose its weak points."}},{"@type":"Question","name":"Should I write my case word for word?","acceptedAnswer":{"@type":"Answer","text":"In formats with prepared constructives, such as Public Forum and Lincoln-Douglas, most debaters do. In impromptu formats like BP and WSDC, prepare an outline and key lines instead."}},{"@type":"Question","name":"How do I make a case harder to attack?","acceptedAnswer":{"@type":"Answer","text":"Explain every warrant, use evidence you have checked, pre-empt the most obvious response inside each contention, and attack the draft yourself before the round."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"How to Write a Debate Case","item":"https://debateowl.com/how-to-write-a-debate-case"}]}]}</script>
+  <script type="application/ld+json">{"@context":"https://schema.org","@graph":[{"@type":"Article","headline":"How to Write a Debate Case","name":"How to Write a Debate Case | DebateOwl","url":"https://debateowl.com/how-to-write-a-debate-case","description":"A step-by-step guide to writing a debate case: motion analysis, an opening, arguments with evidence, answers to the other side and a closing line.","inLanguage":"en","dateModified":"2026-10-28","datePublished":"2026-07-05","author":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"publisher":{"@type":"Organization","@id":"https://debateowl.com/#organization","name":"DebateOwl","url":"https://debateowl.com/","logo":{"@type":"ImageObject","url":"https://debateowl.com/icon-512.png","width":512,"height":512}},"about":{"@id":"https://debateowl.com/#software"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"How do you write a debate case?","acceptedAnswer":{"@type":"Answer","text":"Start with the motion, not the arguments. Define the key terms fairly and write down in one sentence what your side has to prove. Keep two to four arguments, each with a point, an explanation, evidence and why it matters. Open with a hook and what you will show, add \"If they say… we answer…\" replies, end on a closing line, and time a reading aloud. The format changes the details: Public Forum constructives usually fit two arguments, Lincoln-Douglas cases centre on a value and criterion, and BP closing teams prepare an extension instead."}},{"@type":"Question","name":"How many contentions should a debate case have?","acceptedAnswer":{"@type":"Answer","text":"Usually two to four arguments, which some formats call contentions. Public Forum constructives often fit two; formats with longer speeches can take three or four. Fewer well-defended arguments beat many thin ones."}},{"@type":"Question","name":"What is the difference between a claim and a warrant?","acceptedAnswer":{"@type":"Answer","text":"The claim is what you say is true; the warrant is the reason it is true. In a case, they are the point and its explanation. Judges vote on the reasons, so a claim without one is an assertion that the other side can dismiss."}},{"@type":"Question","name":"How long does it take to write a debate case?","acceptedAnswer":{"@type":"Answer","text":"A first draft can take an hour once you have researched the topic. Expect to revise it several times after practice rounds expose its weak points."}},{"@type":"Question","name":"Should I write my case word for word?","acceptedAnswer":{"@type":"Answer","text":"In formats with prepared constructives, such as Public Forum and Lincoln-Douglas, most debaters do. In impromptu formats like BP and WSDC, prepare an outline and key lines instead."}},{"@type":"Question","name":"How do I make a case harder to attack?","acceptedAnswer":{"@type":"Answer","text":"Explain why every point is true, use evidence you have checked, answer the most obvious response inside each argument, and attack the draft yourself before the round."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"DebateOwl","item":"https://debateowl.com/"},{"@type":"ListItem","position":2,"name":"How to Write a Debate Case","item":"https://debateowl.com/how-to-write-a-debate-case"}]}]}</script>
 </head>
 <body>
   <header class="wrap">
@@ -39,12 +39,12 @@
   <main class="wrap">
     <nav class="breadcrumb" aria-label="Breadcrumb"><a href="/">DebateOwl</a> / <span aria-current="page">How to Write a Debate Case</span></nav>
     <article>
-      <header class="hero"><span class="eyebrow">How-to guide</span><h1>How to Write a Debate Case</h1><p class="lead">Move from motion analysis to contentions, warrants, evidence, impacts, and weighing.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-27">October 27, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
-      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">How do you write a debate case?</h2><p>Start with the motion, not the arguments. Read it word by word, define the key terms fairly and write your burden in one sentence. Brainstorm widely, then keep two to four contentions, each built as claim, warrant, evidence, impact and weighing. Add a framework telling the judge how to decide, pre-empt the obvious response inside each contention, and read the case aloud against a timer until it fits. The format changes the details: Public Forum constructives usually fit two contentions, Lincoln-Douglas cases centre on a value and criterion, and BP closing teams prepare an extension instead.</p></section>
+      <header class="hero"><span class="eyebrow">How-to guide</span><h1>How to Write a Debate Case</h1><p class="lead">Move from motion analysis to an opening, arguments with evidence, answers to the other side, and a closing line.</p><p class="dates">Published <time datetime="2026-07-05">July 5, 2026</time> · Updated <time datetime="2026-10-28">October 28, 2026</time></p><p class="dates">By the <a href="/">DebateOwl team</a></p><div class="cta"><a class="btn primary" href="/app">Start practicing</a><a class="btn secondary" href="/">See DebateOwl</a></div></header>
+      <section class="answer" aria-labelledby="short-answer"><h2 id="short-answer">How do you write a debate case?</h2><p>Start with the motion, not the arguments. Define the key terms fairly and write down in one sentence what your side has to prove. Keep two to four arguments, each with a point, an explanation, evidence and why it matters. Open with a hook and what you will show, add &quot;If they say… we answer…&quot; replies, end on a closing line, and time a reading aloud. The format changes the details: Public Forum constructives usually fit two arguments, Lincoln-Douglas cases centre on a value and criterion, and BP closing teams prepare an extension instead.</p></section>
       
-      <section class="grid" aria-label="Highlights"><article class="card"><h3>Motion analysis first</h3><p class="muted">Define the terms, name the burden and find the clashes before writing a single contention.</p></article><article class="card"><h3>Contentions that hold up</h3><p class="muted">Build each point as claim, warrant, evidence, impact and weighing, so a judge can follow it and an opponent cannot break it with one question.</p></article><article class="card"><h3>A case you can defend</h3><p class="muted">Pre-empt the obvious responses, cut what does not clash, and test the draft by attacking it yourself.</p></article></section>
-      <div class="article section"><h2>What a debate case is</h2><p>A debate case is the argument your side will defend for the whole round, organised so a judge can follow it on first hearing. It is not an essay. An essay can explore; a case has to survive an opponent whose job is to find the weakest sentence in it. That is why good cases are built from small, testable parts: a clear position, a reason the judge should decide the round your way, and two to four contentions that each prove something specific.</p><p>The process below works for every format. The format changes the length, the number of contentions and who gives which part, which the format section covers further down.</p><h2>Eight steps from motion to finished case</h2><ol><li>Read the motion word by word. Note the actor (who does it), the action (what changes) and any word that sets the strength of the claim, such as should, would, ban, regulate or prioritise. A motion about regulating something is a different debate from one about banning it.</li><li>Define the key terms in plain language. Pick definitions that are fair and that a judge would accept without argument. A squirrelled definition wins the definition debate and loses the round.</li><li>Write your burden in one sentence: what does your side have to prove for the judge to vote for you? If you are proposing a policy, you usually need to show a problem, a mechanism and a net benefit. If you are opposing, you choose whether to defend the status quo, a counter-proposal or simply that the proposal does more harm than good.</li><li>Brainstorm widely, then cut hard. List every argument for your side, group the ones that share a reason, and keep the two to four groups that are strongest and most different from each other.</li><li>Build each contention as a chain: claim (what is true), warrant (why it is true), evidence (what supports the warrant), impact (why it matters) and weighing (why it matters more than what the other side will say).</li><li>Write the framework: the standard the judge should use to decide. In <a href="/lincoln-douglas-debate">Lincoln-Douglas</a> it is a value and criterion; in most other formats it is a sentence on what the round should be about, such as who bears the cost or which outcome is more likely.</li><li>Pre-empt the most obvious response to each contention inside the contention itself. One sentence is enough. It stops the opponent&#x27;s best attack from looking new.</li><li>Write it out, read it aloud against a timer, and cut until it fits with fifteen seconds to spare.</li></ol><h2>Worked example: a full case outline</h2><div class="card"><h3>Motion: This house would make public transport free</h3><p><strong>Side:</strong> Proposition.</p><p><strong>Definitions:</strong> Public transport means buses, trams and local trains run or funded by government. Free means no fare at the point of use, paid for from general taxation.</p><p><strong>Burden:</strong> Show that removing fares produces benefits greater than the cost of replacing fare revenue.</p><p><strong>Framework:</strong> The round should be decided by who gains and who pays: a policy that shifts costs from those least able to pay towards those most able is preferable when the total benefit is comparable.</p><p><strong>Contention 1, access:</strong> Claim: fares stop low-income people from reaching jobs and services. Warrant: transport is a fixed cost that takes a larger share of a small income. Impact: removing it widens the area in which people can work and study. Pre-emption: discounted passes exist, but they require applications and proof of eligibility that many eligible people never complete.</p><p><strong>Contention 2, congestion and emissions:</strong> Claim: free fares move some journeys from cars to public transport. Warrant: price is one of the factors people weigh when choosing how to travel. Impact: fewer car journeys reduce congestion and emissions for everyone in the city.</p><p><strong>Weighing:</strong> Contention 1 is the more certain benefit and reaches the people most affected, so it leads; contention 2 is larger in scale but less certain, so it is framed as an additional reason, not the case&#x27;s foundation.</p><p><strong>Likely opposition and prepared answer:</strong> Opposition will say the money is better spent on more frequent services. The answer: frequency helps people who already ride; free fares reach people currently priced out, and the two are not mutually exclusive.</p></div><p>Notice what the outline does not contain: a long introduction, rhetorical questions or a list of statistics without warrants. Every line either defines the debate, proves something or tells the judge how to compare.</p><h2>How case structure changes by format</h2><h3>Public Forum (PF)</h3><p>A four-minute constructive usually fits two contentions, each with evidence, and sometimes a short framework. Because you often do not know your side until shortly before the round, write a case for each side and keep them consistent in style. Put pre-emption into the second constructive if you speak second.</p><h3>Lincoln-Douglas (LD)</h3><p>The case is built around a value and a criterion, followed by contentions that each show how your side meets the criterion. A weak link between contention and criterion is the first thing a good negative will attack, so state it explicitly at the end of every contention.</p><h3>British Parliamentary (BP)</h3><p>Opening Government sets the definition and, for policy motions, a model: what exactly happens, who does it and how it is enforced. Opening Opposition responds to that model. <a href="/british-parliamentary-debate">Closing teams</a> do not write a full case of their own; they prepare an extension, a new line of analysis the opening half did not cover.</p><h3>World Schools (WSDC)</h3><p>The case is split between the first and second speakers under a single team line. The first speaker gives definitions, the burden and usually the first argument; the second speaker gives the remaining arguments. Write the split before you write the arguments, so neither speaker repeats the other.</p><h2>Checklist before you call the case finished</h2><ul><li>Can you state the whole case in two sentences?</li><li>Does every contention have a warrant you could explain without your notes?</li><li>Is every piece of evidence one you have read in the original, with a full citation?</li><li>Does each contention say why it matters more than what the other side will argue?</li><li>Have you written down the strongest response to each contention, and your answer to it?</li><li>Does it fit in the time with room to slow down?</li></ul><p>If any answer is no, fix that before you practise <a href="/debate-speech-structure">delivery</a>. Polishing the speech of a case with a missing warrant only makes the gap harder to see.</p><h2>Where DebateOwl helps</h2><p>Once you have a draft, attack it before an opponent does. Paste a contention into Attack to see which link breaks first, use Brainstorm when you need more angles at step four, and use Factoids to research a single statement you want to rely on. If you would rather start from a structure, the case generator produces a draft with a thesis, framework, contentions and a predicted opposing case, which you can then cut and rewrite with the steps above.</p></div>
-      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>How many contentions should a debate case have?</summary><p>Usually two to four. Public Forum constructives often fit two; formats with longer speeches can take three or four. Fewer well-defended contentions beat many thin ones.</p></details><details><summary>What is the difference between a claim and a warrant?</summary><p>The claim is what you say is true; the warrant is the reason it is true. Judges vote on warrants, so a claim without one is an assertion that the other side can dismiss.</p></details><details><summary>How long does it take to write a debate case?</summary><p>A first draft can take an hour once you have researched the topic. Expect to revise it several times after practice rounds expose its weak points.</p></details><details><summary>Should I write my case word for word?</summary><p>In formats with prepared constructives, such as Public Forum and Lincoln-Douglas, most debaters do. In impromptu formats like BP and WSDC, prepare an outline and key lines instead.</p></details><details><summary>How do I make a case harder to attack?</summary><p>Explain every warrant, use evidence you have checked, pre-empt the most obvious response inside each contention, and attack the draft yourself before the round.</p></details></section>
+      <section class="grid" aria-label="Highlights"><article class="card"><h3>Motion analysis first</h3><p class="muted">Define the terms, write down what your side has to prove and find where the two sides disagree before writing a single argument.</p></article><article class="card"><h3>Arguments that hold up</h3><p class="muted">Build each argument as a point, an explanation, evidence and why it matters, so a judge can follow it and an opponent cannot break it with one question.</p></article><article class="card"><h3>A case you can defend</h3><p class="muted">Write &quot;If they say… we answer…&quot; replies to the obvious responses, cut what does not clash, and test the draft by attacking it yourself.</p></article></section>
+      <div class="article section"><h2>What a debate case is</h2><p>A debate case is the argument your side will defend for the whole round, organised so a judge can follow it on first hearing. It is not an essay. An essay can explore; a case has to survive an opponent whose job is to find the weakest sentence in it. That is why good cases are built from small, testable parts: an opening that tells the judge what you will prove, two to four arguments that each prove something specific, answers to what the other side will say, and a closing line the judge remembers.</p><p>The process below works for every format. The format changes the length, the number of arguments and who gives which part, which the format section covers further down.</p><h2>Eight steps from motion to finished case</h2><ol><li>Read the motion word by word. Note the actor (who does it), the action (what changes) and any word that sets the strength of the claim, such as should, would, ban, regulate or prioritise. A motion about regulating something is a different debate from one about banning it.</li><li>Define the key terms in plain language. Pick definitions that are fair and that a judge would accept without argument. A squirrelled definition wins the definition debate and loses the round.</li><li>Write down in one sentence what your side has to prove for the judge to vote for you. If you are proposing a policy, you usually need to show a problem, a mechanism and a net benefit. If you are opposing, you choose whether to defend the status quo, a counter-proposal or simply that the proposal does more harm than good.</li><li>Brainstorm widely, then cut hard. List every argument for your side, group the ones that share a reason, and keep the two to four groups that are strongest and most different from each other.</li><li>Build each argument in four parts: the point (what is true, in one sentence), the explanation (why it is true, step by step), the evidence (a source that backs it, named with its year) and why it matters (what it means for real people, and why that matters more than what the other side will say).</li><li>Write the opening: a hook that makes the judge listen, then one line that says what you will show, such as &quot;Today we will show two arguments that prove…&quot;. In <a href="/lincoln-douglas-debate">Lincoln-Douglas</a>, your value and criterion go here too.</li><li>For each argument, write down what the other side is most likely to say and a short answer: &quot;If they say…, we answer…&quot;. Put the answer to the most obvious response inside the argument itself, so the opponent&#x27;s best attack does not sound new.</li><li>Finish with a closing line that ties back to the opening and a list of your sources. Then read the case aloud against a timer and cut until it fits with fifteen seconds to spare.</li></ol><h2>Worked example: a full case outline</h2><div class="card"><h3>Motion: This house would make public transport free</h3><p><strong>Side:</strong> Proposition.</p><p><strong>Definitions:</strong> Public transport means buses, trams and local trains run or funded by government. Free means no fare at the point of use, paid for from general taxation.</p><p><strong>What we have to prove:</strong> That removing fares produces benefits greater than the cost of replacing fare revenue.</p><p><strong>Opening:</strong> For a family on a low income, the bus fare to work can be the difference between taking a job and turning it down. Today we will show two arguments that prove free public transport is worth what it costs.</p><p><strong>Argument 1, access:</strong> Point: fares stop low-income people from reaching jobs and services. Explanation: transport is a fixed cost that takes a larger share of a small income. Why it matters: removing it widens the area in which people can work and study. Answer built in: discounted passes exist, but they require applications and proof of eligibility that many eligible people never complete.</p><p><strong>Argument 2, congestion and emissions:</strong> Point: free fares move some journeys from cars to public transport. Explanation: price is one of the things people consider when choosing how to travel. Why it matters: fewer car journeys reduce congestion and emissions for everyone in the city.</p><p><strong>Order:</strong> Argument 1 is the more certain benefit and reaches the people most affected, so it goes first; argument 2 is larger in scale but less certain, so it is an additional reason, not the case&#x27;s foundation.</p><p><strong>If they say:</strong> The money is better spent on more frequent services.</p><p><strong>We answer:</strong> Frequency helps people who already ride; free fares reach people currently priced out, and the two are not mutually exclusive.</p><p><strong>Closing line:</strong> That is why free fares are the fairest way to pay for the buses a whole city depends on.</p></div><p>Notice what the outline does not contain: a long introduction, rhetorical questions or a list of statistics without explanations. Every line either defines the debate, proves something, answers the other side or tells the judge what to remember.</p><h2>How case structure changes by format</h2><h3>Public Forum (PF)</h3><p>A four-minute constructive usually fits two arguments, each with evidence, and sometimes a short framework. Because you often do not know your side until shortly before the round, write a case for each side and keep them consistent in style. Put answers to the other side into the second constructive if you speak second.</p><h3>Lincoln-Douglas (LD)</h3><p>The case is built around a value and a criterion, followed by contentions that each show how your side meets the criterion. A weak link between contention and criterion is the first thing a good negative will attack, so state it explicitly at the end of every contention.</p><h3>British Parliamentary (BP)</h3><p>Opening Government sets the definition and, for policy motions, a model: what exactly happens, who does it and how it is enforced. Opening Opposition responds to that model. <a href="/british-parliamentary-debate">Closing teams</a> do not write a full case of their own; they prepare an extension, a new line of analysis the opening half did not cover.</p><h3>World Schools (WSDC)</h3><p>The case is split between the first and second speakers under a single team line. The first speaker gives definitions, the burden and usually the first argument; the second speaker gives the remaining arguments. Write the split before you write the arguments, so neither speaker repeats the other.</p><h2>Checklist before you call the case finished</h2><ul><li>Can you state the whole case in two sentences?</li><li>Does every argument have an explanation you could give without your notes?</li><li>Is every piece of evidence one you have read in the original, with a full citation?</li><li>Does each argument say why it matters, and why that matters more than what the other side will argue?</li><li>Have you written an &quot;If they say…&quot; answer to the strongest response to each argument?</li><li>Does it fit in the time with room to slow down?</li></ul><p>If any answer is no, fix that before you practise <a href="/debate-speech-structure">delivery</a>. Polishing the speech of a case with a missing explanation only makes the gap harder to see.</p><h2>Where DebateOwl helps</h2><p>Once you have a draft, attack it before an opponent does. Paste an argument into Attack to see which link breaks first, use Brainstorm when you need more angles at step four, and use Factoids to research a single statement you want to rely on. If you would rather start from a draft, the case generator writes a ready-to-read case in the same shape: an opening, arguments with explanation, evidence and why it matters, &quot;If they say… we answer…&quot; replies, a closing line and sources. Cut and rewrite it with the steps above.</p></div>
+      <section class="section faq article" aria-labelledby="faq"><h2 id="faq">Frequently asked questions</h2><details><summary>How many contentions should a debate case have?</summary><p>Usually two to four arguments, which some formats call contentions. Public Forum constructives often fit two; formats with longer speeches can take three or four. Fewer well-defended arguments beat many thin ones.</p></details><details><summary>What is the difference between a claim and a warrant?</summary><p>The claim is what you say is true; the warrant is the reason it is true. In a case, they are the point and its explanation. Judges vote on the reasons, so a claim without one is an assertion that the other side can dismiss.</p></details><details><summary>How long does it take to write a debate case?</summary><p>A first draft can take an hour once you have researched the topic. Expect to revise it several times after practice rounds expose its weak points.</p></details><details><summary>Should I write my case word for word?</summary><p>In formats with prepared constructives, such as Public Forum and Lincoln-Douglas, most debaters do. In impromptu formats like BP and WSDC, prepare an outline and key lines instead.</p></details><details><summary>How do I make a case harder to attack?</summary><p>Explain why every point is true, use evidence you have checked, answer the most obvious response inside each argument, and attack the draft yourself before the round.</p></details></section>
     </article>
     <aside class="section article" aria-labelledby="about"><h2 id="about">About DebateOwl</h2><p><a href="/">DebateOwl</a> is an AI debate prep and practice app. See <a href="/">how it works</a> or <a href="/debateowl-pricing">pricing</a>.</p></aside>
     <section class="section article" aria-labelledby="related"><h2 id="related">Related DebateOwl guides</h2><nav class="links" aria-label="Related guides"><a href="/how-to-practice-rebuttals">How to Practice Debate Rebuttals</a>
diff --git a/public/llms.txt b/public/llms.txt
index 575a1db06..7d4bcce47 100644
--- a/public/llms.txt
+++ b/public/llms.txt
@@ -51,14 +51,14 @@ Free to use, no account needed, and they run in the browser.
 
 ## Guides
 
-- [AI Debate Practice for Stronger Cases, Rebuttals, and Speeches](https://debateowl.com/ai-debate-practice): Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and weighing.
-- [AI Debate Case Generator with Citations](https://debateowl.com/ai-debate-case-generator): DebateOwl drafts a structured debate case with claims, warrants, impacts and cited evidence leads that you check before taking it into a round.
-- [Practice Rebuttals Before Your Opponent Finds the Weakness](https://debateowl.com/debate-rebuttal-practice): Paste an opposing argument into DebateOwl to find its weak warrants, missing weighing and logic gaps, then practice the rebuttal you would give.
-- [Ask an AI Debate Coach for Round-Ready Prep](https://debateowl.com/ai-debate-coach): Ask DebateOwl's AI debate coach about strategy, case structure, weighing, rebuttals and speeches, with answers tied to your own motion and side.
-- [Find Better Debate Evidence Without Losing the Argument](https://debateowl.com/debate-evidence-finder): DebateOwl finds cited evidence leads for your debate case so you can open the original source and check the warrant before you read it in a round.
-- [Map the Clash With an Argument Flowchart](https://debateowl.com/argument-flowchart): DebateOwl turns a debate case and its rebuttals into a flowchart of claims, warrants, impacts and weighing, so you can see where the clash is.
+- [AI Debate Practice for Stronger Cases, Rebuttals, and Speeches](https://debateowl.com/ai-debate-practice): Practice debate with DebateOwl by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and speeches.
+- [AI Debate Case Generator with Citations](https://debateowl.com/ai-debate-case-generator): DebateOwl turns a motion into a ready-to-read debate case: an opening, arguments with evidence, If they say… replies, a closing line and sources to check.
+- [Practice Rebuttals Before Your Opponent Finds the Weakness](https://debateowl.com/debate-rebuttal-practice): Paste an opposing argument into DebateOwl to find its weak links, missing evidence and logic gaps, then practice the rebuttal you would give.
+- [Ask an AI Debate Coach for Round-Ready Prep](https://debateowl.com/ai-debate-coach): Ask DebateOwl's AI debate coach about strategy, arguments, rebuttals and speeches, with answers tied to your own motion, side and speaker role.
+- [Find Better Debate Evidence Without Losing the Argument](https://debateowl.com/debate-evidence-finder): DebateOwl finds cited evidence leads for your debate case so you can open the original source and check it backs your point before a round.
+- [Map the Clash With an Argument Flowchart](https://debateowl.com/argument-flowchart): DebateOwl turns a debate case and its rebuttals into a flowchart of your arguments, their attacks and your answers, so you can see where the clash is.
 - [How Debate Speech Times Work in Each Format](https://debateowl.com/online-debate-timer): Speech, cross-examination and prep times for Public Forum, Lincoln-Douglas, Policy, British Parliamentary and World Schools debate in one table.
-- [How to Write a Debate Case](https://debateowl.com/how-to-write-a-debate-case): A step-by-step guide to writing a debate case, from motion analysis and burdens to contentions with warrants, evidence, impacts and weighing.
+- [How to Write a Debate Case](https://debateowl.com/how-to-write-a-debate-case): A step-by-step guide to writing a debate case: motion analysis, an opening, arguments with evidence, answers to the other side and a closing line.
 - [How to Practice Debate Rebuttals](https://debateowl.com/how-to-practice-rebuttals): Drills for practicing debate rebuttals one skill at a time, from attacking warrants and evidence to weighing impacts and collapsing your last speech.
 - [Public Forum Debate Prep with AI](https://debateowl.com/public-forum-debate): How to prepare for Public Forum debate, with case writing, rebuttal drills, crossfire practice, summary and final focus, and evidence research.
 - [Lincoln-Douglas Debate Prep with AI](https://debateowl.com/lincoln-douglas-debate): How a Lincoln-Douglas round runs at NSDA speech times, how a value and criterion work, and a worked example case with the negative's turn against it.
diff --git a/scripts/generate_seo_content.py b/scripts/generate_seo_content.py
index 67e14028c..95d9daf79 100644
--- a/scripts/generate_seo_content.py
+++ b/scripts/generate_seo_content.py
@@ -46,14 +46,14 @@
 """.strip()
 
 PAGES = [
-    {"slug": "ai-debate-practice", "title": "AI Debate Practice | {product}", "description": "Practice debate with {product} by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and weighing.", "eyebrow": "{product} guide", "h1": "AI Debate Practice for Stronger Cases, Rebuttals, and Speeches", "lead": "Use a focused debate workspace for cases, rebuttals, sources, flowcharts, coaching, and timed practice."},
-    {"slug": "ai-debate-case-generator", "title": "AI Debate Case Generator with Citations | {product}", "description": "{product} drafts a structured debate case with claims, warrants, impacts and cited evidence leads that you check before taking it into a round.", "eyebrow": "Tool guide", "h1": "AI Debate Case Generator with Citations", "lead": "Draft faster, verify carefully, and walk into the round with a structured case."},
-    {"slug": "debate-rebuttal-practice", "title": "Debate Rebuttal Practice | {product}", "description": "Paste an opposing argument into {product} to find its weak warrants, missing weighing and logic gaps, then practice the rebuttal you would give.", "eyebrow": "Feature guide", "h1": "Practice Rebuttals Before Your Opponent Finds the Weakness", "lead": "Choose the link to attack, explain why it matters, and turn pressure into round-winning collapse."},
-    {"slug": "ai-debate-coach", "title": "AI Debate Coach | {product}", "description": "Ask {product}'s AI debate coach about strategy, case structure, weighing, rebuttals and speeches, with answers tied to your own motion and side.", "eyebrow": "Feature guide", "h1": "Ask an AI Debate Coach for Round-Ready Prep", "lead": "Get focused help with strategy, structure, weighing, rebuttals, speeches, and practice feedback."},
-    {"slug":"debate-evidence-finder","title":"Debate Evidence Finder | {product}","description":"{product} finds cited evidence leads for your debate case so you can open the original source and check the warrant before you read it in a round.","eyebrow":"Research workflow","h1":"Find Better Debate Evidence Without Losing the Argument","lead":"Use AI to locate research directions, then verify sources and connect evidence to warrants.","features":["Evidence leads","Citation checks","Impact links"],"sections":[("Evidence is not the argument",["Cards win rounds only when they support a clear warrant. A source should answer a burden, not decorate a speech.","{product} helps move from a claim to research leads, source checks, and the impact comparison the judge must evaluate."]),("Verify before you read it aloud",["Open the original source, check date and author, confirm the quote, and explain why the evidence proves your link. Never rely on an AI summary alone."]),("Connect research to clash",["The best evidence pages are tied to specific clashes: solvency, harms, tradeoffs, comparative examples, and weighing."])]},
-    {"slug":"argument-flowchart","title":"Argument Flowchart for Debate | {product}","description":"{product} turns a debate case and its rebuttals into a flowchart of claims, warrants, impacts and weighing, so you can see where the clash is.","eyebrow":"Flowing guide","h1":"Map the Clash With an Argument Flowchart","lead":"Turn cases and rebuttals into a visual map of claims, warrants, impacts, and weighing.","features":["Visual clash maps","Link chains","Weighing notes"],"sections":[("Why flowcharts help debaters",["Debate rounds become messy fast. A flowchart keeps the important relationships visible: what claim depends on which warrant, where the clash sits, and what impact comparison matters."]),("Build from the motion outward",["Start with burdens, add each contention, then connect evidence and rebuttals. If a link is missing, the map makes the gap obvious."]),("Use the map for speeches",["Before speaking, choose the path that wins the round. A good flowchart helps you collapse instead of spreading yourself thin."])]},
+    {"slug": "ai-debate-practice", "title": "AI Debate Practice | {product}", "description": "Practice debate with {product} by running timed rounds against an AI opponent and getting feedback on your cases, rebuttals and speeches.", "eyebrow": "{product} guide", "h1": "AI Debate Practice for Stronger Cases, Rebuttals, and Speeches", "lead": "Use a focused debate workspace for cases, rebuttals, sources, flowcharts, coaching, and timed practice."},
+    {"slug": "ai-debate-case-generator", "title": "AI Debate Case Generator with Citations | {product}", "description": "{product} turns a motion into a ready-to-read debate case: an opening, arguments with evidence, If they say… replies, a closing line and sources to check.", "eyebrow": "Tool guide", "h1": "AI Debate Case Generator with Citations", "lead": "Draft faster, verify carefully, and walk into the round with a case you can read out."},
+    {"slug": "debate-rebuttal-practice", "title": "Debate Rebuttal Practice | {product}", "description": "Paste an opposing argument into {product} to find its weak links, missing evidence and logic gaps, then practice the rebuttal you would give.", "eyebrow": "Feature guide", "h1": "Practice Rebuttals Before Your Opponent Finds the Weakness", "lead": "Choose the link to attack, explain why it matters, and turn pressure into round-winning collapse."},
+    {"slug": "ai-debate-coach", "title": "AI Debate Coach | {product}", "description": "Ask {product}'s AI debate coach about strategy, arguments, rebuttals and speeches, with answers tied to your own motion, side and speaker role.", "eyebrow": "Feature guide", "h1": "Ask an AI Debate Coach for Round-Ready Prep", "lead": "Get focused help with strategy, arguments, rebuttals, speeches, and practice feedback."},
+    {"slug":"debate-evidence-finder","title":"Debate Evidence Finder | {product}","description":"{product} finds cited evidence leads for your debate case so you can open the original source and check it backs your point before a round.","eyebrow":"Research workflow","h1":"Find Better Debate Evidence Without Losing the Argument","lead":"Use AI to locate research directions, then verify sources and connect evidence to warrants.","features":["Evidence leads","Citation checks","Impact links"],"sections":[("Evidence is not the argument",["Cards win rounds only when they support a clear warrant. A source should answer a burden, not decorate a speech.","{product} helps move from a claim to research leads, source checks, and the impact comparison the judge must evaluate."]),("Verify before you read it aloud",["Open the original source, check date and author, confirm the quote, and explain why the evidence proves your link. Never rely on an AI summary alone."]),("Connect research to clash",["The best evidence pages are tied to specific clashes: solvency, harms, tradeoffs, comparative examples, and weighing."])]},
+    {"slug":"argument-flowchart","title":"Argument Flowchart for Debate | {product}","description":"{product} turns a debate case and its rebuttals into a flowchart of your arguments, their attacks and your answers, so you can see where the clash is.","eyebrow":"Flowing guide","h1":"Map the Clash With an Argument Flowchart","lead":"Turn cases and rebuttals into a visual map of arguments, attacks, and answers.","features":["Visual clash maps","Link chains","Weighing notes"],"sections":[("Why flowcharts help debaters",["Debate rounds become messy fast. A flowchart keeps the important relationships visible: what claim depends on which warrant, where the clash sits, and what impact comparison matters."]),("Build from the motion outward",["Start with burdens, add each contention, then connect evidence and rebuttals. If a link is missing, the map makes the gap obvious."]),("Use the map for speeches",["Before speaking, choose the path that wins the round. A good flowchart helps you collapse instead of spreading yourself thin."])]},
     {"slug":"online-debate-timer","title":"Debate Speech Times by Format | {product}","description":"Speech, cross-examination and prep times for Public Forum, Lincoln-Douglas, Policy, British Parliamentary and World Schools debate in one table.","eyebrow":"Timing guide","h1":"How Debate Speech Times Work in Each Format","lead":"Speech lengths, cross-examination and prep time for the main formats, and how to practise against the clock.","tool":("Open the free debate timer","/tools/debate-timer"),"features":["Speech timing","Prep drills","Pacing feedback"],"sections":[("Timing changes strategy",["A great argument can still lose if it arrives too late or takes too long. Timed practice forces you to pick the strongest material."]),("Drill one skill at a time",["Use short timers for rebuttal blocks, longer timers for full speeches, and prep timers to simulate tournament pressure."]),("Pair timing with feedback",["After each timed speech, use {product} to identify unclear structure, missing weighing, and the next drill to repeat."])]},
-    {"slug":"how-to-write-a-debate-case","title":"How to Write a Debate Case | {product}","description":"A step-by-step guide to writing a debate case, from motion analysis and burdens to contentions with warrants, evidence, impacts and weighing.","eyebrow":"How-to guide","h1":"How to Write a Debate Case","lead":"Move from motion analysis to contentions, warrants, evidence, impacts, and weighing.","features":["Motion analysis","Contention structure","Weighing"],"sections":[("Start with burdens",["Before writing contentions, define what your side must prove. A case that misses the burden can sound polished and still lose."]),("Write contentions as reasoning chains",["Each contention should connect claim, warrant, evidence, impact, and weighing. If one piece is missing, mark it before you practice."]),("Pressure-test the draft",["Use {product} to attack your own case. The strongest final version usually comes after finding the easiest rebuttals first."])]},
+    {"slug":"how-to-write-a-debate-case","title":"How to Write a Debate Case | {product}","description":"A step-by-step guide to writing a debate case: motion analysis, an opening, arguments with evidence, answers to the other side and a closing line.","eyebrow":"How-to guide","h1":"How to Write a Debate Case","lead":"Move from motion analysis to an opening, arguments with evidence, answers to the other side, and a closing line.","features":["Motion analysis","Contention structure","Weighing"],"sections":[("Start with burdens",["Before writing contentions, define what your side must prove. A case that misses the burden can sound polished and still lose."]),("Write contentions as reasoning chains",["Each contention should connect claim, warrant, evidence, impact, and weighing. If one piece is missing, mark it before you practice."]),("Pressure-test the draft",["Use {product} to attack your own case. The strongest final version usually comes after finding the easiest rebuttals first."])]},
     {"slug":"how-to-practice-rebuttals","title":"How to Practice Debate Rebuttals | {product}","description":"Drills for practicing debate rebuttals one skill at a time, from attacking warrants and evidence to weighing impacts and collapsing your last speech.","eyebrow":"How-to guide","h1":"How to Practice Debate Rebuttals","lead":"Build sharper responses by attacking warrants, evidence, impacts, and weighing one drill at a time.","features":["Rebuttal drills","Cross-ex questions","Collapse practice"],"sections":[("Do not rebut everything",["Good rebuttal practice teaches selection. Answer the argument that determines the round, not every sentence your opponent says."]),("Use repeatable drills",["Run separate drills for weak warrants, missing examples, evidence quality, impact defense, and comparative weighing."]),("Turn attacks into speeches",["After finding objections, practice explaining them under time. The goal is a clean speech, not a long list of notes."])]},
     {"slug": "public-forum-debate", "title": "Public Forum Debate Prep | {product}", "description": "How to prepare for Public Forum debate, with case writing, rebuttal drills, crossfire practice, summary and final focus, and evidence research.", "eyebrow": "Format guide", "h1": "Public Forum Debate Prep with AI", "lead": "Practice PF cases, rebuttals, crossfire, summary, and final focus with AI feedback.", "features": ["PF case building", "Crossfire prep", "Summary and final focus"], "sections": [["How PF cases work", ["A PF case has two contentions, each with a claim, warrant, impact, and evidence. The strongest cases also include pre-emption and weighing from the constructive.", "{product} helps you draft, attack, and refine PF cases before the round."]], ["Crossfire and rebuttal practice", ["Crossfire exposes weak warrants and missing evidence. Use {product} to generate likely crossfire questions and practice ten-second rebuttal blocks."]], ["Summary and final focus", ["The best summaries collapse to the winning argument. Practice selecting the right clash and framing the ballot for the judge."]]]},
     {"slug": "lincoln-douglas-debate", "title": "Lincoln-Douglas Debate: Value and Criterion | {product}", "modified": "2026-10-23", "description": "How a Lincoln-Douglas round runs at NSDA speech times, how a value and criterion work, and a worked example case with the negative's turn against it.", "eyebrow": "Format guide", "h1": "Lincoln-Douglas Debate Prep with AI", "lead": "Build LD cases with values, criteria, contentions, and rebuttal blocks.", "features": ["Value and criterion structure", "LD case writing", "Cross-examination prep"], "sections": [["Values and criteria", ["LD is a value debate. Your value tells the judge what matters; your criterion measures whether you achieve it. {product} helps you test whether your criterion actually links to your value."]], ["Case structure for LD", ["A strong LD case has an opening quote, definitions, value, criterion, and contentions with warrants and impacts. Use {product} to draft and pressure-test each piece.", "Paste the written case into the [speech time calculator](/tools/speech-time-calculator) to check that it fits the six-minute affirmative or seven-minute negative constructive."]], ["Cross-examination and rebuttal", ["Cross-ex in LD exposes weak links between value and criterion. Practice generating likely CX questions and building rebuttal blocks for common LD arguments."]]]},
diff --git a/scripts/seo_answers.py b/scripts/seo_answers.py
index 14f0da65e..d3fc1f88f 100644
--- a/scripts/seo_answers.py
+++ b/scripts/seo_answers.py
@@ -18,7 +18,7 @@
     ),
     "debateowl-vs-chatgpt": (
         "Which is better for debate prep, {product} or ChatGPT?",
-        "It depends on the task. ChatGPT is better for learning a new topic, open brainstorming and general writing help, and it works for any subject. {product} is better when you are preparing a specific motion: it keeps your cases, sources and practice rounds together, predicts the opposing case, times your speeches and gives a verdict on practice rounds. Many debaters use both, ChatGPT for background and {product} for motion prep and practice. Neither replaces checking original sources.",
+        "It depends on the task. ChatGPT is better for learning a new topic, open brainstorming and general writing help, and it works for any subject. {product} is better when you are preparing a specific motion: it keeps your cases, sources and practice rounds together, drafts answers to what the other side will say, times your speeches and gives a verdict on practice rounds. Many debaters use both, ChatGPT for background and {product} for motion prep and practice. Neither replaces checking original sources.",
     ),
     "debateowl-vs-windebate": (
         "Which is better, {product} or WinDebate?",
@@ -34,7 +34,7 @@
     ),
     "ai-debate-case-generator": (
         "Can an AI debate case generator write a case I can actually use?",
-        "Yes, as a draft. {product}'s case generator turns a motion into a structured case (thesis, framework, contentions with warrants and impacts, the likely opposing case and counters) and lists the web sources it used, which you then verify and rewrite in your own words. Treat its citations as research leads: open every source and confirm the exact claim. The judgement calls, such as which contention to cut and where to pre-empt the opposition, stay with you.",
+        "Yes, as a draft. {product}'s case generator turns a motion into a ready-to-read case: an opening, arguments with explanation, evidence and why it matters, \"If they say… we answer…\" replies, a closing line and the sources it used. You then verify it and rewrite it in your own words. Treat its citations as research leads: open every source and confirm the exact claim. The judgement calls, such as which argument to cut and where to answer the opposition early, stay with you.",
     ),
     "debate-rebuttal-practice": (
         "How do you find the weak link in an argument you need to rebut?",
@@ -42,7 +42,7 @@
     ),
     "ai-debate-coach": (
         "Can an AI debate coach actually help you prepare?",
-        "Yes. {product}'s Ask coach is an AI debate coach that answers specific prep questions about burdens, clash, weighing and speech structure, and gives feedback on practice speeches; it works best when you name the format, side and speaker role. Vague questions get generic answers. Treat any sources it cites as leads to check. An AI coach has not watched you speak and does not know your judges or your partner, so take its conclusions to your human coach or team.",
+        "Yes. {product}'s Ask coach is an AI debate coach that answers specific prep questions about what your side has to prove, which argument decides the round and how to structure a speech, and gives feedback on practice speeches; it works best when you name the format, side and speaker role. Vague questions get generic answers. Treat any sources it cites as leads to check. An AI coach has not watched you speak and does not know your judges or your partner, so take its conclusions to your human coach or team.",
     ),
     "debate-evidence-finder": (
         "Can AI find reliable evidence for a debate case?",
@@ -50,7 +50,7 @@
     ),
     "argument-flowchart": (
         "When is an argument flowchart useful for debate prep?",
-        "It is useful before and after a round, not during one. A flowchart maps your thesis, your arguments, the attacks on them and your rebuttals, so you can see which link breaks a chain and where two contentions rely on the same assumption. Build it from the motion outward, add the strongest attack to each contention, and note the weighing at each clash. During the round itself, a written flow on paper or a laptop is faster than any canvas, so keep your in-round notes there and use the map to plan and review.",
+        "It is useful before and after a round, not during one. A flowchart maps your case's main line, your arguments, the attacks on them and your answers, so you can see which link breaks a chain and where two arguments rely on the same assumption. Build it from the motion outward, add the strongest attack to each argument, and note at each clash why your side matters more. During the round itself, a written flow on paper or a laptop is faster than any canvas, so keep your in-round notes there and use the map to plan and review.",
     ),
     "online-debate-timer": (
         "How long are debate speeches in each format?",
@@ -58,7 +58,7 @@
     ),
     "how-to-write-a-debate-case": (
         "How do you write a debate case?",
-        "Start with the motion, not the arguments. Read it word by word, define the key terms fairly and write your burden in one sentence. Brainstorm widely, then keep two to four contentions, each built as claim, warrant, evidence, impact and weighing. Add a framework telling the judge how to decide, pre-empt the obvious response inside each contention, and read the case aloud against a timer until it fits. The format changes the details: Public Forum constructives usually fit two contentions, Lincoln-Douglas cases centre on a value and criterion, and BP closing teams prepare an extension instead.",
+        "Start with the motion, not the arguments. Define the key terms fairly and write down in one sentence what your side has to prove. Keep two to four arguments, each with a point, an explanation, evidence and why it matters. Open with a hook and what you will show, add \"If they say… we answer…\" replies, end on a closing line, and time a reading aloud. The format changes the details: Public Forum constructives usually fit two arguments, Lincoln-Douglas cases centre on a value and criterion, and BP closing teams prepare an extension instead.",
     ),
     "how-to-practice-rebuttals": (
         "What is the best way to practise debate rebuttals?",
diff --git a/scripts/seo_guides.py b/scripts/seo_guides.py
index f1ade1efb..ecb305068 100644
--- a/scripts/seo_guides.py
+++ b/scripts/seo_guides.py
@@ -10,7 +10,7 @@
 
 GUIDES = {
     "ai-debate-practice": {
-        "modified": "2026-10-26",
+        "modified": "2026-10-28",
         "features": [
             ("Practice against AI opponents", "Run a full Sparring round in School 4-6-6-3, Lincoln-Douglas or Public Forum, type or speak each speech, and finish with a judged verdict."),
             ("Turn feedback into drills", "Take the weakest point from a verdict or a Crossfire debrief, rebuild it with Attack or Ask, and run that speech again."),
@@ -27,7 +27,7 @@
                 {"steps": [
                     "Start a Current Debate with the motion written exactly as it will be announced (2 minutes). Add any articles or notes you already trust to the Library so later answers are grounded in them.",
                     "Run Brainstorm on the motion and pick the two or three angles you can explain in one sentence each (5 minutes). Discard angles that need evidence you do not have.",
-                    "Generate a case for your side (10 minutes). Read the predicted opponent case before your own contentions: it tells you what you will have to answer.",
+                    "Generate a case for your side (10 minutes). Read its \"If they say…\" answers before your own arguments: they tell you what you will have to answer.",
                     "Run a Sparring round in your format (15 minutes). Give every speech in full, at time, without pausing to edit. Voice mode lets you speak instead of type.",
                     "Read the verdict and write down the single reason it gives for the decision (3 minutes).",
                     "Rebuild only that part (5 minutes): ask Attack to stress-test the rewritten argument, or regenerate the one case section that failed.",
@@ -38,10 +38,10 @@
             ("Worked example: one practice round", [
                 {"example": {"title": "Motion: This house would ban smartphones in secondary schools", "rows": [
                     ("Side and format:", "Proposition, run as a School 4-6-6-3 Sparring round."),
-                    ("First contention:", "Phones fragment attention in class, and attention is the input every other kind of learning depends on."),
+                    ("First argument:", "Phones fragment attention in class, and attention is the input every other kind of learning depends on."),
                     ("AI opponent's response:", "Schools already confiscate phones during lessons, so a ban changes only break times, where the harm you described does not happen."),
                     ("What the verdict flagged:", "Proposition never explained what a ban adds over existing classroom rules, so the opposition's mitigation stood unanswered."),
-                    ("The drill:", "Ask Attack to find the gap in the contention, then rewrite it around breaks: social exclusion, cyberbullying during the school day, and the cost of teachers enforcing rules lesson by lesson."),
+                    ("The drill:", "Ask Attack to find the gap in the argument, then rewrite it around breaks: social exclusion, cyberbullying during the school day, and the cost of teachers enforcing rules lesson by lesson."),
                     ("Second attempt:", "The R1 speech now opens with the comparison: classroom rules depend on every teacher enforcing them every hour, while a ban sets one rule at the school gate. The opponent's mitigation becomes a point in your favour."),
                 ]}},
                 "The example shows the pattern to look for. The first version was not wrong; it was incomplete in a way only a responsive opponent exposes. That is the gap AI practice fills between team practices.",
@@ -69,7 +69,7 @@
             ("AI vs traditional prep", [
                 "AI and traditional preparation are good at different parts of the work. AI is fast at structure; reading, coaching and real rounds are where judgement comes from. Most strong debaters use both and give each the tasks it does well.",
                 {"table": {"head": ["Task", "AI does it well", "Traditional prep does it better"], "rows": [
-                    ["First case outline", "Drafts claims, warrants and a predicted opponent case in minutes", "Choosing which outline fits your team and your circuit"],
+                    ["First case outline", "Drafts an opening, arguments with evidence and \"If they say…\" answers in minutes", "Choosing which outline fits your team and your circuit"],
                     ["Rebuttal blocks", "Lists likely arguments and first-draft answers", "Testing answers against opponents you have actually met"],
                     ["Research", "Suggests evidence leads and search directions", "Reading the original source, checking dates and context"],
                     ["Practice rounds", "A responsive opponent at any hour, at real speech times", "Unpredictable opponents, panels and live crossfire"],
@@ -91,10 +91,10 @@
         ],
     },
     "ai-debate-coach": {
-        "modified": "2026-10-27",
-        "definition": ("What is an AI debate coach?", "AI debate coach", "A chat tool that answers a debater's prep questions about burdens, clash, weighing and speech structure and gives feedback on practice speeches, for the debater to test and adapt."),
+        "modified": "2026-10-28",
+        "definition": ("What is an AI debate coach?", "AI debate coach", "A chat tool that answers a debater's prep questions about strategy, arguments, answers to the other side and speech structure, and gives feedback on practice speeches, for the debater to test and adapt."),
         "features": [
-            ("Strategy help", "Ask which clash decides the round, what your burden is and where to spend your speaking time, with answers that use your debate's motion and sources."),
+            ("Strategy help", "Ask which argument decides the round, what your side has to prove and where to spend your speaking time, with answers that use your debate's motion and sources."),
             ("Speech structure", "Get an outline for a constructive, rebuttal, summary or reply speech: the order of points and how long to give each one."),
             ("Practice feedback", "Paste a speech or a flow and ask what was unclear, under-warranted or dropped, then pick one fix to drill."),
         ],
@@ -148,7 +148,7 @@
             ]),
         ],
         "faqs": [
-            ("What can I ask the AI debate coach?", "Anything you would ask a coach between rounds: burdens, clash, weighing, speech structure, how to answer a specific argument, or why a practice speech did not land. Specific questions with format, side and speaker role get the best answers."),
+            ("What can I ask the AI debate coach?", "Anything you would ask a coach between rounds: what your side has to prove, which argument decides the round, speech structure, how to answer a specific argument, or why a practice speech did not land. Specific questions with format, side and speaker role get the best answers."),
             ("Does the coach know my case?", "It knows your Current Debate: the motion, and the Library sources you have marked active. Paste a speech or a case section into the question when you want feedback on that exact text."),
             ("Can the AI coach cite sources?", "Yes. Turn on Citations in Ask and the answer includes sources you can open. Check each one against the original before using it in a round."),
             ("Will the coach write my speeches for me?", "It can draft an outline or a passage, but you will speak better from structure you understand. Use it to find what is missing, then write the speech in your own words."),
@@ -158,58 +158,58 @@
         ],
     },
     "ai-debate-case-generator": {
-        "modified": "2026-10-27",
-        "definition": ("What is an AI debate case generator?", "AI debate case generator", "A tool that drafts a debate case for a given motion and side, with claims, warrants, impacts and evidence leads, for a debater to verify and adapt."),
+        "modified": "2026-10-28",
+        "definition": ("What is an AI debate case generator?", "AI debate case generator", "A tool that turns a motion into a draft debate case for one side and speaker role, with an opening, arguments backed by evidence, answers to what the other side will say and a source list, for a debater to verify and adapt."),
         "features": [
-            ("Structured case drafts", "Each draft has a thesis, a framework, contentions with warrants and impacts, the case the other side is likely to run, and counters to it."),
-            ("Evidence leads", "Every draft is researched on the web and lists the sources it found. Check each one against the original before it goes on a card."),
+            ("A case you can read out", "Each draft has an opening, arguments with an explanation, evidence and why it matters, \"If they say… we answer…\" replies, a closing line and the sources it cites."),
+            ("Evidence leads", "Every draft is researched on the web, names the source and year in each piece of evidence and lists its sources at the end. Check each one against the original before it goes on a card."),
             ("Roles and length", "Pick your side and speaker role, then set the case length, the audience level and the tone of the draft."),
         ],
         "sections": [
             ("What the case generator produces", [
-                "Generate takes the motion from your Current Debate and returns a structured case, not a block of prose. Every draft has the same parts, so you always know where to look:",
+                "Generate takes the motion from your Current Debate and returns a case you can read out, not a block of prose. Every draft has the same parts, in the order you would say them:",
                 {"list": [
-                    "Thesis: the one-sentence reason your side should win.",
-                    "Framework: how the judge should decide the round, such as the definition, the burden or the weighing standard you will argue for.",
-                    "Contentions: each with a claim, the warrant that makes it true, and the impact that makes it matter.",
-                    "Predicted opponent case: the arguments a strong team on the other side is likely to run.",
-                    "Counters: first responses to that predicted case.",
+                    "Opening: a hook that makes the judge listen, then the line \"Today we will show N arguments that prove…\".",
+                    "Arguments: each with a short title, the point in one sentence, an explanation of why it is true, evidence that names its source and year, and why it matters.",
+                    "If they say…: the claims the other side is likely to make, each with our answer and, when there is one, the source behind it.",
+                    "Closing line: one sentence that ties back to the opening.",
+                    "Sources: every source the case cites, with the organisation, the year, the claim it supports and the link.",
                 ]},
-                "Because the opponent case is part of the draft, you start preparing rebuttals at the same time as your own case. When one section is weak, regenerate just that section; the rest of the case stays where it is. Finished cases export to PDF or DOCX.",
+                "Your speaker role shapes the speech. The introductor gets the opening and short headline arguments, plus one line on what a motion term means when it is genuinely unclear. R1 gets the full arguments. R2 brings no new arguments: it spends about two minutes backing up the team's arguments, then answers the other side with five or six \"If they say…\" blocks. The conclusor brings no new arguments: it gets two or three reasons why your side won and the closing line.",
+                "Because the answers to the other side are part of the draft, you start preparing rebuttals at the same time as your own case. When one section is weak, regenerate just that section; the rest of the case stays where it is. Finished cases export to PDF or DOCX.",
             ]),
             ("Generated draft vs. finished case: what you still do", [
                 {"table": {"caption": "What the case generator gives you, and what you check before the round", "head": ["Section", "The generator gives", "You check"], "rows": [
-                    ["Thesis", "One sentence on why your side should win", "That it answers the motion exactly as worded and you can say it without notes"],
-                    ["Framework", "The definition, burden or weighing standard to argue for", "That it fits your format, for example a value and criterion in Lincoln-Douglas"],
-                    ["Contentions", "A claim, the warrant that makes it true and the impact that makes it matter", "Which ones clash with the other side; cut the rest to fit your speech time"],
-                    ["Predicted opponent case", "The arguments a strong team on the other side is likely to run", "Which of your contentions answers each one"],
-                    ["Counters", "First responses to the predicted case", "That each response is short enough to deliver as a rebuttal block"],
-                    ["Sources", "The web sources it found, with contentions that still need evidence marked Needs Source", "Open every original, confirm the exact claim and record the full citation"],
+                    ["Opening", "A hook and the line \"Today we will show N arguments that prove…\"", "That the hook is true, the line answers the motion exactly as worded and you can say it without notes"],
+                    ["Arguments", "A title, the point, an explanation, evidence and why it matters", "Which ones meet what the other side will say; cut the rest to fit your speech time"],
+                    ["If they say…", "The other side's likely claims, each with our answer", "That each answer meets the claim as they would make it and is short enough to say in a rebuttal"],
+                    ["Closing line", "One sentence that ties back to the opening", "That it sums up the case in words you would actually say"],
+                    ["Sources", "Every source the case cites, with arguments that still need evidence marked Needs Source", "Open every original, confirm the exact claim and record the full citation"],
                 ]}},
             ]),
             ("From motion to verified case in seven steps", [
                 {"steps": [
                     "Start a Current Debate with the exact motion wording. Small wording changes, such as should against would, change the burden.",
                     "Add the sources you already trust to the Library. Active sources are used when the case is generated, so the draft builds on your research instead of ignoring it.",
-                    "Choose your side and speaker role: introductor, R1, R2 or conclusor. Under More options, set the length (two, three or four contentions), the audience level and the tone. If you need a particular angle, for example a principled argument or an economic one, put it in the Current Debate's Instructions.",
+                    "Choose your side and speaker role: introductor, R1, R2 or conclusor. Under More options, set the length, the audience level and the tone. Length sets two, three or four arguments for the introductor and R1, and for R2 how many \"If they say…\" answers you get. If you need a particular angle, for example a principled argument or an economic one, put it in the Current Debate's Instructions.",
                     "Generate the case. Generate researches the motion on the web every time, lists the sources it found under the draft, and saves the relevant ones to the debate's Library.",
-                    "Read the predicted opponent case first and decide which of your contentions actually answers it. Cut contentions that do not clash with anything.",
+                    "Read the \"If they say…\" answers first and decide which of your arguments actually meets each claim. Cut arguments that do not clash with anything.",
                     "Regenerate any section that is vague, then verify every evidence lead against its original source.",
                     "Rewrite the final case in your own words and time a full reading of it before you call it ready.",
                 ]},
             ]),
             ("Worked example: a generated case, and what the debater changed", [
                 {"example": {"title": "Motion: This house would introduce a four-day school week", "rows": [
-                    ("Side:", "Proposition."),
-                    ("Thesis:", "A shorter week concentrates instruction where it works and gives schools a recruitment advantage they cannot buy with pay."),
-                    ("Framework:", "The round should be decided by learning outcomes for students across the school, not by the convenience of any single group."),
-                    ("Contention 1:", "Teacher retention. Claim: a four-day week keeps experienced teachers. Warrant: schools competing for staff cannot always raise salaries, but they can offer time. Impact: experienced teachers are among the strongest in-school drivers of student learning."),
-                    ("Predicted opposition:", "Childcare costs for working parents on the fifth day, and lost instruction time for students who are already behind."),
-                    ("Counter:", "Schools can run an optional fifth-day programme for families who need it, and longer remaining days protect total instruction hours."),
+                    ("Side and role:", "Proposition, R1."),
+                    ("Opening:", "A school that cannot pay more can still offer its teachers time. Today we will show two arguments that prove a four-day week helps students learn."),
+                    ("Argument 1, keeping teachers:", "Point: a four-day week keeps experienced teachers. Explanation: schools competing for staff cannot always raise salaries, but they can offer time. Why it matters: experienced teachers are among the strongest in-school drivers of student learning."),
+                    ("If they say:", "Working parents will pay for childcare on the fifth day, and students who are already behind lose teaching time."),
+                    ("We answer:", "Schools can run an optional fifth-day programme for families who need it, and longer remaining days protect total teaching hours."),
+                    ("Closing line:", "That is why a four-day week is the cheapest way to keep the teachers students learn most from."),
                     ("Evidence lead to verify:", "Research on districts that moved to four-day weeks, looking at attendance, teacher turnover and test results. Read the methodology: results differ between rural and urban districts."),
-                    ("What the debater changed:", "Cut a weaker cost-saving contention the opposition would easily mitigate, and moved the instruction-hours counter into the first speech so it was on the table before the opposition raised it."),
+                    ("What the debater changed:", "Cut a weaker cost-saving argument the opposition would easily answer, and moved the teaching-hours answer into the first speech so it was on the table before the opposition raised it."),
                 ]}},
-                "The draft gave the debater a full structure in minutes. The judgement calls, which contention to cut and where to pre-empt the opposition, were still theirs, and that is where the round was won.",
+                "The draft gave the debater a full structure in minutes. The judgement calls, which argument to cut and where to answer the opposition early, were still theirs, and that is where the round was won.",
             ]),
             ("Checking citations before they reach a card", [
                 "Generated evidence is a starting point. Before any source goes into a speech:",
@@ -217,44 +217,44 @@
                     "Open the original. If you cannot find it, do not use it.",
                     "Find the exact sentence that supports your claim, and check that the surrounding paragraph does not qualify it.",
                     "Check the date, the author and who published it. A think-tank brief and a peer-reviewed study carry different weight.",
-                    "Make sure the evidence supports your link, not just your topic. A study showing four-day weeks save money does not prove they improve learning.",
+                    "Make sure the evidence supports your point, not just your topic. A study showing four-day weeks save money does not prove they improve learning.",
                     "Record the full citation so you can produce it if an opponent or judge asks.",
                 ]},
                 "Factoids is useful here: give it a single statement from your case and it researches that statement and suggests searches you can use to confirm it.",
             ]),
             ("Adapting a generated case to your format", [
                 {"h3": "World Schools (WSDC)"},
-                "A WSDC case is split between the first and second speakers, with a team line both can repeat. Use the thesis as the team line, give the first speaker the framework and the first contention, and keep the strongest contention for the second speaker so the case builds rather than front-loads. Leave the Current Debate's format on Custom and describe this split in its Instructions.",
+                "A WSDC case is split between the first and second speakers, with a team line both can repeat. Use the opening's \"we will show\" line as the team line, give the first speaker the opening and the first argument, and keep the strongest argument for the second speaker so the case builds rather than front-loads. Leave the Current Debate's format on Custom and describe this split in its Instructions.",
                 {"h3": "British Parliamentary (BP)"},
-                "Set the Current Debate's format to British Parliamentary and name your team position in its Instructions; Generate's own role options follow the School 4-6-6-3 speakers. Opening government needs a clear definition and mechanism in the draft. Closing teams should treat the generated case as material the opening half will probably use, and look in the predicted opponent case for an extension nobody else in the room is likely to run.",
+                "Set the Current Debate's format to British Parliamentary and name your team position in its Instructions; Generate's own role options follow the School 4-6-6-3 speakers. Opening government needs a clear definition and mechanism, so describe them in the Instructions if the draft does not give them. Closing teams should treat the generated case as material the opening half will probably use, and look in the \"If they say…\" answers for an extension nobody else in the room is likely to run.",
                 {"h3": "Public Forum (PF)"},
-                "A PF constructive is four minutes, which usually means two contentions with evidence, not four. Since PF teams often find out their side shortly before the round, generate both sides of the resolution in the same debate and prepare the counters for each.",
+                "A PF constructive is four minutes, which usually means two arguments with evidence, not four. Since PF teams often find out their side shortly before the round, generate both sides of the resolution in the same debate and prepare the answers for each.",
                 {"h3": "Lincoln-Douglas (LD)"},
-                "In LD, the framework section becomes your value and criterion. Check that every contention explicitly links back to the criterion; if one does not, add your criterion to the Current Debate's Instructions and regenerate the contentions. Prepare a short defence of the criterion itself, because the negative will often attack it first.",
+                "Generate does not write a value and criterion for you, so put yours in the Current Debate's Instructions before you generate. Then check that each argument's why it matters links back to the criterion; if one does not, regenerate the arguments. Prepare a short defence of the criterion itself, because the negative will often attack it first.",
             ]),
             ("Mistakes to avoid with generated cases", [
                 {"list": [
                     "Reading the draft in round. Judges hear the difference between a case you wrote and one you are reading for the first time.",
-                    "Keeping every contention. Three well-defended points beat five thin ones.",
-                    "Skipping the predicted opponent case. It is the fastest route to your rebuttals.",
+                    "Keeping every argument. Three well-defended points beat five thin ones.",
+                    "Skipping the \"If they say…\" answers. They are the fastest route to your rebuttals.",
                     "Citing an evidence lead you never opened.",
                 ]},
             ]),
         ],
         "faqs": [
-            ("Does the case generator write a complete case?", "It writes a complete draft: thesis, framework, contentions with warrants and impacts, the likely opposing case and counters. Treat it as a structure to cut, verify and rewrite in your own words."),
-            ("Are the generated citations reliable?", "They are research leads. Every draft is researched on the web and lists the sources it found, and a contention that still needs evidence is marked Needs Source. Open every source, confirm the exact claim and record the full citation before using it."),
+            ("Does the case generator write a complete case?", "It writes a complete draft: an opening, arguments with explanation, evidence and why each matters, \"If they say… we answer…\" replies, a closing line and the sources it cites. Treat it as a structure to cut, verify and rewrite in your own words."),
+            ("Are the generated citations reliable?", "They are research leads. Every draft is researched on the web and lists the sources it cites, and an argument that still needs evidence is marked Needs Source. Open every source, confirm the exact claim and record the full citation before using it."),
             ("Which debate formats does the generator support?", "Set the Current Debate's format to British Parliamentary, Policy, Classroom or Custom, and Generate reads it along with the debate's Instructions. Generate's own speaker roles (introductor, R1, R2 and conclusor) follow the School 4-6-6-3 format. For WSDC, Public Forum and Lincoln-Douglas, use Custom and describe the structure in the Instructions."),
             ("Can I change one part of a case without starting over?", "Yes. Regenerate a single section and the rest of the case stays on screen unchanged."),
             ("Can I export a generated case?", "Yes. Cases export to PDF and DOCX, and cases created in a Current Debate are saved to it automatically."),
             ("Is there a free AI debate case generator?", "{product}'s case generator is included in the 3-day free trial, with no credit card, and then in Pro at {pro_price}; there is no permanent free plan. Without an account you can use the free debate timer, motion generator, flow sheet and speech time calculator, but not the case generator."),
-            ("Can AI write a Public Forum case?", "It can draft one. Set the Current Debate's format to Custom and describe the Public Forum structure in its Instructions, since Generate's own speaker roles follow School 4-6-6-3. A PF constructive is four minutes, which usually fits two contentions with evidence, so cut the draft to that and verify every source."),
-            ("Is using an AI case generator cheating?", "Using it to draft and research before a round is preparation, but check your league's and your school's rules first: most leagues forbid electronic help during a round. Verify every source, rewrite the case in your own words and make sure you can defend each contention, because a case you cannot explain is easy to beat."),
+            ("Can AI write a Public Forum case?", "It can draft one. Set the Current Debate's format to Custom and describe the Public Forum structure in its Instructions, since Generate's own speaker roles follow School 4-6-6-3. A PF constructive is four minutes, which usually fits two arguments with evidence, so cut the draft to that and verify every source."),
+            ("Is using an AI case generator cheating?", "Using it to draft and research before a round is preparation, but check your league's and your school's rules first: most leagues forbid electronic help during a round. Verify every source, rewrite the case in your own words and make sure you can defend each argument, because a case you cannot explain is easy to beat."),
         ],
     },
     "best-ai-debate-tools": {
         "software": True,
-        "modified": "2026-10-21",
+        "modified": "2026-10-28",
         "features": [
             ("Feature comparison", "What each kind of tool does well: general chatbots, research assistants, dedicated debate platforms, and timers or flowing tools."),
             ("Format coverage", "Which formats a tool actually models, from Public Forum and Lincoln-Douglas to WSDC and British Parliamentary, and where you still prep by hand."),
@@ -317,7 +317,7 @@
                 "LD needs tools that handle value and criterion, not just policy arguments. Test whether a tool can defend a framework and link contentions to it, and whether it can practise the time-pressured 1AR.",
             ]),
             ("Where {product} fits", [
-                "{product} is a dedicated debate platform that keeps every case, source, round and debrief inside one Current Debate. It covers case generation with a predicted opponent case, Library sources that ground its answers, Attack for finding weak links, Brainstorm, Factoids for checking claims, an Ask coaching chat with optional citations, Crossfire and full Sparring rounds with a verdict, a speech timer and an argument flowchart.",
+                "{product} is a dedicated debate platform that keeps every case, source, round and debrief inside one Current Debate. It covers case generation with \"If they say…\" answers to the other side, Library sources that ground its answers, Attack for finding weak links, Brainstorm, Factoids for checking claims, an Ask coaching chat with optional citations, Crossfire and full Sparring rounds with a verdict, a speech timer and an argument flowchart.",
                 "Its limits are worth stating plainly. Sparring currently runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, so WSDC and BP practice uses the prep and coaching tools rather than a full simulated round. Like every AI tool, its evidence leads need checking against the original source. Run the one-hour test above and decide on your own results.",
             ]),
         ],
@@ -331,7 +331,7 @@
         ],
     },
     "debate-rebuttal-practice": {
-        "modified": "2026-10-21",
+        "modified": "2026-10-28",
         "features": [
             ("Find weak warrants", "Paste an argument into Attack and get the links that fail: missing warrants, overclaimed impacts and assumptions the other side never proved."),
             ("Build targeted blocks", "Each weakness comes with why it is weak, how the other side will attack it and a stronger version. Turn that into a short block; the analysis stays in your Current Debate."),
@@ -351,7 +351,7 @@
             ]),
             ("A 20-minute rebuttal drill", [
                 {"steps": [
-                    "Choose one opposing argument you expect to face. If you have generated a case, take it from the predicted opponent case.",
+                    "Choose one opposing argument you expect to face. If you have generated a case, take it from its \"If they say…\" answers.",
                     "Paste it into Attack and read the weaknesses it finds. Pick the one that breaks the argument, not the one that is easiest to say.",
                     "Write a block: a five-word tag line, the response in two or three sentences, and one sentence on why it matters for the round.",
                     "Time yourself delivering the block in under forty-five seconds.",
@@ -398,12 +398,12 @@
             ("How can I practise rebuttals on my own?", "Take the arguments you expect to face, find each one's weakest link with Attack, write a short block, and deliver it against a timer. Then ask the AI for the best reply to your block and prepare an answer."),
             ("How long should a rebuttal response be?", "Most single responses should take under a minute. Total rebuttal time depends on the format, from four minutes in Public Forum to most of an eight-minute WSDC speech."),
             ("What is the difference between a rebuttal and a block?", "A block is a rebuttal prepared before the round for an argument you expect. In the round you adapt the block to what the opponent actually said."),
-            ("Can the AI predict my opponent's arguments?", "Yes. Each generated case includes a predicted opponent case, which is a practical list of arguments to prepare blocks against."),
+            ("Can the AI predict my opponent's arguments?", "Yes. Each generated case includes \"If they say…\" answers: the claims the other side is likely to make, each with a reply, which is a practical list of arguments to prepare blocks against."),
             ("How do I stop dropping arguments?", "Flow every speech, mark each opposing argument as answered or not, and group similar arguments so one response covers several. Practise against a timer until it becomes routine."),
         ],
     },
     "how-to-practice-rebuttals": {
-        "modified": "2026-10-26",
+        "modified": "2026-10-28",
         "features": [
             ("A weekly drill plan", "Four short sessions a week, each training one rebuttal skill: selection, warrant attacks, grouping, and weighing under time."),
             ("Drills that work alone or with a partner", "Shadow rebuttals, flip-the-flow, one-sentence answers and rapid-fire rounds, with a version for solo practice and one for teams."),
@@ -446,8 +446,8 @@
                 "For one argument, write five different responses: deny the claim, attack the warrant, mitigate the impact, turn it and outweigh it. Then rank them. Practising all five shows you which kind of response you lean on too much.",
                 {"h3": "Drop audit"},
                 "After a practice round, go through your flow and circle every opposing argument you did not answer. For each one, decide whether dropping it was a choice or an accident. Accidents are what you drill next.",
-                {"h3": "Spar the predicted case"},
-                "In {product}, generate a case on your side and read the predicted opponent case. Paste the strongest opposing argument into Attack to see where it breaks, then run a Sparring round and answer it live. The verdict tells you whether your answer changed the outcome.",
+                {"h3": "Spar the \"If they say…\" claims"},
+                "In {product}, generate a case on your side and read its \"If they say…\" answers. Paste the strongest opposing claim into Attack to see where it breaks, then run a Sparring round and answer it live. The verdict tells you whether your answer changed the outcome.",
             ]),
             ("Worked example: from first attempt to clean rebuttal", [
                 {"example": {"title": "Motion: This house would lower the voting age to 16", "rows": [
@@ -510,6 +510,7 @@
         ],
     },
     "ai-rebuttal-generator": {
+        "modified": "2026-10-28",
         "features": [
             ("Weaknesses ranked by damage", "Attack quotes the exact words it is targeting, names the broken link and orders the weaknesses from critical to minor."),
             ("Responses you can say", "Each weakness comes with one to three sentences written to be spoken in round, not a description of what you could argue."),
@@ -552,7 +553,7 @@
             ]),
             ("From generated output to a rebuttal you own", [
                 {"steps": [
-                    "Start from the right input. Use the opponent case predicted when you generated your own case, an argument you heard in a previous round, or your own case when you want to find its weak points first.",
+                    "Start from the right input. Use a claim from the \"If they say…\" answers in a case you generated, an argument you heard in a previous round, or your own case when you want to find its weak points first.",
                     "Read the critical weaknesses and pick one. In a short speech, one well-explained weakness beats four rushed ones.",
                     "Rewrite the suggested response in your own words. Keep the structure (quote, flaw, response, why it matters) and cut anything you would not naturally say.",
                     "Check any evidence it relies on against the original source.",
@@ -582,44 +583,47 @@
         ],
     },
     "how-to-write-a-debate-case": {
+        "modified": "2026-10-28",
         "features": [
-            ("Motion analysis first", "Define the terms, name the burden and find the clashes before writing a single contention."),
-            ("Contentions that hold up", "Build each point as claim, warrant, evidence, impact and weighing, so a judge can follow it and an opponent cannot break it with one question."),
-            ("A case you can defend", "Pre-empt the obvious responses, cut what does not clash, and test the draft by attacking it yourself."),
+            ("Motion analysis first", "Define the terms, write down what your side has to prove and find where the two sides disagree before writing a single argument."),
+            ("Arguments that hold up", "Build each argument as a point, an explanation, evidence and why it matters, so a judge can follow it and an opponent cannot break it with one question."),
+            ("A case you can defend", "Write \"If they say… we answer…\" replies to the obvious responses, cut what does not clash, and test the draft by attacking it yourself."),
         ],
         "sections": [
             ("What a debate case is", [
-                "A debate case is the argument your side will defend for the whole round, organised so a judge can follow it on first hearing. It is not an essay. An essay can explore; a case has to survive an opponent whose job is to find the weakest sentence in it. That is why good cases are built from small, testable parts: a clear position, a reason the judge should decide the round your way, and two to four contentions that each prove something specific.",
-                "The process below works for every format. The format changes the length, the number of contentions and who gives which part, which the format section covers further down.",
+                "A debate case is the argument your side will defend for the whole round, organised so a judge can follow it on first hearing. It is not an essay. An essay can explore; a case has to survive an opponent whose job is to find the weakest sentence in it. That is why good cases are built from small, testable parts: an opening that tells the judge what you will prove, two to four arguments that each prove something specific, answers to what the other side will say, and a closing line the judge remembers.",
+                "The process below works for every format. The format changes the length, the number of arguments and who gives which part, which the format section covers further down.",
             ]),
             ("Eight steps from motion to finished case", [
                 {"steps": [
                     "Read the motion word by word. Note the actor (who does it), the action (what changes) and any word that sets the strength of the claim, such as should, would, ban, regulate or prioritise. A motion about regulating something is a different debate from one about banning it.",
                     "Define the key terms in plain language. Pick definitions that are fair and that a judge would accept without argument. A squirrelled definition wins the definition debate and loses the round.",
-                    "Write your burden in one sentence: what does your side have to prove for the judge to vote for you? If you are proposing a policy, you usually need to show a problem, a mechanism and a net benefit. If you are opposing, you choose whether to defend the status quo, a counter-proposal or simply that the proposal does more harm than good.",
+                    "Write down in one sentence what your side has to prove for the judge to vote for you. If you are proposing a policy, you usually need to show a problem, a mechanism and a net benefit. If you are opposing, you choose whether to defend the status quo, a counter-proposal or simply that the proposal does more harm than good.",
                     "Brainstorm widely, then cut hard. List every argument for your side, group the ones that share a reason, and keep the two to four groups that are strongest and most different from each other.",
-                    "Build each contention as a chain: claim (what is true), warrant (why it is true), evidence (what supports the warrant), impact (why it matters) and weighing (why it matters more than what the other side will say).",
-                    "Write the framework: the standard the judge should use to decide. In Lincoln-Douglas it is a value and criterion; in most other formats it is a sentence on what the round should be about, such as who bears the cost or which outcome is more likely.",
-                    "Pre-empt the most obvious response to each contention inside the contention itself. One sentence is enough. It stops the opponent's best attack from looking new.",
-                    "Write it out, read it aloud against a timer, and cut until it fits with fifteen seconds to spare.",
+                    "Build each argument in four parts: the point (what is true, in one sentence), the explanation (why it is true, step by step), the evidence (a source that backs it, named with its year) and why it matters (what it means for real people, and why that matters more than what the other side will say).",
+                    "Write the opening: a hook that makes the judge listen, then one line that says what you will show, such as \"Today we will show two arguments that prove…\". In Lincoln-Douglas, your value and criterion go here too.",
+                    "For each argument, write down what the other side is most likely to say and a short answer: \"If they say…, we answer…\". Put the answer to the most obvious response inside the argument itself, so the opponent's best attack does not sound new.",
+                    "Finish with a closing line that ties back to the opening and a list of your sources. Then read the case aloud against a timer and cut until it fits with fifteen seconds to spare.",
                 ]},
             ]),
             ("Worked example: a full case outline", [
                 {"example": {"title": "Motion: This house would make public transport free", "rows": [
                     ("Side:", "Proposition."),
                     ("Definitions:", "Public transport means buses, trams and local trains run or funded by government. Free means no fare at the point of use, paid for from general taxation."),
-                    ("Burden:", "Show that removing fares produces benefits greater than the cost of replacing fare revenue."),
-                    ("Framework:", "The round should be decided by who gains and who pays: a policy that shifts costs from those least able to pay towards those most able is preferable when the total benefit is comparable."),
-                    ("Contention 1, access:", "Claim: fares stop low-income people from reaching jobs and services. Warrant: transport is a fixed cost that takes a larger share of a small income. Impact: removing it widens the area in which people can work and study. Pre-emption: discounted passes exist, but they require applications and proof of eligibility that many eligible people never complete."),
-                    ("Contention 2, congestion and emissions:", "Claim: free fares move some journeys from cars to public transport. Warrant: price is one of the factors people weigh when choosing how to travel. Impact: fewer car journeys reduce congestion and emissions for everyone in the city."),
-                    ("Weighing:", "Contention 1 is the more certain benefit and reaches the people most affected, so it leads; contention 2 is larger in scale but less certain, so it is framed as an additional reason, not the case's foundation."),
-                    ("Likely opposition and prepared answer:", "Opposition will say the money is better spent on more frequent services. The answer: frequency helps people who already ride; free fares reach people currently priced out, and the two are not mutually exclusive."),
+                    ("What we have to prove:", "That removing fares produces benefits greater than the cost of replacing fare revenue."),
+                    ("Opening:", "For a family on a low income, the bus fare to work can be the difference between taking a job and turning it down. Today we will show two arguments that prove free public transport is worth what it costs."),
+                    ("Argument 1, access:", "Point: fares stop low-income people from reaching jobs and services. Explanation: transport is a fixed cost that takes a larger share of a small income. Why it matters: removing it widens the area in which people can work and study. Answer built in: discounted passes exist, but they require applications and proof of eligibility that many eligible people never complete."),
+                    ("Argument 2, congestion and emissions:", "Point: free fares move some journeys from cars to public transport. Explanation: price is one of the things people consider when choosing how to travel. Why it matters: fewer car journeys reduce congestion and emissions for everyone in the city."),
+                    ("Order:", "Argument 1 is the more certain benefit and reaches the people most affected, so it goes first; argument 2 is larger in scale but less certain, so it is an additional reason, not the case's foundation."),
+                    ("If they say:", "The money is better spent on more frequent services."),
+                    ("We answer:", "Frequency helps people who already ride; free fares reach people currently priced out, and the two are not mutually exclusive."),
+                    ("Closing line:", "That is why free fares are the fairest way to pay for the buses a whole city depends on."),
                 ]}},
-                "Notice what the outline does not contain: a long introduction, rhetorical questions or a list of statistics without warrants. Every line either defines the debate, proves something or tells the judge how to compare.",
+                "Notice what the outline does not contain: a long introduction, rhetorical questions or a list of statistics without explanations. Every line either defines the debate, proves something, answers the other side or tells the judge what to remember.",
             ]),
             ("How case structure changes by format", [
                 {"h3": "Public Forum (PF)"},
-                "A four-minute constructive usually fits two contentions, each with evidence, and sometimes a short framework. Because you often do not know your side until shortly before the round, write a case for each side and keep them consistent in style. Put pre-emption into the second constructive if you speak second.",
+                "A four-minute constructive usually fits two arguments, each with evidence, and sometimes a short framework. Because you often do not know your side until shortly before the round, write a case for each side and keep them consistent in style. Put answers to the other side into the second constructive if you speak second.",
                 {"h3": "Lincoln-Douglas (LD)"},
                 "The case is built around a value and a criterion, followed by contentions that each show how your side meets the criterion. A weak link between contention and criterion is the first thing a good negative will attack, so state it explicitly at the end of every contention.",
                 {"h3": "British Parliamentary (BP)"},
@@ -630,28 +634,28 @@
             ("Checklist before you call the case finished", [
                 {"list": [
                     "Can you state the whole case in two sentences?",
-                    "Does every contention have a warrant you could explain without your notes?",
+                    "Does every argument have an explanation you could give without your notes?",
                     "Is every piece of evidence one you have read in the original, with a full citation?",
-                    "Does each contention say why it matters more than what the other side will argue?",
-                    "Have you written down the strongest response to each contention, and your answer to it?",
+                    "Does each argument say why it matters, and why that matters more than what the other side will argue?",
+                    "Have you written an \"If they say…\" answer to the strongest response to each argument?",
                     "Does it fit in the time with room to slow down?",
                 ]},
-                "If any answer is no, fix that before you practise delivery. Polishing the speech of a case with a missing warrant only makes the gap harder to see.",
+                "If any answer is no, fix that before you practise delivery. Polishing the speech of a case with a missing explanation only makes the gap harder to see.",
             ]),
             ("Where {product} helps", [
-                "Once you have a draft, attack it before an opponent does. Paste a contention into Attack to see which link breaks first, use Brainstorm when you need more angles at step four, and use Factoids to research a single statement you want to rely on. If you would rather start from a structure, the case generator produces a draft with a thesis, framework, contentions and a predicted opposing case, which you can then cut and rewrite with the steps above.",
+                "Once you have a draft, attack it before an opponent does. Paste an argument into Attack to see which link breaks first, use Brainstorm when you need more angles at step four, and use Factoids to research a single statement you want to rely on. If you would rather start from a draft, the case generator writes a ready-to-read case in the same shape: an opening, arguments with explanation, evidence and why it matters, \"If they say… we answer…\" replies, a closing line and sources. Cut and rewrite it with the steps above.",
             ]),
         ],
         "faqs": [
-            ("How many contentions should a debate case have?", "Usually two to four. Public Forum constructives often fit two; formats with longer speeches can take three or four. Fewer well-defended contentions beat many thin ones."),
-            ("What is the difference between a claim and a warrant?", "The claim is what you say is true; the warrant is the reason it is true. Judges vote on warrants, so a claim without one is an assertion that the other side can dismiss."),
+            ("How many contentions should a debate case have?", "Usually two to four arguments, which some formats call contentions. Public Forum constructives often fit two; formats with longer speeches can take three or four. Fewer well-defended arguments beat many thin ones."),
+            ("What is the difference between a claim and a warrant?", "The claim is what you say is true; the warrant is the reason it is true. In a case, they are the point and its explanation. Judges vote on the reasons, so a claim without one is an assertion that the other side can dismiss."),
             ("How long does it take to write a debate case?", "A first draft can take an hour once you have researched the topic. Expect to revise it several times after practice rounds expose its weak points."),
             ("Should I write my case word for word?", "In formats with prepared constructives, such as Public Forum and Lincoln-Douglas, most debaters do. In impromptu formats like BP and WSDC, prepare an outline and key lines instead."),
-            ("How do I make a case harder to attack?", "Explain every warrant, use evidence you have checked, pre-empt the most obvious response inside each contention, and attack the draft yourself before the round."),
+            ("How do I make a case harder to attack?", "Explain why every point is true, use evidence you have checked, answer the most obvious response inside each argument, and attack the draft yourself before the round."),
         ],
     },
     "debate-topics-for-students": {
-        "modified": "2026-10-23",
+        "modified": "2026-10-28",
         "features": [
             ("Topics by level", "Starter motions for new debaters, intermediate motions with more technical clash, and advanced motions for experienced teams."),
             ("Topics by format", "Motion wording for BP and WSDC, resolutions for Public Forum and value resolutions for Lincoln-Douglas."),
@@ -732,7 +736,7 @@
                     "Rerun the same topic with sides swapped. The second round is usually much better, because each team now knows the other side's best arguments.",
                 ]},
                 "For a quick random pick, the [free debate motion generator](/tools/debate-motion-generator) draws a practice motion by topic and difficulty, with no account.",
-                "In {product}, start a Current Debate with the motion and run Brainstorm to see angles for both sides, generate a case with its predicted opposing case, or run a Sparring round against the AI when there is no second team available.",
+                "In {product}, start a Current Debate with the motion and run Brainstorm to see angles for both sides, generate a case with \"If they say…\" answers to the other side, or run a Sparring round against the AI when there is no second team available.",
             ]),
         ],
         "faqs": [
@@ -827,7 +831,7 @@
     },
     "debateowl-vs-chatgpt": {
         "software": True,
-        "modified": "2026-10-27",
+        "modified": "2026-10-28",
         "features": [
             ("A general assistant", "ChatGPT can brainstorm, explain, draft and revise on any subject, including debate."),
             ("A debate workspace", "{product} organises prep around one motion at a time, with structured cases, an AI opponent, a timer and judged practice rounds."),
@@ -838,7 +842,7 @@
                 "ChatGPT is a general-purpose AI assistant. {product} is a debate practice workspace. Both use large language models, but they are designed for different jobs. If you want to explore an idea, learn background on a topic or tighten a paragraph, a general assistant is flexible and fast. If you want to prepare a specific motion, practise against an opponent at real speech times and get a verdict on your round, a tool built around debate structure saves the setup you would otherwise do by hand in every conversation.",
                 "Many debaters use both. This page explains where each is stronger so you can decide what fits your preparation.",
                 {"table": {"caption": "{product} vs ChatGPT for debate prep (as of October 2026)", "head": ["Feature", "{product}", "ChatGPT"], "rows": [
-                    ["Structured case output", "Every case has a thesis, a framework, contentions with warrants and impacts, the likely opposing case and counters", "Whatever structure you ask for, in each conversation"],
+                    ["Structured case output", "Every case has an opening, arguments with explanation, evidence and why it matters, \"If they say… we answer…\" replies, a closing line and sources", "Whatever structure you ask for, in each conversation"],
                     ["Saved sources (Library)", "Sources you add to a debate's Library are given to its prep tools", "You paste the motion and your sources into each new conversation"],
                     ["Web research with a source list", "Generate researches the motion on the web and lists the sources it found; Ask can answer with citations", "Not tied to one debate; nothing is saved to a Library"],
                     ["Timed practice round with a verdict", "Sparring runs School 4-6-6-3, Lincoln-Douglas and Public Forum rounds, times each speech and ends with a verdict", "No built-in round, timing or verdict; you role-play and keep time yourself"],
@@ -862,7 +866,7 @@
                 {"h3": "One motion, one place"},
                 "In {product}, everything belongs to a Current Debate: the motion, the Library sources you have added, generated cases, Attack analyses, practice rounds and debriefs. The prep tools read that context, so you never paste the motion and your research into a new conversation.",
                 {"h3": "Structured output"},
-                "Generated cases always have the same parts: thesis, framework, contentions with warrants and impacts, the case the other side is likely to run, and counters to it. Attack always returns ranked weaknesses that quote the attacked words, with a response to say in round, cross-examination questions and a weighing analysis. Fixed structure makes the output easier to check and to turn into speeches.",
+                "Generated cases always have the same parts: an opening, arguments with explanation, evidence and why each matters, \"If they say… we answer…\" replies to the other side, a closing line and a source list. Attack always returns ranked weaknesses that quote the attacked words, with a response to say in round, cross-examination questions and a weighing analysis. Fixed structure makes the output easier to check and to turn into speeches.",
                 {"h3": "Timed practice rounds"},
                 "Sparring runs full rounds against an AI opponent in School 4-6-6-3, Lincoln-Douglas and Public Forum, with each speech timed, and ends with a verdict that names the reason for the decision. Crossfire drills cross-examination in either direction. A speech timer covers Standard, Lincoln-Douglas, Public Forum and Policy speech orders.",
                 {"h3": "Sources you control"},
@@ -871,14 +875,14 @@
             ("Worked example: the same task in both tools", [
                 {"example": {"title": "Task: prepare to answer the opposition on This house would make voting compulsory", "rows": [
                     ("In a general chat:", "You describe the motion, your side and your format, then ask for the opposition's arguments. You get a useful list. To get responses, you ask again; to check one argument in depth, you paste it back; to practise, you would need to role-play a round and keep track of time yourself."),
-                    ("In {product}:", "You start a Current Debate with the motion, generate your proposition case and read the predicted opposition case it includes. You paste the strongest opposition argument into Attack, which returns its weakest link, a response to say and a cross-ex question. You import the questions into Crossfire to practise them, then run a timed Sparring round and read the verdict."),
+                    ("In {product}:", "You start a Current Debate with the motion, generate your proposition case and read its \"If they say…\" answers to the opposition. You paste the strongest opposition argument into Attack, which returns its weakest link, a response to say and a cross-ex question. You import the questions into Crossfire to practise them, then run a timed Sparring round and read the verdict."),
                     ("The difference:", "Individual sentences can be similar in quality. What changes is how much setup you repeat, and whether you end up practising a round or only reading text."),
                 ]}},
             ]),
             ("Which should you use?", [
                 {"list": [
                     "Learning about a topic from scratch: a general assistant is a good start.",
-                    "Writing a case for a specific motion: a debate workspace gives a consistent structure and a predicted opposing case.",
+                    "Writing a case for a specific motion: a debate workspace gives a consistent structure and answers to what the other side will say.",
                     "Finding the weak point in an opposing argument: a tool that returns structured weaknesses and responses is faster to use in prep.",
                     "Practising speeches and rounds: you need timing, an opponent and a verdict, which a general chat does not provide.",
                     "Polishing wording: either works; use the one you are already in.",
@@ -956,55 +960,56 @@
         ],
     },
     "argument-flowchart": {
-        "modified": "2026-10-21",
+        "modified": "2026-10-28",
         "features": [
-            ("Visual clash maps", "Put the thesis, each argument, the attacks on it and your rebuttals on one canvas, so you can see where the round will be decided."),
+            ("Visual clash maps", "Put your case's main line, each argument, the attacks on it and your answers on one canvas, so you can see where the round will be decided."),
             ("Link and strength tracking", "Mark each argument strong, moderate or weak, and connect nodes with support, attack and rebuttal links."),
             ("Saved with your debate", "Flowcharts save to the Current Debate next to its case and rebuttals, and export as a PNG for teammates."),
         ],
         "sections": [
             ("Why map arguments at all", [
-                "Arguments are chains: a claim depends on a warrant, the warrant on an assumption, and the impact on all of them. When one link breaks, the whole contention falls. A flowchart makes the chain visible, so you can see which link the other side will attack and which link of theirs you should attack.",
-                "A map also shows what a written case hides. Two contentions that rely on the same assumption look independent on paper; on a map they share a node, and one good response takes out both.",
+                "Arguments are chains: a point depends on its explanation, the explanation on an assumption, and why it matters on all of them. When one link breaks, the whole argument falls. A flowchart makes the chain visible, so you can see which link the other side will attack and which link of theirs you should attack.",
+                "A map also shows what a written case hides. Two arguments that rely on the same assumption look independent on paper; on a map they share a node, and one good response takes out both.",
             ]),
             ("How the {product} flowchart works", [
-                "A new flowchart starts with a thesis, three example arguments, an opponent attack and a rebuttal, all of which you can edit or delete. Each node has a label, a description and a type:",
+                "A new flowchart starts with a top node for your case's main line, three example arguments, an opponent attack and a rebuttal, all of which you can edit or delete. Each node has a label, a description and a type:",
                 {"list": [
-                    "Thesis: the position your side has to prove.",
-                    "Argument: a contention, rated strong, moderate or weak.",
+                    "Thesis: your case's main line, the one sentence your side has to prove.",
+                    "Argument: one of your arguments, rated strong, moderate or weak.",
                     "Attack: an opposing response to one of your arguments.",
                     "Rebuttal: your answer to an attack.",
                     "Dropped: an argument nobody answered.",
                 ]},
                 "Links between nodes are support, attack or rebuttal, each drawn in its own style. Save the chart to the Current Debate, load it again later, or export it as an image.",
+                "A generated case can build the map for you. Choose Flowcharts under the case: the opening's \"we will show\" line goes at the top, each argument becomes a node with its point and evidence, each \"If they say…\" claim becomes an attack, and our answer becomes the rebuttal to it.",
             ]),
             ("Build from the motion outward", [
                 {"steps": [
-                    "Write the thesis as one sentence: what your side must prove for the motion.",
-                    "Add each contention as an argument node and link it to the thesis. Rate it honestly; a weak node is one to fix or cut.",
-                    "For each contention, add the strongest attack you expect. If you have generated a case, the predicted opponent case is the place to find them.",
+                    "Write the main line as one sentence: what your side must prove for the motion.",
+                    "Add each argument as a node and link it to the main line. Rate it honestly; a weak node is one to fix or cut.",
+                    "For each argument, add the strongest attack you expect. If you have generated a case, its \"If they say…\" claims are the place to find them.",
                     "Add your rebuttal to each attack. Where you cannot write one, the map has found your gap.",
-                    "Mark weighing at each clash in a node's description: why your side of that clash matters more.",
+                    "At each clash, note in a node's description why your side of it matters more.",
                 ]},
                 "Build the opposing case the same way on a second chart. Most rounds turn on two or three clashes, and the two maps side by side show which ones.",
             ]),
             ("Worked example: mapping one clash", [
                 {"example": {"title": "Motion: This house would ban single-use plastics", "rows": [
-                    ("Thesis:", "A ban cuts plastic pollution at its largest source."),
+                    ("Main line:", "A ban cuts plastic pollution at its largest source."),
                     ("Argument (strong):", "Single-use items are a large share of plastic waste and are rarely recycled."),
                     ("Attack:", "Substitutes such as paper and glass have a higher carbon footprint per use."),
                     ("Rebuttal:", "The comparison only holds if reusable items are used a few times; reuse, not substitution, is the goal of the ban."),
-                    ("Weighing note:", "Plastic pollution lasts for centuries and cannot be reversed, while the footprint of substitutes falls with every reuse."),
+                    ("Why ours matters more:", "Plastic pollution lasts for centuries and cannot be reversed, while the footprint of substitutes falls with every reuse."),
                 ]}},
-                "The map makes it obvious that the round turns on the substitution clash. That is where the rebuttal speech and the weighing should go.",
+                "The map makes it obvious that the round turns on the substitution clash. That is where the rebuttal speech and the comparison should go.",
             ]),
             ("Use the map in your speeches", [
-                "Before you speak, look for the path that wins: the strongest argument still standing after the attacks, and the weighing that makes it outweigh. Speak to that path and drop the rest. A good map helps you collapse instead of spreading yourself thin.",
+                "Before you speak, look for the path that wins: the strongest argument still standing after the attacks, and the reason it matters more than theirs. Speak to that path and drop the rest. A good map helps you collapse instead of spreading yourself thin.",
                 "During a round, a written flow is faster than any canvas. Use the flowchart to prepare before the round and to review the clashes after it, and keep your in-round flow on paper or a laptop.",
             ]),
         ],
         "faqs": [
-            ("What is an argument flowchart in debate?", "A diagram of a case: the thesis, the arguments that support it, the attacks on them and the responses, joined by links that show what depends on what."),
+            ("What is an argument flowchart in debate?", "A diagram of a case: its main line, the arguments that support it, the attacks on them and the answers, joined by links that show what depends on what."),
             ("Is a flowchart the same as flowing?", "No. Flowing is note-taking during a round, speech by speech. A flowchart is a map you build before or after a round to plan and review the clash."),
             ("Can I save and share a flowchart?", "Yes. Save it to the Current Debate to load it later, or export it as a PNG image to share with a partner or coach."),
             ("How many arguments should a flowchart have?", "As many as the case has, but the useful part is the two or three clashes that decide the round. If the map is too crowded to read, collapse it to those."),
@@ -1228,7 +1233,7 @@
         ],
     },
     "debate-evidence-finder": {
-        "modified": "2026-10-21",
+        "modified": "2026-10-28",
         "features": [
             ("Evidence leads", "Research directions for a claim: the kinds of sources that could support it and searches you can run to confirm it."),
             ("Citation checks", "A checklist for each source before it goes on a card: author, date, method and whether the quote says what you claim."),
@@ -1246,7 +1251,7 @@
             ("Finding evidence with {product}", [
                 {"steps": [
                     "Give Factoids a single statement from your case. It researches that statement and returns supporting factoids with citations, context and suggestions for how to use them.",
-                    "Generate a case. {product} researches the motion before it writes, so the draft comes with sources for its claims.",
+                    "Generate a case. {product} researches the motion before it writes, so each piece of evidence names its source and year, and the case ends with a source list: the organisation, the year, the claim it supports and the link.",
                     "Save the sources you trust to the Library. Active Library sources that fit a request are used by the other prep tools for that debate, so later answers draw on material you have checked.",
                     "Ask for counter-evidence too. Attack runs research on an argument and can point to sources that cut against it, which tells you what the other side may read.",
                 ]},
@@ -1327,7 +1332,7 @@
         ],
     },
     "debateowl-vs-windebate": {
-        "modified": "2026-10-27",
+        "modified": "2026-10-28",
         "software": True,
         "features": [
             ("Formats", "As of October 2026, WinDebate names six formats: Public Forum, Lincoln-Douglas, Congressional, Policy, World Schools and British Parliamentary. {product}'s Sparring rounds cover School 4-6-6-3, Lincoln-Douglas and Public Forum."),
@@ -1340,7 +1345,7 @@
                 "As of October 2026, its plans are Free ($0, with 1 research session, 10 drills and 1 Live Assistant round a month), Plus ($19.99/month, which adds voice input and playback and weekly progress) and Pro ($39.99/month). These details come from WinDebate's own site; check it for current terms.",
             ]),
             ("What {product} offers", [
-                "{product} is an AI debate prep and practice app with {mode_count} prep modes. You start a Current Debate for one motion, add sources to its Library, generate a structured case with a predicted opponent case, find weak links with Attack, research claims with Factoids, ask the Ask coach, drill cross-examination in Crossfire, and run timed Sparring rounds against an AI opponent that end in a verdict. A speech timer and an argument flowchart round it out.",
+                "{product} is an AI debate prep and practice app with {mode_count} prep modes. You start a Current Debate for one motion, add sources to its Library, generate a ready-to-read case with \"If they say…\" answers to the other side, find weak links with Attack, research claims with Factoids, ask the Ask coach, drill cross-examination in Crossfire, and run timed Sparring rounds against an AI opponent that end in a verdict. A speech timer and an argument flowchart round it out.",
                 "As of October 2026, {product} has a 3-day free trial with no credit card, then Pro at {pro_price}. The app is available in English, Spanish and Hungarian.",
             ]),
             ("Side by side", [
@@ -1370,7 +1375,7 @@
         ],
     },
     "debateowl-vs-debateclub": {
-        "modified": "2026-10-27",
+        "modified": "2026-10-28",
         "software": True,
         "features": [
             ("Audience", "As of October 2026, DebateClub describes itself as training for high-stakes conversations such as negotiations, pitches and meetings. {product} is built for school and competitive debate."),
@@ -1383,7 +1388,7 @@
                 "As of October 2026, its plans are Free ($0, one debate credit) and Pro ($19/month or $149/year). These details come from DebateClub's own site; check it for current terms.",
             ]),
             ("What {product} offers", [
-                "{product} is an AI debate prep and practice app for students and competitive debaters, with {mode_count} prep modes. It builds structured cases with a predicted opponent case, finds weak links with Attack, researches claims with Factoids, drills cross-examination in Crossfire and runs timed Sparring rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum that end in a verdict. Voice mode lets you speak your speeches instead of typing them.",
+                "{product} is an AI debate prep and practice app for students and competitive debaters, with {mode_count} prep modes. It builds ready-to-read cases with \"If they say…\" answers to the other side, finds weak links with Attack, researches claims with Factoids, drills cross-examination in Crossfire and runs timed Sparring rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum that end in a verdict. Voice mode lets you speak your speeches instead of typing them.",
                 "As of October 2026, {product} has a 3-day free trial with no credit card, then Pro at {pro_price}. The app is available in English, Spanish and Hungarian.",
             ]),
             ("Side by side", [
@@ -1391,7 +1396,7 @@
                     ["Built for", "School and competitive debate", "High-stakes conversations such as negotiations, pitches and meetings"],
                     ["Formats named", "Sparring rounds in School 4-6-6-3, Lincoln-Douglas and Public Forum", "None"],
                     ["Practice style", "Timed Sparring rounds you can type or speak, ending in a verdict", "Voice-only sparring with opponent personas and rhetorical technique scoring"],
-                    ["Prep tools", "Cases with a predicted opponent case, Attack, Factoids, Crossfire and a timer", "A prep screen for openings and counters"],
+                    ["Prep tools", "Cases with \"If they say…\" answers, Attack, Factoids, Crossfire and a timer", "A prep screen for openings and counters"],
                     ["Price", "3-day free trial, then {pro_price}", "Free tier with one debate credit; Pro $19/month or $149/year"],
                 ]}},
             ]),
diff --git a/scripts/staging-sync.mjs b/scripts/staging-sync.mjs
index a17ace8e1..b957259fc 100644
--- a/scripts/staging-sync.mjs
+++ b/scripts/staging-sync.mjs
@@ -26,7 +26,6 @@ import { join, relative } from "node:path";
 import { backendStatus } from "./backend-status.mjs";
 
 export const STAGING_REF = "brifeyypjauyusmkptkx";
-export const STAGING_NAME = "debate-trainer-staging";
 export const PRODUCTION_REF = "uziwdtkzofptihahfooo";
 export const GITHUB_REPO = "Programcode/DebateLab";
 const STATUS_CONTEXT = "staging-sync";
@@ -78,7 +77,13 @@ function supabase(root, args) {
   return output;
 }
 
-/** Refuses to run unless the CLI sees the staging ref under the staging name. */
+/**
+ * Refuses to run unless the CLI can see the staging project by its ref. The
+ * check is keyed on the ref, which never changes, not on the display name,
+ * which anyone can rename in the dashboard (staging went from
+ * "debate-trainer-staging" to "DebateOwl Staging"). Every CLI call passes
+ * STAGING_REF explicitly, so production is never the target.
+ */
 export function assertStagingTarget(projects, env = process.env) {
   const override = env.SUPABASE_PROJECT_ID?.trim();
   if (override && override !== STAGING_REF) {
@@ -87,9 +92,7 @@ export function assertStagingTarget(projects, env = process.env) {
   if (STAGING_REF === PRODUCTION_REF) throw new RefusedError("Staging and production refs are the same.");
   const staging = projects.find((project) => (project.ref ?? project.id) === STAGING_REF);
   if (!staging) throw new RefusedError(`The Supabase account cannot see ${STAGING_REF}.`);
-  if (staging.name !== STAGING_NAME) {
-    throw new RefusedError(`${STAGING_REF} is named "${staging.name}", expected "${STAGING_NAME}".`);
-  }
+  return staging;
 }
 
 /** What the sync has to do, from a backend-status result. */
diff --git a/src/components/features/generate/GenerateResults.tsx b/src/components/features/generate/GenerateResults.tsx
index f8158d8b8..def1dd047 100644
--- a/src/components/features/generate/GenerateResults.tsx
+++ b/src/components/features/generate/GenerateResults.tsx
@@ -1,12 +1,13 @@
 import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Target, Shield, Swords, AlertTriangle, MessageSquare, GitBranch, Sparkles, Undo2, Flame } from 'lucide-react';
+import { Shield, Swords, AlertTriangle, MessageSquare, GitBranch, Sparkles, Undo2, Flame, Trophy, Quote, BookOpen } from 'lucide-react';
 import { Badge } from '@/components/ui/badge';
 import { Button } from '@/components/ui/button';
 import { SectionCard } from '@/components/ui/section-card';
 import { Separator } from '@/components/ui/separator';
 import { Markdown } from '@/components/ui/markdown';
-import type { GenerateOutput, Contention } from '@/lib/ai/schemas/generate';
+import type { GenerateOutput } from '@/lib/ai/schemas/generate';
+import { readCase, sourceLabel, type CaseArgument } from '@debatelab/core/ai/case-view';
 import { toast } from 'sonner';
 import { formatDecimal, formatEuropeanDateTime } from '@/lib/date-format';
 import { ExportToolbar } from '@/components/features/ExportToolbar';
@@ -34,16 +35,16 @@ interface GenerateResultsProps {
   onPracticeCrossfire?: () => void;
 }
 
-function ArgumentCard({ contention, index, unverified }: { contention: Contention; index: number; unverified: boolean }) {
+function ArgumentCard({ argument, index, unverified }: { argument: CaseArgument; index: number; unverified: boolean }) {
   const { t } = useTranslation();
   return (
     <div className="rounded-lg border border-border bg-card p-4 space-y-3 motion-list-item">
       <div className="flex items-start justify-between gap-2">
         <h3 className="font-semibold text-foreground">
           <span className="text-primary mr-2">#{index + 1}</span>
-          {contention.claim}
+          {argument.title ?? argument.point}
         </h3>
-        {contention.needsSource && (
+        {argument.needsSource && (
           <Badge variant="outline" className="shrink-0 border-amber-500 text-amber-600">
             <AlertTriangle className="mr-1 h-3 w-3" />
             {t('generateResults.needsSource')}
@@ -52,34 +53,59 @@ function ArgumentCard({ contention, index, unverified }: { contention: Contentio
       </div>
 
       <div className="space-y-2 text-sm">
-        <div>
-          <span className="font-medium text-muted-foreground">{t('generateResults.reasoning')} </span>
-          <Markdown inline>{contention.reasoning}</Markdown>
-        </div>
-        <div>
-          <span className="font-medium text-muted-foreground">{t('generateResults.evidence')} </span>
-          {unverified && !contention.needsSource && (
-            <Badge variant="outline" className="mr-1 border-amber-500/40 bg-amber-500/10 py-0 align-middle text-amber-800 dark:text-amber-300">
-              {t('generateResults.unverified', 'Unverified')}
-            </Badge>
-          )}
-          <Markdown inline>{contention.evidence}</Markdown>
-        </div>
-        {contention.sourceQuery && (
+        {argument.title && argument.point && (
+          <div>
+            <span className="font-medium text-muted-foreground">{t('generateResults.point')} </span>
+            <Markdown inline>{argument.point}</Markdown>
+          </div>
+        )}
+        {argument.explanation && (
+          <div>
+            <span className="font-medium text-muted-foreground">{t('generateResults.explanation')} </span>
+            <Markdown inline>{argument.explanation}</Markdown>
+          </div>
+        )}
+        {argument.evidence && (
+          <div>
+            <span className="font-medium text-muted-foreground">{t('generateResults.evidence')} </span>
+            {unverified && !argument.needsSource && (
+              <Badge variant="outline" className="mr-1 border-amber-500/40 bg-amber-500/10 py-0 align-middle text-amber-800 dark:text-amber-300">
+                {t('generateResults.unverified', 'Unverified')}
+              </Badge>
+            )}
+            <Markdown inline>{argument.evidence}</Markdown>
+          </div>
+        )}
+        {argument.sourceQuery && (
           <div className="rounded-md bg-muted/50 p-2 text-xs">
             <span className="font-medium">{t('generateResults.searchSuggestion')} </span>
-            <code className="text-primary">{contention.sourceQuery}</code>
+            <code className="text-primary">{argument.sourceQuery}</code>
+          </div>
+        )}
+        {argument.whyItMatters && (
+          <div>
+            <span className="font-medium text-muted-foreground">{t('generateResults.whyItMatters')} </span>
+            <Markdown inline>{argument.whyItMatters}</Markdown>
           </div>
         )}
-        <div>
-          <span className="font-medium text-muted-foreground">{t('generateResults.impact')} </span>
-          <Markdown inline>{contention.impact}</Markdown>
-        </div>
       </div>
     </div>
   );
 }
 
+/** A labelled bullet list for an older case's section; nothing when it is empty. */
+function LegacyList({ title, items }: { title: string; items: string[] }) {
+  if (!items.length) return null;
+  return (
+    <div>
+      <h3 className="text-sm font-medium text-muted-foreground mb-2">{title}</h3>
+      <ul className="list-disc list-inside space-y-1 text-sm text-foreground">
+        {items.map((item, i) => <li key={i}>{item}</li>)}
+      </ul>
+    </div>
+  );
+}
+
 function formatDuration(ms: number | undefined, t: (key: string, options?: Record<string, unknown>) => string) {
   if (!ms || ms < 0) return null;
   if (ms < 1000) return t('generateResults.durationMs', { value: ms });
@@ -144,7 +170,7 @@ export function GenerateResults({ result, discoveredSources, onRegenerateSection
   };
 
   // Guard against incomplete result data
-  if (!result?.caseStructure || !result?.contentions || !result?.predictedOpponentCase || !result?.counters) {
+  if (!result?.caseStructure || !Array.isArray(result?.contentions) || !Array.isArray(result?.counters)) {
     return (
       <div className="rounded-lg border border-destructive/50 bg-destructive/5 p-6 text-center">
         <h2 className="text-lg font-semibold text-destructive mb-2">{t('generateResults.incomplete')}</h2>
@@ -155,6 +181,8 @@ export function GenerateResults({ result, discoveredSources, onRegenerateSection
     );
   }
 
+  const view = readCase(result);
+  const { opening, legacy } = view;
   const durationText = formatDuration(result.metadata?.durationMs, t);
   // Without web research, evidence is the model's own claim and is labelled that way.
   const researched = Boolean(discoveredSources?.length);
@@ -220,148 +248,182 @@ export function GenerateResults({ result, discoveredSources, onRegenerateSection
       />
       <ResearchedSources sources={discoveredSources} />
 
-      {/* Exordio (Introductor only) */}
-      {result.exordio && (result.exordio.hook || result.exordio.transition) && (
+      {/* Opening: the hook, an unclear term when the Introductor needs one, and the roadmap. */}
+      {(opening.hook || opening.definition || opening.roadmap || legacy.framework || legacy.burdenOfProof || legacy.definitions.length > 0) && (
         <SectionCard
-          title={t('generateResults.exordio')}
-          description={t('generateResults.exordioDesc')}
+          title={t('generateResults.opening')}
+          description={t('generateResults.openingDesc')}
           icon={<Sparkles className="h-5 w-5" />}
-          onRegenerate={regenerate('exordio')}
-          {...regenerateState('exordio')}
+          onRegenerate={regenerate('opening')}
+          {...regenerateState('opening')}
         >
           <div className="space-y-4">
-            <div>
-              <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.hook')}</h3>
-              <p className="text-foreground italic">{result.exordio.hook}</p>
-            </div>
-            <Separator />
-            <div>
-              <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.transition')}</h3>
-              <p className="text-foreground">{result.exordio.transition}</p>
-            </div>
+            {opening.hook && <Markdown className="italic">{opening.hook}</Markdown>}
+            {opening.definition && (
+              <div className="text-sm">
+                <span className="font-medium text-muted-foreground">{t('generateResults.definition')} </span>
+                <Markdown inline>{opening.definition}</Markdown>
+              </div>
+            )}
+            {opening.roadmap && (
+              <div>
+                <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.roadmap')}</h3>
+                <Markdown>{opening.roadmap}</Markdown>
+              </div>
+            )}
+            {/* Older cases kept these as their own sections; they show under plain names. */}
+            {legacy.framework && (
+              <div>
+                <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.legacyJudgeBy')}</h3>
+                <Markdown>{legacy.framework}</Markdown>
+              </div>
+            )}
+            {legacy.burdenOfProof && (
+              <div>
+                <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.legacyMustShow')}</h3>
+                <Markdown>{legacy.burdenOfProof}</Markdown>
+              </div>
+            )}
+            <LegacyList title={t('generateResults.legacyDefinitions')} items={legacy.definitions} />
           </div>
         </SectionCard>
       )}
 
-      {/* Case Structure */}
-      <SectionCard
-        title={t('generateResults.caseStructure')}
-        description={t('generateResults.caseStructureDesc')}
-        icon={<Target className="h-5 w-5" />}
-        onRegenerate={regenerate('structure')}
-        {...regenerateState('structure')}
-      >
-        <div className="space-y-4">
-          <div>
-            <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.thesis')}</h3>
-            <Markdown>{result.caseStructure.thesis}</Markdown>
-          </div>
-          <Separator />
-          <div>
-            <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.framework')}</h3>
-            <Markdown>{result.caseStructure.framework}</Markdown>
-          </div>
-          <Separator />
-          <div>
-            <h3 className="text-sm font-medium text-muted-foreground mb-1">{t('generateResults.burdenOfProof')}</h3>
-            <Markdown>{result.caseStructure.burdenOfProof}</Markdown>
+      {view.arguments.length > 0 && (
+        <SectionCard
+          title={t('generateResults.arguments')}
+          description={t('generateResults.argumentCount', { count: view.arguments.length })}
+          icon={<Shield className="h-5 w-5" />}
+          onRegenerate={regenerate('contentions')}
+          {...regenerateState('contentions')}
+        >
+          <div className="space-y-4">
+            {view.arguments.map((argument, index) => (
+              <ArgumentCard key={argument.id} argument={argument} index={index} unverified={!researched} />
+            ))}
           </div>
-          <div>
-            <h3 className="text-sm font-medium text-muted-foreground mb-2">{t('generateResults.keyDefinitions')}</h3>
-            <ul className="list-disc list-inside space-y-1 text-sm text-foreground">
-              {result.caseStructure.keyDefinitions?.map((def, i) => (
-                <li key={i}>{def}</li>
-              )) || <li className="text-muted-foreground">{t('generateResults.noDefinitions')}</li>}
-            </ul>
+        </SectionCard>
+      )}
+
+      {/* R2: the team's earlier arguments, backed up, instead of new ones. */}
+      {view.reinforce.length > 0 && (
+        <SectionCard
+          title={t('generateResults.reinforce')}
+          description={t('generateResults.reinforceDesc')}
+          icon={<Shield className="h-5 w-5" />}
+          onRegenerate={regenerate('reinforce')}
+          {...regenerateState('reinforce')}
+        >
+          <div className="space-y-4">
+            {view.reinforce.map((item, i) => (
+              <div key={i} className="rounded-lg border border-border bg-card p-4 space-y-2 motion-list-item">
+                {item.argument && <h3 className="font-semibold text-foreground">{item.argument}</h3>}
+                <Markdown className="text-sm">{item.text}</Markdown>
+              </div>
+            ))}
           </div>
-        </div>
-      </SectionCard>
+        </SectionCard>
+      )}
 
-      {/* Contentions */}
-      <SectionCard
-        title={t('generateResults.arguments')}
-        description={`${result.contentions?.length || 0} ${t('generateResults.structuredArguments')}`}
-        icon={<Shield className="h-5 w-5" />}
-        onRegenerate={regenerate('contentions')}
-        {...regenerateState('contentions')}
-      >
-        <div className="space-y-4">
-          {result.contentions?.map((contention, index) => (
-            <ArgumentCard key={contention.id} contention={contention} index={index} unverified={!researched} />
-          ))}
-        </div>
-      </SectionCard>
+      {/* Conclusor: the reasons we win take the place of new arguments. */}
+      {view.whyWeWin.length > 0 && (
+        <SectionCard
+          title={t('generateResults.whyWeWin')}
+          description={t('generateResults.whyWeWinDesc')}
+          icon={<Trophy className="h-5 w-5" />}
+          onRegenerate={regenerate('whyWeWin')}
+          {...regenerateState('whyWeWin')}
+        >
+          <ol className="space-y-3">
+            {view.whyWeWin.map((reason, i) => (
+              <li key={i} className="flex items-start gap-3 text-sm">
+                <span className="font-semibold text-primary">{i + 1}.</span>
+                <Markdown inline>{reason}</Markdown>
+              </li>
+            ))}
+          </ol>
+        </SectionCard>
+      )}
 
-      {/* Predicted Opponent Case */}
-      <SectionCard
-        title={t('generateResults.predictedOpponent')}
-        description={t('generateResults.predictedOpponentDesc')}
-        icon={<Swords className="h-5 w-5" />}
-        onRegenerate={regenerate('opponent')}
-        {...regenerateState('opponent')}
-      >
-        <div className="space-y-4">
-          <div>
-            <h3 className="text-sm font-medium text-muted-foreground mb-2">{t('generateResults.likelyArguments')}</h3>
-            <ul className="space-y-2">
-              {result.predictedOpponentCase?.likelyArguments?.map((arg, i) => (
-                <li key={i} className="flex items-start gap-2 text-sm">
-                  <span className="text-destructive mt-1">•</span>
-                  <span className="text-foreground">{arg}</span>
-                </li>
-              ))}
-            </ul>
-          </div>
-          <Separator />
-          <div>
-            <h3 className="text-sm font-medium text-muted-foreground mb-2">{t('generateResults.strategicWeaknesses')}</h3>
-            <ul className="space-y-2">
-              {result.predictedOpponentCase?.strategicWeaknesses?.map((weakness, i) => (
-                <li key={i} className="flex items-start gap-2 text-sm">
-                  <span className="text-amber-600 dark:text-amber-400 mt-1">•</span>
-                  <span className="text-foreground">{weakness}</span>
-                </li>
-              ))}
-            </ul>
-          </div>
-          <Separator />
-          <div>
-            <h3 className="text-sm font-medium text-muted-foreground mb-2">{t('generateResults.keyClashes')}</h3>
-            <div className="flex flex-wrap gap-2">
-              {result.predictedOpponentCase?.keyClashes?.map((clash, i) => (
-                <Badge key={i} variant="outline">{clash}</Badge>
-              ))}
-            </div>
+      {(view.ifTheySay.length > 0 || legacy.likelyArguments.length > 0 || legacy.weaknesses.length > 0 || legacy.clashes.length > 0) && (
+        <SectionCard
+          title={t('generateResults.ifTheySay')}
+          description={t('generateResults.ifTheySayDesc')}
+          icon={<Swords className="h-5 w-5" />}
+          onRegenerate={regenerate('counters')}
+          {...regenerateState('counters')}
+        >
+          <div className="space-y-4">
+            {view.ifTheySay.map((answer, i) => (
+              <div key={i} className="rounded-lg border border-border p-4 space-y-2">
+                {answer.theySay && (
+                  <div className="flex items-start gap-2">
+                    <Badge variant="destructive" className="shrink-0 text-xs">{t('generateResults.theySay')}</Badge>
+                    <span className="text-sm font-medium text-foreground">{answer.theySay}</span>
+                  </div>
+                )}
+                {answer.weAnswer && (
+                  <div className="text-sm">
+                    <span className="font-medium text-muted-foreground">{t('generateResults.weAnswer')} </span>
+                    <Markdown inline>{answer.weAnswer}</Markdown>
+                  </div>
+                )}
+                {answer.inRound && (
+                  <div className="bg-muted/50 rounded-md p-2">
+                    <span className="text-xs font-medium text-muted-foreground">{t('generateResults.legacySayItLike')} </span>
+                    <span className="text-sm text-foreground">{answer.inRound}</span>
+                  </div>
+                )}
+                {answer.source && (
+                  <p className="text-xs text-muted-foreground">
+                    <span className="font-medium">{t('generateResults.source')}</span> {answer.source}
+                  </p>
+                )}
+              </div>
+            ))}
+            <LegacyList title={t('generateResults.legacyAlsoSay')} items={legacy.likelyArguments} />
+            <LegacyList title={t('generateResults.legacyWeakSpots')} items={legacy.weaknesses} />
+            <LegacyList title={t('generateResults.legacyDecidingPoints')} items={legacy.clashes} />
           </div>
-        </div>
-      </SectionCard>
+        </SectionCard>
+      )}
 
-      {/* Prepared Counters */}
-      <SectionCard
-        title={t('generateResults.preparedCounters')}
-        description={t('generateResults.preparedCountersDesc')}
-        onRegenerate={regenerate('counters')}
-        {...regenerateState('counters')}
-      >
-        <div className="space-y-4">
-          {result.counters?.map((counter, i) => (
-            <div key={i} className="rounded-lg border border-border p-4 space-y-2">
-              <div className="flex items-center gap-2">
-                <Badge variant="destructive" className="text-xs">{t('generateResults.target')}</Badge>
-                <span className="text-sm font-medium text-foreground">{counter?.targetArgument}</span>
-              </div>
-              <div>
-                <span className="text-sm font-medium text-muted-foreground">{t('generateResults.counter')} </span>
-                <span className="text-sm text-foreground">{counter?.counterpoint}</span>
-              </div>
-              <div className="bg-muted/50 rounded-md p-2">
-                <span className="text-xs font-medium text-muted-foreground">{t('generateResults.rebuttal')} </span>
-                <span className="text-sm text-foreground">{counter?.rebuttal}</span>
-              </div>
-            </div>
-          ))}
-        </div>
-      </SectionCard>
+      {view.closingLine && (
+        <SectionCard
+          title={t('generateResults.closingLine')}
+          description={t('generateResults.closingLineDesc')}
+          icon={<Quote className="h-5 w-5" />}
+          onRegenerate={regenerate('closing')}
+          {...regenerateState('closing')}
+        >
+          <Markdown className="font-medium">{view.closingLine}</Markdown>
+        </SectionCard>
+      )}
+
+      {view.sources.length > 0 && (
+        <SectionCard
+          title={t('generateResults.sources')}
+          description={t('generateResults.sourcesDesc')}
+          icon={<BookOpen className="h-5 w-5" />}
+        >
+          <ul className="space-y-2 text-sm">
+            {view.sources.map((source, i) => (
+              <li key={i} className="min-w-0 break-words">
+                <span className="font-medium text-foreground">{sourceLabel(source)}</span>
+                {source.claim && <span className="text-foreground">{source.org ? ' – ' : ''}{source.claim}</span>}
+                {source.url && (
+                  <>
+                    {' – '}
+                    <a href={source.url} target="_blank" rel="noopener noreferrer" className="text-primary underline underline-offset-2 break-all">
+                      {source.url}
+                    </a>
+                  </>
+                )}
+              </li>
+            ))}
+          </ul>
+        </SectionCard>
+      )}
     </div>
   );
 }
diff --git a/src/components/features/sparring/SparringRound.tsx b/src/components/features/sparring/SparringRound.tsx
index b55fa27ec..089477ae1 100644
--- a/src/components/features/sparring/SparringRound.tsx
+++ b/src/components/features/sparring/SparringRound.tsx
@@ -51,10 +51,10 @@ function wordCount(value: string) {
 }
 
 const SCHOOL_ROLE_GUIDANCE: Partial<Record<SparringTurnKind, string>> = {
-  introductor: 'Open with an exordio, define the key terms, set the framework and thesis, then give the roadmap. Save the full arguments for R1.',
-  r1: 'Build the core arguments with claims, warrants, support, and impacts. Use the final part to anticipate or answer the strongest opposition.',
-  r2: 'Extend R1, answer the opponent directly, identify the central clashes, and compare the impacts. Do not simply repeat the case.',
-  conclusor: 'Add no new arguments. Crystallize the decisive clashes, weigh the round, and close with the reason your side wins.',
+  introductor: 'Open with a hook, say "we will show N arguments that prove…", and give each argument in short form. Explain a motion word in one line only if it is unclear. Save the full arguments for R1.',
+  r1: 'Build the arguments in full: the point, why it is true, evidence with its source and year, and why it matters. Use the last part to answer what they are most likely to say.',
+  r2: 'Bring no new arguments. Spend about 2 minutes backing up your team\'s arguments, then about 4 minutes answering theirs: "If they say…, we answer…".',
+  conclusor: 'Add no new arguments. Give two or three reasons your side won, then end with one clear closing line.',
 };
 
 export function SparringRound({
diff --git a/src/components/features/subscription/TrialBanner.tsx b/src/components/features/subscription/TrialBanner.tsx
index a6a8a88a9..889c2119b 100644
--- a/src/components/features/subscription/TrialBanner.tsx
+++ b/src/components/features/subscription/TrialBanner.tsx
@@ -6,16 +6,7 @@ import { useSubscription } from '@/hooks/use-subscription';
 import { useAuth } from '@/lib/supabase/AuthProvider';
 import { BILLING_ACTION_LABELS, billingAction } from '@/lib/billing/plan';
 import { PricingModal } from './PricingModal';
-
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-/** Calendar days from today to the trial's end on the reader's clock; 0 on its last day. */
-function trialDaysLeft(endsAt: string, now = new Date()): number | null {
-  const end = new Date(endsAt);
-  if (Number.isNaN(end.getTime()) || end.getTime() <= now.getTime()) return null;
-  const startOfDay = (date: Date) => new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
-  return Math.round((startOfDay(end) - startOfDay(now)) / DAY_MS);
-}
+import { trialDaysLeft } from '@debatelab/core/trial';
 
 function dismissedKey(userId: string, endsAt: string) {
   return `debatelab:trial-banner-dismissed:${userId}:${endsAt}`;
diff --git a/src/components/features/tools/discuss.ts b/src/components/features/tools/discuss.ts
index 35cc4912e..b2a46c616 100644
--- a/src/components/features/tools/discuss.ts
+++ b/src/components/features/tools/discuss.ts
@@ -42,7 +42,11 @@ export function generateDiscussPrompt(result: GenerateOutput, t: TFunction) {
     `**${t('discuss.generate.thesis', 'Thesis')}:** ${result.caseStructure.thesis}`,
     '',
     `**${t('discuss.generate.arguments', 'Arguments')}:**`,
-    ...result.contentions.map((contention, index) => `${index + 1}. ${contention.claim}`),
+    ...(result.contentions.length
+      ? result.contentions.map((contention, index) => `${index + 1}. ${contention.title ?? contention.claim}`)
+      : result.reinforce?.length
+        ? result.reinforce.map((item, index) => `${index + 1}. ${item.argument || item.text}`)
+        : (result.whyWeWin ?? []).map((reason, index) => `${index + 1}. ${reason}`)),
     '',
     t('discuss.generate.ask', 'Can we refine this?'),
   ].join('\n');
diff --git a/src/components/features/tools/result-text.ts b/src/components/features/tools/result-text.ts
index dfe9b6b70..f6907cf9c 100644
--- a/src/components/features/tools/result-text.ts
+++ b/src/components/features/tools/result-text.ts
@@ -2,27 +2,39 @@ import type { TFunction } from 'i18next';
 import type { BrainstormOutput, Idea } from '@/lib/ai/schemas/brainstorm';
 import type { FactoidsOutput } from '@/lib/ai/schemas/factoids';
 import type { GenerateOutput } from '@/lib/ai/schemas/generate';
+import { readCase, sourceLine } from '@debatelab/core/ai/case-view';
 
 // Plain-text versions of tool results for the Clipboard button, in what each result view shows.
 
 export function caseText(result: GenerateOutput): string {
+  const view = readCase(result);
   const lines: string[] = [];
-  lines.push(`THESIS: ${result.caseStructure?.thesis || ''}`);
-  lines.push(`FRAMEWORK: ${result.caseStructure?.framework || ''}`);
-  lines.push('');
-  result.contentions?.forEach((c, i) => {
-    lines.push(`CONTENTION #${i + 1}: ${c.claim}`);
-    lines.push(`  Reasoning: ${c.reasoning}`);
-    lines.push(`  Evidence: ${c.evidence}`);
-    lines.push(`  Impact: ${c.impact}`);
-    lines.push('');
+  const block = (title: string, body: string[]) => {
+    if (!body.length) return;
+    if (lines.length) lines.push('');
+    lines.push(title, ...body);
+  };
+  block('OPENING:', [
+    view.opening.hook,
+    view.opening.definition && `What we mean: ${view.opening.definition}`,
+    view.opening.roadmap,
+    view.legacy.framework && `How to judge this debate: ${view.legacy.framework}`,
+    view.legacy.burdenOfProof && `What we have to show: ${view.legacy.burdenOfProof}`,
+  ].filter((line): line is string => Boolean(line)).map((line) => `  ${line}`));
+  view.arguments.forEach((argument, i) => {
+    block(`ARGUMENT ${i + 1}: ${argument.title ?? argument.point}`, [
+      argument.title && argument.point && `  Point: ${argument.point}`,
+      argument.explanation && `  Explanation: ${argument.explanation}`,
+      argument.evidence && `  Evidence: ${argument.evidence}`,
+      argument.whyItMatters && `  Why it matters: ${argument.whyItMatters}`,
+    ].filter((line): line is string => Boolean(line)));
   });
-  if (result.counters?.length) {
-    lines.push('PREPARED COUNTERS:');
-    result.counters.forEach(c => {
-      lines.push(`  vs "${c.targetArgument}": ${c.counterpoint}`);
-    });
-  }
+  view.reinforce.forEach((item, i) => block(`BACKING UP ${item.argument || `ARGUMENT ${i + 1}`}:`, [`  ${item.text}`]));
+  block('WHY WE WIN:', view.whyWeWin.map((reason, i) => `  ${i + 1}. ${reason}`));
+  block('IF THEY SAY...', view.ifTheySay.map((answer) =>
+    `  "${answer.theySay}" -> ${answer.weAnswer}${answer.inRound ? ` ${answer.inRound}` : ''}${answer.source ? ` (${answer.source})` : ''}`));
+  if (view.closingLine) block('CLOSING LINE:', [`  ${view.closingLine}`]);
+  block('SOURCES:', view.sources.map((source) => `  - ${sourceLine(source)}`));
   return lines.join('\n');
 }
 
diff --git a/src/lib/ai/features/generate.ts b/src/lib/ai/features/generate.ts
index 60c16e0d7..ae84864a1 100644
--- a/src/lib/ai/features/generate.ts
+++ b/src/lib/ai/features/generate.ts
@@ -5,7 +5,7 @@ import { AIResponseError } from '../errors';
 import { callSupabaseAI, withOutputLanguage } from '../request';
 import type { LiveGeneration } from '../live';
 import { autosaveDiscoveredSources, parseDiscoveredSources, type ResultWithSources } from '../sources';
-import { transformGenerateResponse, expectedContentionCount } from '@debatelab/core/ai/generate-output';
+import { transformGenerateResponse, expectedContentionCount, hasExpectedArguments } from '@debatelab/core/ai/generate-output';
 
 /** Validates the transformed generate response before it can be rendered or persisted alongside sources. */
 function validateGenerateOutput(output: unknown): GenerateOutput {
@@ -29,7 +29,7 @@ export async function generateCase(input: GenerateInput, config: ProviderConfig,
       const data = rawData as { output: unknown; discoveredSources?: unknown };
       const result = validateGenerateOutput(transformGenerateResponse(data.output as Record<string, unknown>));
       const expectedCount = expectedContentionCount(input.length);
-      if (result.contentions.length !== expectedCount) {
+      if (!hasExpectedArguments(result, input)) {
         throw new AIResponseError('AI response did not contain the expected number of contentions.', {
           details: { expectedCount, actualCount: result.contentions.length },
         });
diff --git a/src/lib/export-utils.ts b/src/lib/export-utils.ts
index 48cbe4cf6..23a8a6e28 100644
--- a/src/lib/export-utils.ts
+++ b/src/lib/export-utils.ts
@@ -4,16 +4,19 @@ import type { AttackOutput } from './ai/schemas/attack';
 import type { BrainstormOutput } from './ai/schemas/brainstorm';
 import type { FactoidsOutput } from './ai/schemas/factoids';
 import type { SparringSession } from './stores/sparring-store';
+import {
+  buildAttackDocx,
+  buildBrainstormDocx,
+  buildCaseDocx,
+  buildFactoidsDocx,
+  buildSparringDocx,
+  hasCaseData,
+  type BuiltDocx,
+  type DocxContext,
+  type DocxModule,
+} from '@debatelab/core/export/docx';
 import { formatEuropeanDate, formatEuropeanDateTime } from './date-format';
 import { captureProductEvent } from '@/lib/observability';
-import {
-  formatSparringDuration,
-  getSparringCategoryLabel,
-  getSparringFormatLabel,
-  getSparringSideLabel,
-  getSparringTurnLabel,
-  getSparringWinnerLabel,
-} from './export-sparring-labels';
 
 /** Triggers a browser download from a Blob. */
 export function saveBlob(blob: Blob, filename: string): void {
@@ -27,162 +30,27 @@ export function saveBlob(blob: Blob, filename: string): void {
   URL.revokeObjectURL(url);
 }
 
+// The documents themselves are built in @debatelab/core, shared with the iOS app;
+// the builders throw on results missing the data they need.
+const docxContext: DocxContext = {
+  t: (key, options) => i18n.t(key, options),
+  formatDate: (date) => formatEuropeanDate(date),
+  formatDateTime: (date) => formatEuropeanDateTime(date),
+};
+
+/** Builds a Word document with the lazily loaded `docx` library and downloads it. */
+async function downloadDocx(build: (docx: DocxModule, ctx: DocxContext) => BuiltDocx, tool: string): Promise<void> {
+  // Dynamically import heavy libraries only when needed
+  const docx = await import('docx');
+  const { doc, fileName } = build(docx, docxContext);
+  const blob = await docx.Packer.toBlob(doc);
+  saveBlob(blob, fileName);
+  captureProductEvent('content_exported', { format: 'docx', tool });
+}
+
 export async function exportCaseToDocx(result: GenerateOutput): Promise<boolean> {
   try {
-    if (
-      !result?.metadata ||
-      !result.caseStructure ||
-      !Array.isArray(result.contentions) ||
-      !result.predictedOpponentCase ||
-      !Array.isArray(result.counters)
-    ) {
-      throw new Error('Missing required case data for export.');
-    }
-
-    // Dynamically import heavy libraries only when needed
-    const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = await import('docx');
-
-    const thesis = result.caseStructure.thesis?.trim() || 'Untitled Thesis';
-    const motion = (result.metadata as Record<string, unknown>)?.motion as string | undefined;
-    const thesisTitle = motion || thesis.split('.')[0] || thesis;
-    const framework = result.caseStructure.framework?.trim() || 'No framework provided.';
-    const burdenOfProof = result.caseStructure.burdenOfProof?.trim() || 'No burden of proof provided.';
-    const sideLabel = result.metadata.side === 'pro'
-      ? i18n.t('export.proposition')
-      : result.metadata.side === 'con'
-        ? i18n.t('export.opposition')
-        : 'Unknown';
-    const formatLabel = result.metadata.format ? result.metadata.format.toUpperCase() : 'UNKNOWN';
-    const generatedAtDate = result.metadata.generatedAt ? new Date(result.metadata.generatedAt) : null;
-    const generatedAtText = generatedAtDate && !Number.isNaN(generatedAtDate.getTime())
-      ? formatEuropeanDate(generatedAtDate)
-      : 'Unknown';
-
-    const contentions = Array.isArray(result.contentions) ? result.contentions : [];
-    const contentionsSection = contentions.length > 0
-      ? contentions.flatMap((c, i) => {
-        const claim = c?.claim || 'Untitled argument';
-        const reasoning = c?.reasoning || 'No reasoning provided.';
-        const evidence = c?.evidence || 'No evidence provided.';
-        const impact = c?.impact || 'No impact provided.';
-        return [
-          new Paragraph({
-            children: [new TextRun({ text: `Argument ${i + 1}: ${claim}`, bold: true, size: 28 })],
-            spacing: { before: 200, after: 100 },
-          }),
-          new Paragraph({
-            children: [new TextRun({ text: `${i18n.t('export.reasoning')}: `, italics: true }), new TextRun(reasoning)],
-            spacing: { after: 100 },
-          }),
-          new Paragraph({
-            children: [new TextRun({ text: `${i18n.t('export.evidence')}: `, italics: true }), new TextRun(evidence)],
-            spacing: { after: 100 },
-          }),
-          new Paragraph({
-            children: [new TextRun({ text: `${i18n.t('export.impact')}: `, italics: true }), new TextRun(impact)],
-            spacing: { after: 300 },
-          }),
-        ];
-      })
-      : [new Paragraph({ text: i18n.t('export.noArguments'), spacing: { after: 200 } })];
-
-    const predictedArguments = Array.isArray(result.predictedOpponentCase.likelyArguments)
-      ? result.predictedOpponentCase.likelyArguments
-      : [];
-    const predictedSection = predictedArguments.length > 0
-      ? predictedArguments.map(arg => new Paragraph({ text: "• " + arg, spacing: { after: 100 } }))
-      : [new Paragraph({ text: i18n.t('export.noOpponentArgs'), spacing: { after: 100 } })];
-
-    const counters = Array.isArray(result.counters) ? result.counters : [];
-    const countersSection = counters.length > 0
-      ? counters.flatMap(c => {
-        const target = c?.targetArgument || 'Unknown target';
-        const counterpoint = c?.counterpoint || 'No counterpoint provided.';
-        const rebuttal = c?.rebuttal || 'No rebuttal provided.';
-        return [
-          new Paragraph({
-            children: [new TextRun({ text: `${i18n.t('export.target')}: `, bold: true }), new TextRun(target)],
-          }),
-          new Paragraph({
-            children: [new TextRun({ text: `${i18n.t('export.counter')}: `, italics: true }), new TextRun(counterpoint)],
-          }),
-          new Paragraph({
-            children: [new TextRun({ text: `${i18n.t('export.rebuttal')}: `, italics: true }), new TextRun(rebuttal)],
-            spacing: { after: 200 },
-          }),
-        ];
-      })
-      : [new Paragraph({ text: i18n.t('export.noCounters'), spacing: { after: 200 } })];
-
-    const doc = new Document({
-      sections: [
-        {
-          properties: {},
-          children: [
-            // Title
-            new Paragraph({
-              text: i18n.t('export.debateCase') + ": " + thesisTitle,
-              heading: HeadingLevel.HEADING_1,
-              alignment: AlignmentType.CENTER,
-              spacing: { after: 400 },
-            }),
-
-            // Metadata
-            new Paragraph({
-              children: [
-                new TextRun({ text: `${i18n.t('export.side')}: `, bold: true }),
-                new TextRun(sideLabel),
-                new TextRun({ text: " | Format: ", bold: true }),
-                new TextRun(formatLabel),
-                new TextRun({ text: " | Date: ", bold: true }),
-                new TextRun(generatedAtText),
-              ],
-              spacing: { after: 400 },
-            }),
-
-            // Exordio (if present)
-            ...(result.exordio ? [
-              new Paragraph({ text: i18n.t('export.exordio').toUpperCase(), heading: HeadingLevel.HEADING_2 }),
-              new Paragraph({
-                children: [new TextRun({ text: `${i18n.t('export.hook')}: `, bold: true }), new TextRun(result.exordio.hook || '')],
-                spacing: { after: 100 },
-              }),
-              new Paragraph({
-                children: [new TextRun({ text: `${i18n.t('export.transition')}: `, bold: true }), new TextRun(result.exordio.transition || '')],
-                spacing: { after: 400 },
-              }),
-            ] : []),
-
-            // Thesis & Framework
-            new Paragraph({ text: i18n.t('export.thesis').toUpperCase(), heading: HeadingLevel.HEADING_2 }),
-            new Paragraph({ text: thesis, spacing: { after: 200 } }),
-
-            new Paragraph({ text: i18n.t('export.framework').toUpperCase(), heading: HeadingLevel.HEADING_2 }),
-            new Paragraph({ text: framework, spacing: { after: 200 } }),
-
-            new Paragraph({ text: i18n.t('export.burdenOfProof').toUpperCase(), heading: HeadingLevel.HEADING_2 }),
-            new Paragraph({ text: burdenOfProof, spacing: { after: 400 } }),
-
-            // Contentions
-            new Paragraph({ text: i18n.t('export.arguments').toUpperCase(), heading: HeadingLevel.HEADING_2 }),
-            ...contentionsSection,
-
-            // Predictions
-            new Paragraph({ text: i18n.t('export.predictedOpponent').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
-            ...predictedSection,
-
-            // Counters
-            new Paragraph({ text: i18n.t('export.counters').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
-            ...countersSection,
-          ],
-        },
-      ],
-    });
-
-    const blob = await Packer.toBlob(doc);
-    const fileSuffix = result.metadata.side || 'case';
-    saveBlob(blob, `DebateCase_${fileSuffix}.docx`);
-    captureProductEvent('content_exported', { format: 'docx', tool: 'generate' });
+    await downloadDocx((docx, ctx) => buildCaseDocx(docx, result, ctx), 'generate');
     return true;
   } catch (error) {
     console.error('Failed to export case to DOCX:', error);
@@ -190,97 +58,9 @@ export async function exportCaseToDocx(result: GenerateOutput): Promise<boolean>
   }
 }
 
-// ============================================================
-// ATTACK DOCX EXPORT
-// ============================================================
 export async function exportAttackToDocx(result: AttackOutput): Promise<boolean> {
   try {
-    if (!result?.overallAssessment || !Array.isArray(result.weaknesses)) {
-      throw new Error('Missing required attack data for export.');
-    }
-
-    const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = await import('docx');
-
-    const weaknesses = result.weaknesses || [];
-    const weaknessesSection = weaknesses.length > 0
-      ? weaknesses.flatMap((w, i) => [
-        new Paragraph({
-          children: [new TextRun({ text: `${i + 1}. [${w.severity?.toUpperCase()}] ${w.description}`, bold: true })],
-          spacing: { before: 200, after: 100 },
-        }),
-        new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.whyWeak')}: `, italics: true }), new TextRun(w.whyWeak || '')],
-          spacing: { after: 100 },
-        }),
-        new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.howOpponentAttacks')}: `, italics: true }), new TextRun(w.howOpponentAttacks || '')],
-          spacing: { after: 100 },
-        }),
-        new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.improvedVersion')}: `, italics: true }), new TextRun(w.improvedVersion || '')],
-          spacing: { after: 200 },
-        }),
-      ])
-      : [new Paragraph({ text: i18n.t('export.noWeaknesses'), spacing: { after: 200 } })];
-
-    const fallacies = result.fallaciesDetected || [];
-    const fallaciesSection = fallacies.length > 0
-      ? fallacies.flatMap(f => [
-        new Paragraph({
-          children: [new TextRun({ text: f.name, bold: true })],
-          spacing: { before: 100, after: 50 },
-        }),
-        new Paragraph({ text: `Location: ${f.location}`, spacing: { after: 50 } }),
-        new Paragraph({ text: f.explanation, spacing: { after: 150 } }),
-      ])
-      : [new Paragraph({ text: i18n.t('export.noFallacies'), spacing: { after: 200 } })];
-
-    const crossEx = result.crossExQuestions || [];
-    const crossExSection = crossEx.length > 0
-      ? crossEx.flatMap((q, i) => [
-        new Paragraph({
-          children: [new TextRun({ text: `Q${i + 1}: ${q.question}`, bold: true })],
-          spacing: { before: 100, after: 50 },
-        }),
-        new Paragraph({ text: `Purpose: ${q.purpose}`, spacing: { after: 50 } }),
-        new Paragraph({ text: `Expected Trap: ${q.expectedTrap}`, spacing: { after: 150 } }),
-      ])
-      : [new Paragraph({ text: i18n.t('export.noCrossEx'), spacing: { after: 200 } })];
-
-    const doc = new Document({
-      sections: [{
-        properties: {},
-        children: [
-          new Paragraph({
-            text: i18n.t('export.caseAttack'),
-            heading: HeadingLevel.HEADING_1,
-            alignment: AlignmentType.CENTER,
-            spacing: { after: 400 },
-          }),
-          new Paragraph({
-            children: [
-              new TextRun({ text: `${i18n.t('export.overallScore')}: `, bold: true }),
-              new TextRun(`${result.overallAssessment.score}/100`),
-            ],
-            spacing: { after: 200 },
-          }),
-          new Paragraph({ text: result.overallAssessment.summary, spacing: { after: 400 } }),
-
-          new Paragraph({ text: i18n.t('export.weaknesses').toUpperCase(), heading: HeadingLevel.HEADING_2 }),
-          ...weaknessesSection,
-
-          new Paragraph({ text: i18n.t('export.fallacies').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
-          ...fallaciesSection,
-
-          new Paragraph({ text: i18n.t('export.crossExQuestions').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
-          ...crossExSection,
-        ],
-      }],
-    });
-
-    const blob = await Packer.toBlob(doc);
-    saveBlob(blob, `AttackAnalysis_${new Date().toISOString().split('T')[0]}.docx`);
-    captureProductEvent('content_exported', { format: 'docx', tool: 'attack' });
+    await downloadDocx((docx, ctx) => buildAttackDocx(docx, result, ctx), 'attack');
     return true;
   } catch (error) {
     console.error('Failed to export attack to DOCX:', error);
@@ -288,86 +68,9 @@ export async function exportAttackToDocx(result: AttackOutput): Promise<boolean>
   }
 }
 
-// ============================================================
-// BRAINSTORM DOCX EXPORT
-// ============================================================
 export async function exportBrainstormToDocx(result: BrainstormOutput): Promise<boolean> {
   try {
-    const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = await import('docx');
-
-    const children: InstanceType<typeof Paragraph>[] = [
-      new Paragraph({
-        text: i18n.t('export.brainstormResults'),
-        heading: HeadingLevel.HEADING_1,
-        alignment: AlignmentType.CENTER,
-        spacing: { after: 400 },
-      }),
-    ];
-
-    // Top Five
-    const topFive = result.topFive || [];
-    if (topFive.length > 0) {
-      children.push(new Paragraph({ text: "TOP 5 ARGUMENT ANGLES", heading: HeadingLevel.HEADING_2 }));
-      topFive.forEach(item => {
-        children.push(new Paragraph({
-          children: [new TextRun({ text: `#${item.rank}: ${item.idea?.title || 'Untitled'}`, bold: true })],
-          spacing: { before: 150, after: 50 },
-        }));
-        children.push(new Paragraph({ text: item.idea?.description || '', spacing: { after: 50 } }));
-        children.push(new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.whyTop')}: `, italics: true }), new TextRun(item.whyTop || '')],
-          spacing: { after: 150 },
-        }));
-      });
-    }
-
-    // Mind Map
-    const mindmap = result.mindmap || [];
-    if (mindmap.length > 0) {
-      children.push(new Paragraph({ text: "ARGUMENT MAP", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }));
-      mindmap.forEach(category => {
-        children.push(new Paragraph({
-          children: [new TextRun({ text: category.category, bold: true })],
-          spacing: { before: 200, after: 100 },
-        }));
-        category.items?.forEach(idea => {
-          children.push(new Paragraph({
-            text: `• ${idea.title}: ${idea.description}`,
-            spacing: { after: 75 },
-          }));
-        });
-      });
-    }
-
-    // Buckets
-    const buckets = result.buckets || [];
-    if (buckets.length > 0) {
-      children.push(new Paragraph({ text: "ARGUMENT BUCKETS", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }));
-      buckets.forEach(bucket => {
-        children.push(new Paragraph({
-          children: [new TextRun({ text: bucket.name, bold: true })],
-          spacing: { before: 200, after: 50 },
-        }));
-        children.push(new Paragraph({ text: bucket.keyInsight || '', spacing: { after: 100 } }));
-        bucket.ideas?.forEach(idea => {
-          children.push(new Paragraph({ text: `• ${idea.title}`, spacing: { after: 50 } }));
-        });
-      });
-    }
-
-    // Next Steps
-    const nextSteps = result.nextSteps || [];
-    if (nextSteps.length > 0) {
-      children.push(new Paragraph({ text: "NEXT STEPS", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }));
-      nextSteps.forEach((step, i) => {
-        children.push(new Paragraph({ text: `${i + 1}. ${step}`, spacing: { after: 75 } }));
-      });
-    }
-
-    const doc = new Document({ sections: [{ properties: {}, children }] });
-    const blob = await Packer.toBlob(doc);
-    saveBlob(blob, `Brainstorm_${new Date().toISOString().split('T')[0]}.docx`);
-    captureProductEvent('content_exported', { format: 'docx', tool: 'brainstorm' });
+    await downloadDocx((docx, ctx) => buildBrainstormDocx(docx, result, ctx), 'brainstorm');
     return true;
   } catch (error) {
     console.error('Failed to export brainstorm to DOCX:', error);
@@ -375,74 +78,9 @@ export async function exportBrainstormToDocx(result: BrainstormOutput): Promise<
   }
 }
 
-// ============================================================
-// FACTOIDS DOCX EXPORT
-// ============================================================
 export async function exportFactoidsToDocx(result: FactoidsOutput): Promise<boolean> {
   try {
-    if (!Array.isArray(result.factoids)) {
-      throw new Error('Missing required factoids data for export.');
-    }
-
-    const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = await import('docx');
-
-    const factoids = result.factoids || [];
-    const factoidsSection = factoids.length > 0
-      ? factoids.flatMap((f, i) => [
-        new Paragraph({
-          children: [new TextRun({ text: `${i + 1}. ${f.shortClaim}`, bold: true })],
-          spacing: { before: 200, after: 100 },
-        }),
-        new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.keyFigure')}: `, italics: true }), new TextRun(f.keyFigure || '')],
-          spacing: { after: 50 },
-        }),
-        new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.context')}: `, italics: true }), new TextRun(f.context || '')],
-          spacing: { after: 50 },
-        }),
-        new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.howToUse')}: `, italics: true }), new TextRun(f.howToUse || '')],
-          spacing: { after: 50 },
-        }),
-        new Paragraph({
-          children: [
-            new TextRun({ text: `${i18n.t('export.source')}: `, italics: true }),
-            new TextRun(`${f.citation?.title || 'Unknown'} - ${f.citation?.publisher || 'Unknown'}`),
-          ],
-          spacing: { after: 200 },
-        }),
-      ])
-      : [new Paragraph({ text: i18n.t('export.noFactoids'), spacing: { after: 200 } })];
-
-    const warnings = result.warnings || [];
-    const warningsSection = warnings.length > 0
-      ? warnings.map(w => new Paragraph({ text: `⚠ ${w}`, spacing: { after: 75 } }))
-      : [];
-
-    const doc = new Document({
-      sections: [{
-        properties: {},
-        children: [
-          new Paragraph({
-            text: i18n.t('export.researchFactoids'),
-            heading: HeadingLevel.HEADING_1,
-            alignment: AlignmentType.CENTER,
-            spacing: { after: 400 },
-          }),
-          new Paragraph({ text: "FACTS & EVIDENCE", heading: HeadingLevel.HEADING_2 }),
-          ...factoidsSection,
-          ...(warningsSection.length > 0 ? [
-            new Paragraph({ text: "WARNINGS", heading: HeadingLevel.HEADING_2, spacing: { before: 400 } }),
-            ...warningsSection,
-          ] : []),
-        ],
-      }],
-    });
-
-    const blob = await Packer.toBlob(doc);
-    saveBlob(blob, `Factoids_${new Date().toISOString().split('T')[0]}.docx`);
-    captureProductEvent('content_exported', { format: 'docx', tool: 'factoids' });
+    await downloadDocx((docx, ctx) => buildFactoidsDocx(docx, result, ctx), 'factoids');
     return true;
   } catch (error) {
     console.error('Failed to export factoids to DOCX:', error);
@@ -552,13 +190,7 @@ async function callGoogleDocsEdgeFunction(
 }
 
 export async function exportCaseToGoogleDocs(result: GenerateOutput): Promise<GoogleDocsExportResult> {
-  if (
-    !result?.metadata ||
-    !result.caseStructure ||
-    !Array.isArray(result.contentions) ||
-    !result.predictedOpponentCase ||
-    !Array.isArray(result.counters)
-  ) {
+  if (!hasCaseData(result)) {
     return { success: false, error: 'Missing required case data for export.' };
   }
   return callGoogleDocsEdgeFunction('generate', result);
@@ -587,106 +219,7 @@ export async function exportFactoidsToGoogleDocs(result: FactoidsOutput): Promis
 // ============================================================
 export async function exportSparringToDocx(session: SparringSession): Promise<boolean> {
   try {
-    const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = await import('docx');
-    const totalTimeUsedSeconds = session.speeches.reduce((total, speech) => total + speech.timeUsedSeconds, 0);
-    const totalTimeLimitSeconds = session.speeches.reduce((total, speech) => total + speech.timeLimitSeconds, 0);
-    const scorecard = session.scorecard;
-    const metadata = [
-      [i18n.t('export.motion'), session.motion],
-      [i18n.t('export.sparringFormat'), getSparringFormatLabel(session.format)],
-      [i18n.t('export.side'), getSparringSideLabel(session.userSide)],
-      [i18n.t('export.sparringDifficulty'), i18n.t(`sparring.difficulty.${session.difficulty}`, session.difficulty)],
-      [i18n.t('export.sparringCompleted'), formatEuropeanDateTime(session.updatedAt)],
-      [i18n.t('export.sparringTimeUsed'), `${formatSparringDuration(totalTimeUsedSeconds)} / ${formatSparringDuration(totalTimeLimitSeconds)}`],
-    ].map(([label, value]) => new Paragraph({
-      children: [new TextRun({ text: `${label}: `, bold: true }), new TextRun(value)],
-      spacing: { after: 100 },
-    }));
-
-    const scorecardContent = scorecard
-      ? [
-        new Paragraph({ text: i18n.t('export.sparringTotals').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 300, after: 150 } }),
-        new Paragraph({
-          children: [
-            new TextRun({ text: `${i18n.t('export.sparringUser')}: `, bold: true }),
-            new TextRun(`${scorecard.userScore}/100`),
-            new TextRun({ text: `   ${i18n.t('export.sparringOpponent')}: `, bold: true }),
-            new TextRun(`${scorecard.aiScore}/100`),
-          ],
-          spacing: { after: 100 },
-        }),
-        new Paragraph({
-          children: [new TextRun({ text: `${i18n.t('export.sparringWinner')}: `, bold: true }), new TextRun(getSparringWinnerLabel(session))],
-          spacing: { after: 200 },
-        }),
-        new Paragraph({ text: i18n.t('export.sparringCategories').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 200, after: 150 } }),
-        ...scorecard.categories.flatMap((category) => [
-          new Paragraph({
-            children: [new TextRun({ text: `${getSparringCategoryLabel(category.name)}: `, bold: true }), new TextRun(`${category.userScore}/25 ${i18n.t('export.sparringUser').toLowerCase()} | ${category.aiScore}/25 ${i18n.t('export.sparringOpponent').toLowerCase()}`)],
-            spacing: { after: 75 },
-          }),
-          new Paragraph({ text: category.feedback, spacing: { after: 150 } }),
-        ]),
-        new Paragraph({ text: i18n.t('export.sparringFeedback').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 200, after: 150 } }),
-        new Paragraph({ text: scorecard.verdict, spacing: { after: 100 } }),
-        new Paragraph({ text: scorecard.overallFeedback, spacing: { after: 150 } }),
-        ...(scorecard.keyMoments.length > 0
-          ? [
-            new Paragraph({ text: i18n.t('export.sparringKeyMoments'), heading: HeadingLevel.HEADING_2, spacing: { before: 150, after: 75 } }),
-            ...scorecard.keyMoments.map((moment) => new Paragraph({ text: `• ${moment}`, spacing: { after: 75 } })),
-          ]
-          : []),
-        ...(scorecard.improvementAreas.length > 0
-          ? [
-            new Paragraph({ text: i18n.t('export.sparringImprovementAreas'), heading: HeadingLevel.HEADING_2, spacing: { before: 150, after: 75 } }),
-            ...scorecard.improvementAreas.map((area) => new Paragraph({ text: `• ${area}`, spacing: { after: 75 } })),
-          ]
-          : []),
-      ]
-      : [
-        new Paragraph({ text: i18n.t('export.sparringScorecardUnavailable'), spacing: { before: 300, after: 150 } }),
-      ];
-
-    const transcriptContent = session.speeches.length > 0
-      ? session.speeches.flatMap((speech, index) => [
-        new Paragraph({
-          children: [new TextRun({ text: `${index + 1}. ${getSparringTurnLabel(speech)}`, bold: true })],
-          spacing: { before: 200, after: 75 },
-        }),
-        new Paragraph({
-          children: [
-            new TextRun({ text: `${i18n.t('export.side')}: `, bold: true }),
-            new TextRun(getSparringSideLabel(speech.side)),
-            new TextRun({ text: `   ${i18n.t('export.sparringTimeUsed')}: `, bold: true }),
-            new TextRun(`${formatSparringDuration(speech.timeUsedSeconds)} / ${formatSparringDuration(speech.timeLimitSeconds)}`),
-          ],
-          spacing: { after: 75 },
-        }),
-        new Paragraph({ text: speech.content, spacing: { after: 150 } }),
-      ])
-      : [new Paragraph({ text: i18n.t('export.sparringNoTranscript'), spacing: { after: 150 } })];
-
-    const doc = new Document({
-      sections: [{
-        properties: {},
-        children: [
-          new Paragraph({
-            text: i18n.t('export.sparringTranscript'),
-            heading: HeadingLevel.HEADING_1,
-            alignment: AlignmentType.CENTER,
-            spacing: { after: 250 },
-          }),
-          ...metadata,
-          ...scorecardContent,
-          new Paragraph({ text: i18n.t('export.sparringTranscript').toUpperCase(), heading: HeadingLevel.HEADING_2, spacing: { before: 300, after: 150 } }),
-          ...transcriptContent,
-        ],
-      }],
-    });
-
-    const blob = await Packer.toBlob(doc);
-    saveBlob(blob, `SparringTranscript_${new Date(session.updatedAt).toISOString().slice(0, 10)}.docx`);
-    captureProductEvent('content_exported', { format: 'docx', tool: 'sparring' });
+    await downloadDocx((docx, ctx) => buildSparringDocx(docx, session, ctx), 'sparring');
     return true;
   } catch (error) {
     console.error('Failed to export sparring transcript to DOCX:', error);
diff --git a/src/lib/pdf-export-utils.ts b/src/lib/pdf-export-utils.ts
index d319dc883..28601cba0 100644
--- a/src/lib/pdf-export-utils.ts
+++ b/src/lib/pdf-export-utils.ts
@@ -3,6 +3,7 @@
 import i18n from '@/i18n';
 import site from '@/config/site.json';
 import type { GenerateOutput } from './ai/schemas/generate';
+import { readCase, sourceLine } from '@debatelab/core/ai/case-view';
 import type { AttackOutput } from './ai/schemas/attack';
 import type { BrainstormOutput } from './ai/schemas/brainstorm';
 import type { FactoidsOutput } from './ai/schemas/factoids';
@@ -342,7 +343,7 @@ export async function exportCaseToPdf(result: GenerateOutput): Promise<boolean>
             doc.setFontSize(12);
             doc.setFont(PDF_FONT, 'bold');
             doc.setTextColor(...COLORS.dark);
-            doc.text(i18n.t('export.contentionNumber', { number: index + 1 }), margin + textIndent, pdf.y);
+            doc.text(i18n.t('export.argumentNumber', { number: index + 1 }), margin + textIndent, pdf.y);
             pdf.y += 5;
 
             // Claim text
@@ -375,36 +376,34 @@ export async function exportCaseToPdf(result: GenerateOutput): Promise<boolean>
             pdf.y += 6;
         };
 
-        // Exordio (if present)
-        if (result.exordio) {
-            addSectionTitle(i18n.t('export.exordio'), COLORS.primary);
-            if (result.exordio.hook) {
-                addSubsectionLabel(i18n.t('export.hook'));
-                addParagraph(result.exordio.hook, 2);
-            }
-            if (result.exordio.transition) {
-                addSubsectionLabel(i18n.t('export.transition'));
-                addParagraph(result.exordio.transition, 2);
-            }
-            addSeparator(COLORS.primary);
-        }
+        const view = readCase(result);
 
-        // Case Structure: one section heading, then a label for each part, so no heading repeats.
-        addSectionTitle(i18n.t('export.caseStructure'));
-        addSubsectionLabel(i18n.t('export.thesis'));
-        addParagraph(result.caseStructure?.thesis || i18n.t('export.noThesis'), 2);
-        if (result.caseStructure?.framework) {
-            addSubsectionLabel(i18n.t('export.framework'));
-            addParagraph(result.caseStructure.framework, 2);
+        // Opening: hook, an unclear term when there is one, and the roadmap.
+        // Older cases add their framework, burden and definitions here.
+        addSectionTitle(i18n.t('export.opening'), COLORS.primary);
+        if (view.opening.hook) addParagraph(view.opening.hook, 2);
+        if (view.opening.definition) {
+            addSubsectionLabel(i18n.t('export.definition'));
+            addParagraph(view.opening.definition, 2);
+        }
+        addSubsectionLabel(i18n.t('export.roadmap'));
+        addParagraph(view.opening.roadmap || i18n.t('export.untitledCase'), 2);
+        if (view.legacy.framework) {
+            addSubsectionLabel(i18n.t('export.legacyJudgeBy'));
+            addParagraph(view.legacy.framework, 2);
         }
-        if (result.caseStructure?.burdenOfProof) {
-            addSubsectionLabel(i18n.t('export.burdenOfProof'));
-            addParagraph(result.caseStructure.burdenOfProof, 2);
+        if (view.legacy.burdenOfProof) {
+            addSubsectionLabel(i18n.t('export.legacyMustShow'));
+            addParagraph(view.legacy.burdenOfProof, 2);
+        }
+        if (view.legacy.definitions.length) {
+            addSubsectionLabel(i18n.t('export.legacyDefinitions'));
+            addBulletList(view.legacy.definitions);
         }
         addSeparator(COLORS.success);
 
         // Arguments with accent bars
-        if (result.contentions?.length) {
+        if (view.arguments.length) {
             addSectionTitle(i18n.t('export.arguments'), COLORS.success);
 
             // Cycle through accent colors for visual variety
@@ -415,33 +414,61 @@ export async function exportCaseToPdf(result: GenerateOutput): Promise<boolean>
                 [139, 92, 246], // Purple
             ];
 
-            result.contentions.forEach((c, i) => {
+            view.arguments.forEach((argument, i) => {
                 const details: { label: string; text: string }[] = [];
-                if (c.reasoning) details.push({ label: i18n.t('export.reasoning'), text: c.reasoning });
-                if (c.evidence) details.push({ label: i18n.t('export.evidence'), text: c.evidence });
-                if (c.impact) details.push({ label: i18n.t('export.impact'), text: c.impact });
+                if (argument.title && argument.point) details.push({ label: i18n.t('export.point'), text: argument.point });
+                if (argument.explanation) details.push({ label: i18n.t('export.explanation'), text: argument.explanation });
+                if (argument.evidence) details.push({ label: i18n.t('export.evidence'), text: argument.evidence });
+                if (argument.whyItMatters) details.push({ label: i18n.t('export.whyItMatters'), text: argument.whyItMatters });
 
-                addContentionBlock(i, c.claim || '', details, accentColors[i % accentColors.length]);
+                addContentionBlock(i, argument.title ?? argument.point, details, accentColors[i % accentColors.length]);
             });
             addSeparator(COLORS.warning);
         }
 
-        // Predicted Opponent Case
-        if (result.predictedOpponentCase?.likelyArguments?.length) {
-            addSectionTitle(i18n.t('export.predictedOpponent'), COLORS.warning);
-            addBulletList(result.predictedOpponentCase.likelyArguments);
-            addSeparator(COLORS.danger);
+        // R2: the team's earlier arguments, backed up, instead of new ones.
+        if (view.reinforce.length) {
+            addSectionTitle(i18n.t('export.reinforce'), COLORS.success);
+            view.reinforce.forEach((item) => {
+                if (item.argument) addSubsectionLabel(item.argument);
+                addParagraph(item.text, 2);
+            });
+            addSeparator(COLORS.warning);
         }
 
-        // Counters
-        if (result.counters?.length) {
-            addSectionTitle(i18n.t('export.counters'), COLORS.danger);
-            result.counters.forEach((c) => {
-                addSubsectionLabel(`${i18n.t('export.target')}: ${c.targetArgument || ''}`);
-                if (c.counterpoint) addParagraph(`${i18n.t('export.counter')}: ${c.counterpoint}`, 4);
-                if (c.rebuttal) addParagraph(`${i18n.t('export.rebuttal')}: ${c.rebuttal}`, 4);
+        // Conclusor: the reasons we win replace new arguments.
+        if (view.whyWeWin.length) {
+            addSectionTitle(i18n.t('export.whyWeWin'), COLORS.success);
+            view.whyWeWin.forEach((reason, i) => addParagraph(`${i + 1}. ${reason}`, 2));
+            addSeparator(COLORS.warning);
+        }
+
+        // If they say…: their claim, our answer, the source.
+        if (view.ifTheySay.length || view.legacy.likelyArguments.length) {
+            addSectionTitle(i18n.t('export.ifTheySay'), COLORS.danger);
+            view.ifTheySay.forEach((answer) => {
+                addSubsectionLabel(`${i18n.t('export.theySay')}: ${answer.theySay}`);
+                if (answer.weAnswer) addParagraph(`${i18n.t('export.weAnswer')}: ${answer.weAnswer}`, 4);
+                if (answer.inRound) addParagraph(`${i18n.t('export.legacySayItLike')}: ${answer.inRound}`, 4);
+                if (answer.source) addParagraph(`${i18n.t('export.source')}: ${answer.source}`, 4);
                 pdf.y += 3;
             });
+            if (view.legacy.likelyArguments.length) {
+                addSubsectionLabel(i18n.t('export.legacyAlsoSay'));
+                addBulletList(view.legacy.likelyArguments);
+            }
+        }
+
+        if (view.closingLine) {
+            addSeparator(COLORS.primary);
+            addSectionTitle(i18n.t('export.closingLine'), COLORS.primary);
+            addParagraph(view.closingLine, 2);
+        }
+
+        if (view.sources.length) {
+            addSeparator(COLORS.secondary);
+            addSectionTitle(i18n.t('export.sources'), COLORS.secondary);
+            addBulletList(view.sources.map(sourceLine));
         }
 
         addFooter();
diff --git a/src/locales/en.json b/src/locales/en.json
index 10a8951c0..c1c015d71 100644
--- a/src/locales/en.json
+++ b/src/locales/en.json
@@ -1090,34 +1090,10 @@
     "save": "Save",
     "discuss": "Discuss",
     "flowcharts": "Flowcharts",
-    "exordio": "Exordio",
-    "exordioDesc": "Your compelling opening",
-    "hook": "Hook",
-    "transition": "Transition",
-    "caseStructure": "Case structure",
-    "caseStructureDesc": "Your argument framework",
-    "thesis": "Thesis",
-    "framework": "Framework",
-    "burdenOfProof": "Burden of proof",
-    "keyDefinitions": "Key definitions",
-    "noDefinitions": "No definitions provided",
     "arguments": "Arguments",
-    "structuredArguments": "structured arguments",
-    "predictedOpponent": "Predicted opponent case",
-    "predictedOpponentDesc": "What they'll likely argue",
-    "likelyArguments": "Likely arguments",
-    "strategicWeaknesses": "Strategic weaknesses",
-    "keyClashes": "Key clashes",
-    "preparedCounters": "Prepared counters",
-    "preparedCountersDesc": "Ready-to-use rebuttals",
     "needsSource": "Needs source",
-    "reasoning": "Reasoning:",
     "evidence": "Evidence:",
     "searchSuggestion": "Search suggestion:",
-    "impact": "Impact:",
-    "target": "Target",
-    "counter": "Counter:",
-    "rebuttal": "Rebuttal:",
     "exportedGdocs": "Case exported to Google Docs!",
     "open": "Open",
     "exportFailed": "Failed to export to Google Docs",
@@ -1127,7 +1103,36 @@
     "undo": "Undo",
     "resultTitle": "Your case",
     "unverified": "Unverified",
-    "unresearchedCaveat": "AI-generated, and no web research backs this evidence. Check facts and sources before using them in a round."
+    "unresearchedCaveat": "AI-generated, and no web research backs this evidence. Check facts and sources before using them in a round.",
+    "opening": "Opening",
+    "openingDesc": "How your speech starts",
+    "definition": "What we mean:",
+    "roadmap": "What we will show",
+    "argumentCount_one": "{{count}} argument",
+    "argumentCount_other": "{{count}} arguments",
+    "point": "Point:",
+    "explanation": "Explanation:",
+    "whyItMatters": "Why it matters:",
+    "ifTheySay": "If they say…",
+    "ifTheySayDesc": "Their likely claims and your answers",
+    "theySay": "They say",
+    "weAnswer": "We answer:",
+    "source": "Source:",
+    "whyWeWin": "Why we win",
+    "whyWeWinDesc": "What the judge should remember",
+    "closingLine": "Closing line",
+    "closingLineDesc": "Your last sentence",
+    "sources": "Sources",
+    "sourcesDesc": "Everything this case cites",
+    "reinforce": "Backing up our case",
+    "reinforceDesc": "About 2 minutes on the arguments your team already made",
+    "legacyJudgeBy": "How to judge this debate",
+    "legacyMustShow": "What we have to show",
+    "legacyDefinitions": "What we mean by the motion",
+    "legacyAlsoSay": "They may also say",
+    "legacyWeakSpots": "Where we're weakest",
+    "legacyDecidingPoints": "What the debate comes down to",
+    "legacySayItLike": "Say it like this:"
   },
   "attackForm": {
     "argument": "Your argument",
@@ -1873,8 +1878,6 @@
     "unknown": "Unknown",
     "standard": "Standard",
     "format": "Format",
-    "contentionNumber": "Contention #{{number}}",
-    "noThesis": "No thesis provided.",
     "assessmentSummary": "Assessment summary",
     "noSummary": "No summary provided.",
     "strengthAreas": "Strength areas",
@@ -1914,17 +1917,7 @@
       "unverified": "Unverified",
       "pending": "Pending"
     },
-    "reasoning": "Reasoning",
     "evidence": "Evidence",
-    "impact": "Impact",
-    "hook": "Hook",
-    "transition": "Transition",
-    "noArguments": "No arguments provided.",
-    "noOpponentArgs": "No predicted opponent arguments provided.",
-    "noCounters": "No counters provided.",
-    "target": "Target",
-    "counter": "Counter",
-    "rebuttal": "Rebuttal",
     "debateCase": "Debate case",
     "side": "Side",
     "proposition": "In favor",
@@ -1945,15 +1938,7 @@
     "howToUse": "How to use",
     "source": "Source",
     "noFactoids": "No factoids found.",
-    "exordio": "Exordio",
-    "caseStructure": "Case structure",
-    "thesis": "Thesis",
-    "framework": "Framework",
-    "burdenOfProof": "Burden of proof",
-    "keyDefinitions": "Key definitions",
     "arguments": "Arguments",
-    "predictedOpponent": "Predicted opponent case",
-    "counters": "Prepared counters",
     "weaknesses": "Weaknesses identified",
     "fallacies": "Fallacies detected",
     "crossExQuestions": "Cross-examination questions",
@@ -1982,7 +1967,26 @@
     "factoidsSummary_one": "{{count}} fact • {{verified}} verified",
     "factoidsSummary_other": "{{count}} facts • {{verified}} verified",
     "topIdeasCount_one": "{{count}} top idea",
-    "topIdeasCount_other": "{{count}} top ideas"
+    "topIdeasCount_other": "{{count}} top ideas",
+    "opening": "Opening",
+    "roadmap": "What we will show",
+    "definition": "What we mean",
+    "argumentNumber": "Argument {{number}}",
+    "point": "Point",
+    "whyItMatters": "Why it matters",
+    "ifTheySay": "If they say…",
+    "theySay": "They say",
+    "weAnswer": "We answer",
+    "whyWeWin": "Why we win",
+    "closingLine": "Closing line",
+    "sources": "Sources",
+    "reinforce": "Backing up our case",
+    "legacyJudgeBy": "How to judge this debate",
+    "legacyMustShow": "What we have to show",
+    "legacyDefinitions": "What we mean by the motion",
+    "legacyAlsoSay": "They may also say",
+    "legacySayItLike": "Say it like this",
+    "untitledCase": "Untitled case"
   },
   "sparring": {
     "pro": "Pro",
@@ -2029,10 +2033,10 @@
       "hard": "Ruthless"
     },
     "roleGuidance": {
-      "introductor": "Open with an exordio, define the key terms, set the framework and thesis, then give the roadmap. Save the full arguments for R1.",
-      "r1": "Build the core arguments with claims, warrants, support, and impacts. Use the final part to anticipate or answer the strongest opposition.",
-      "r2": "Extend R1, answer the opponent directly, identify the central clashes, and compare the impacts. Do not simply repeat the case.",
-      "conclusor": "Add no new arguments. Crystallize the decisive clashes, weigh the round, and close with the reason your side wins."
+      "introductor": "Open with a hook, say \"we will show N arguments that prove…\", and give each argument in short form. Explain a motion word in one line only if it is unclear. Save the full arguments for R1.",
+      "r1": "Build the arguments in full: the point, why it is true, evidence with its source and year, and why it matters. Use the last part to answer what they are most likely to say.",
+      "r2": "Bring no new arguments. Spend about 2 minutes backing up your team's arguments, then about 4 minutes answering theirs: \"If they say…, we answer…\".",
+      "conclusor": "Add no new arguments. Give two or three reasons your side won, then end with one clear closing line."
     },
     "category": {
       "Logic": "Logic",
@@ -2708,9 +2712,6 @@
       "done": "Done",
       "openItem": "Open {{title}}"
     },
-    "offline": {
-      "notice": "Offline: showing saved copies. AI and saving wait for the connection."
-    },
     "debates": {
       "search": "Search motions",
       "noMatches": "No debates match your search.",
@@ -2969,6 +2970,65 @@
     "permissions": {
       "speechRecognition": "DebateOwl turns your voice into text when you dictate a question, a Crossfire answer or a Sparring speech. Apple processes the audio to recognize it.",
       "microphone": "DebateOwl uses the microphone while you dictate a question, a Crossfire answer or a Sparring speech."
+    },
+    "sidebar": {
+      "dashboard": "Dashboard",
+      "sources": "Sources",
+      "account": "Account and settings",
+      "noDebate": "No current debate",
+      "collapseHint": "Hides this section’s tools",
+      "expandHint": "Shows this section’s tools"
+    },
+    "trialBanner": {
+      "seePlan": "See plan"
+    },
+    "tour": {
+      "progress": "Step {{step}} of {{steps}}"
+    },
+    "a11y": {
+      "answerReady": "Answer ready",
+      "resultReady": "Ready: {{title}}"
+    },
+    "share": {
+      "shareLink": "Share link",
+      "linkCopied": "Link copied",
+      "failed": "Could not create a share link. Try again.",
+      "limitReached": "You've reached the daily share limit ({{limit}}). Try again tomorrow.",
+      "tooLarge": "This is too large to share as a link.",
+      "signIn": "Sign in again to share a link.",
+      "timeout": "Creating the link took too long. Try again.",
+      "openWebsite": "Open on the website",
+      "unknownKind": "This shared item can only be opened on the website."
+    },
+    "widget": {
+      "spar": "Spar",
+      "description": "Your motion and preparation at a glance."
+    },
+    "quickActions": {
+      "startTimer": "Start timer"
+    },
+    "offlineQueue": {
+      "notice": "Offline: showing saved copies. New notes, source edits and switches sync when you're back online. AI and other changes wait for the connection.",
+      "pending_one": "{{count}} change will sync when you're back online",
+      "pending_other": "{{count}} changes will sync when you're back online",
+      "syncing_one": "{{count}} change is waiting to sync",
+      "syncing_other": "{{count}} changes are waiting to sync",
+      "waiting": "Waiting to sync",
+      "syncsWhenOnline": "Saved on this phone. It syncs when you're back online.",
+      "syncingSoon": "Saved on this phone. It syncs as soon as the server can be reached.",
+      "noteQueuedTitle": "Note saved on this phone",
+      "noteQueuedDesc": "It's added to your Library when you're back online.",
+      "changeQueuedTitle": "Saved on this phone",
+      "changeQueuedDesc": "It syncs when you're back online.",
+      "synced_one": "{{count}} change synced",
+      "synced_other": "{{count}} changes synced",
+      "refusedTitle_one": "{{count}} change could not be saved",
+      "refusedTitle_other": "{{count}} changes could not be saved",
+      "refusedDesc_one": "The server refused it, so it was removed from this phone.",
+      "refusedDesc_other": "The server refused them, so they were removed from this phone.",
+      "noteRefused": "The server refused the note \"{{title}}\", so it was removed from this phone.",
+      "notKeptTitle": "Not saved on this phone yet",
+      "notKeptDesc": "Your changes sync when you are back online. Keep the app open until then."
     }
   }
 }
diff --git a/src/locales/es.json b/src/locales/es.json
index d2b12546a..d14d3feb2 100644
--- a/src/locales/es.json
+++ b/src/locales/es.json
@@ -1090,34 +1090,10 @@
     "save": "Guardar",
     "discuss": "Discutir",
     "flowcharts": "Diagramas",
-    "exordio": "Exordio",
-    "exordioDesc": "Tu apertura convincente",
-    "hook": "Gancho",
-    "transition": "Transición",
-    "caseStructure": "Estructura del caso",
-    "caseStructureDesc": "Tu marco argumentativo",
-    "thesis": "Tesis",
-    "framework": "Marco",
-    "burdenOfProof": "Carga de la prueba",
-    "keyDefinitions": "Definiciones clave",
-    "noDefinitions": "No se proporcionaron definiciones",
     "arguments": "Argumentos",
-    "structuredArguments": "argumentos estructurados",
-    "predictedOpponent": "Caso predicho del oponente",
-    "predictedOpponentDesc": "Lo que probablemente argumentarán",
-    "likelyArguments": "Argumentos probables",
-    "strategicWeaknesses": "Debilidades estratégicas",
-    "keyClashes": "Choques clave",
-    "preparedCounters": "Contra-argumentos preparados",
-    "preparedCountersDesc": "Refutaciones listas para usar",
     "needsSource": "Necesita fuente",
-    "reasoning": "Razonamiento:",
     "evidence": "Evidencia:",
     "searchSuggestion": "Sugerencia de búsqueda:",
-    "impact": "Impacto:",
-    "target": "Objetivo",
-    "counter": "Contra:",
-    "rebuttal": "Refutación:",
     "exportedGdocs": "¡Caso exportado a Google Docs!",
     "open": "Abrir",
     "exportFailed": "Error al exportar a Google Docs",
@@ -1127,7 +1103,36 @@
     "undo": "Deshacer",
     "resultTitle": "Tu caso",
     "unverified": "Sin verificar",
-    "unresearchedCaveat": "Generado por IA, y ninguna búsqueda web respalda esta evidencia. Comprueba los datos y las fuentes antes de usarlos en una ronda."
+    "unresearchedCaveat": "Generado por IA, y ninguna búsqueda web respalda esta evidencia. Comprueba los datos y las fuentes antes de usarlos en una ronda.",
+    "opening": "Apertura",
+    "openingDesc": "Cómo empieza tu discurso",
+    "definition": "Qué entendemos por:",
+    "roadmap": "Lo que vamos a demostrar",
+    "argumentCount_one": "{{count}} argumento",
+    "argumentCount_other": "{{count}} argumentos",
+    "point": "Idea:",
+    "explanation": "Explicación:",
+    "whyItMatters": "Por qué importa:",
+    "ifTheySay": "Si dicen…",
+    "ifTheySayDesc": "Lo que probablemente dirán y tus respuestas",
+    "theySay": "Dicen",
+    "weAnswer": "Respondemos:",
+    "source": "Fuente:",
+    "whyWeWin": "Por qué ganamos",
+    "whyWeWinDesc": "Lo que el jurado debe recordar",
+    "closingLine": "Frase de cierre",
+    "closingLineDesc": "Tu última frase",
+    "sources": "Fuentes",
+    "sourcesDesc": "Todo lo que cita tu caso",
+    "reinforce": "Reforzamos nuestro caso",
+    "reinforceDesc": "Unos 2 minutos sobre los argumentos que tu equipo ya dio",
+    "legacyJudgeBy": "Cómo juzgar este debate",
+    "legacyMustShow": "Lo que tenemos que demostrar",
+    "legacyDefinitions": "Qué entendemos por la moción",
+    "legacyAlsoSay": "También pueden decir",
+    "legacyWeakSpots": "Dónde somos más débiles",
+    "legacyDecidingPoints": "En qué se decide el debate",
+    "legacySayItLike": "Dilo así:"
   },
   "attackForm": {
     "argument": "Tu argumento",
@@ -1873,8 +1878,6 @@
     "unknown": "Desconocido",
     "standard": "Estándar",
     "format": "Formato",
-    "contentionNumber": "Argumento n.º {{number}}",
-    "noThesis": "No se proporcionó ninguna tesis.",
     "assessmentSummary": "Resumen de la evaluación",
     "noSummary": "No se proporcionó ningún resumen.",
     "strengthAreas": "Puntos fuertes",
@@ -1914,17 +1917,7 @@
       "unverified": "No verificado",
       "pending": "Pendiente"
     },
-    "reasoning": "Razonamiento",
     "evidence": "Evidencia",
-    "impact": "Impacto",
-    "hook": "Gancho",
-    "transition": "Transición",
-    "noArguments": "No se proporcionaron argumentos.",
-    "noOpponentArgs": "No se proporcionaron argumentos predichos del oponente.",
-    "noCounters": "No se proporcionaron contra-argumentos.",
-    "target": "Objetivo",
-    "counter": "Contra",
-    "rebuttal": "Refutación",
     "debateCase": "Caso de debate",
     "side": "Lado",
     "proposition": "A favor",
@@ -1945,15 +1938,7 @@
     "howToUse": "Cómo usar",
     "source": "Fuente",
     "noFactoids": "No se encontraron datos.",
-    "exordio": "Exordio",
-    "caseStructure": "Estructura del caso",
-    "thesis": "Tesis",
-    "framework": "Marco",
-    "burdenOfProof": "Carga de la prueba",
-    "keyDefinitions": "Definiciones clave",
     "arguments": "Argumentos",
-    "predictedOpponent": "Caso predicho del oponente",
-    "counters": "Contra-argumentos preparados",
     "weaknesses": "Debilidades identificadas",
     "fallacies": "Falacias detectadas",
     "crossExQuestions": "Preguntas de interrogatorio cruzado",
@@ -1982,7 +1967,26 @@
     "factoidsSummary_one": "{{count}} dato • Verificados: {{verified}}",
     "factoidsSummary_other": "{{count}} datos • Verificados: {{verified}}",
     "topIdeasCount_one": "{{count}} idea destacada",
-    "topIdeasCount_other": "{{count}} ideas destacadas"
+    "topIdeasCount_other": "{{count}} ideas destacadas",
+    "opening": "Apertura",
+    "roadmap": "Lo que vamos a demostrar",
+    "definition": "Qué entendemos por",
+    "argumentNumber": "Argumento {{number}}",
+    "point": "Idea",
+    "whyItMatters": "Por qué importa",
+    "ifTheySay": "Si dicen…",
+    "theySay": "Dicen",
+    "weAnswer": "Respondemos",
+    "whyWeWin": "Por qué ganamos",
+    "closingLine": "Frase de cierre",
+    "sources": "Fuentes",
+    "reinforce": "Reforzamos nuestro caso",
+    "legacyJudgeBy": "Cómo juzgar este debate",
+    "legacyMustShow": "Lo que tenemos que demostrar",
+    "legacyDefinitions": "Qué entendemos por la moción",
+    "legacyAlsoSay": "También pueden decir",
+    "legacySayItLike": "Dilo así",
+    "untitledCase": "Caso sin título"
   },
   "sparring": {
     "pro": "A favor",
@@ -2029,10 +2033,10 @@
       "hard": "Despiadado"
     },
     "roleGuidance": {
-      "introductor": "Abre con un exordio, define los términos clave, fija el marco y la tesis, y presenta la hoja de ruta. Reserva los argumentos completos para R1.",
-      "r1": "Construye los argumentos centrales con afirmaciones, razonamientos, apoyo e impactos. Usa la parte final para anticipar o responder a la oposición más fuerte.",
-      "r2": "Amplía R1, responde directamente al oponente, identifica los choques centrales y compara los impactos. No te limites a repetir el caso.",
-      "conclusor": "No añadas argumentos nuevos. Cristaliza los choques decisivos, sopesa la ronda y cierra explicando por qué gana tu lado."
+      "introductor": "Empieza con un gancho, di «vamos a demostrar N argumentos que prueban que…» y presenta cada argumento en pocas palabras. Explica una palabra de la moción en una línea solo si no está clara. Deja los argumentos completos para el R1.",
+      "r1": "Desarrolla los argumentos completos: la idea, por qué es cierta, la evidencia con su fuente y año, y por qué importa. Usa la última parte para responder lo que probablemente dirán.",
+      "r2": "No traigas argumentos nuevos. Dedica unos 2 minutos a reforzar los argumentos de tu equipo y unos 4 minutos a responder los suyos: «Si dicen…, respondemos…».",
+      "conclusor": "No añadas argumentos nuevos. Da dos o tres razones por las que tu lado ganó y termina con una frase de cierre clara."
     },
     "category": {
       "Logic": "Lógica",
@@ -2708,9 +2712,6 @@
       "done": "Listo",
       "openItem": "Abrir {{title}}"
     },
-    "offline": {
-      "notice": "Sin conexión: se muestran las copias guardadas. La IA y el guardado esperan a la conexión."
-    },
     "debates": {
       "search": "Buscar mociones",
       "noMatches": "Ningún debate coincide con tu búsqueda.",
@@ -2969,6 +2970,65 @@
     "permissions": {
       "speechRecognition": "DebateOwl convierte tu voz en texto cuando dictas una pregunta, una respuesta de Interrogatorio o un discurso de Sparring. Apple procesa el audio para reconocerlo.",
       "microphone": "DebateOwl usa el micrófono mientras dictas una pregunta, una respuesta de Interrogatorio o un discurso de Sparring."
+    },
+    "sidebar": {
+      "dashboard": "Panel",
+      "sources": "Fuentes",
+      "account": "Cuenta y ajustes",
+      "noDebate": "Ningún debate actual",
+      "collapseHint": "Oculta las herramientas de esta sección",
+      "expandHint": "Muestra las herramientas de esta sección"
+    },
+    "trialBanner": {
+      "seePlan": "Ver plan"
+    },
+    "tour": {
+      "progress": "Paso {{step}} de {{steps}}"
+    },
+    "a11y": {
+      "answerReady": "Respuesta lista",
+      "resultReady": "Listo: {{title}}"
+    },
+    "share": {
+      "shareLink": "Compartir enlace",
+      "linkCopied": "Enlace copiado",
+      "failed": "No se pudo crear el enlace para compartir. Inténtalo de nuevo.",
+      "limitReached": "Has alcanzado el límite diario de enlaces compartidos ({{limit}}). Inténtalo de nuevo mañana.",
+      "tooLarge": "Es demasiado grande para compartirlo como enlace.",
+      "signIn": "Vuelve a iniciar sesión para compartir un enlace.",
+      "timeout": "Crear el enlace tardó demasiado. Inténtalo de nuevo.",
+      "openWebsite": "Abrir en el sitio web",
+      "unknownKind": "Este contenido compartido solo se puede abrir en el sitio web."
+    },
+    "widget": {
+      "spar": "Entrenar",
+      "description": "Tu moción y tu preparación de un vistazo."
+    },
+    "quickActions": {
+      "startTimer": "Iniciar cronómetro"
+    },
+    "offlineQueue": {
+      "notice": "Sin conexión: se muestran copias guardadas. Las notas nuevas, los cambios en las fuentes y los interruptores se sincronizan cuando vuelvas a tener conexión. La IA y los demás cambios esperan a la conexión.",
+      "pending_one": "{{count}} cambio se sincronizará cuando vuelvas a tener conexión",
+      "pending_other": "{{count}} cambios se sincronizarán cuando vuelvas a tener conexión",
+      "syncing_one": "{{count}} cambio está esperando para sincronizarse",
+      "syncing_other": "{{count}} cambios están esperando para sincronizarse",
+      "waiting": "Pendiente de sincronizar",
+      "syncsWhenOnline": "Guardado en este teléfono. Se sincroniza cuando vuelvas a tener conexión.",
+      "syncingSoon": "Guardado en este teléfono. Se sincroniza en cuanto se pueda conectar con el servidor.",
+      "noteQueuedTitle": "Nota guardada en este teléfono",
+      "noteQueuedDesc": "Se añadirá a la Biblioteca cuando vuelvas a tener conexión.",
+      "changeQueuedTitle": "Guardado en este teléfono",
+      "changeQueuedDesc": "Se sincroniza cuando vuelvas a tener conexión.",
+      "synced_one": "{{count}} cambio sincronizado",
+      "synced_other": "{{count}} cambios sincronizados",
+      "refusedTitle_one": "No se pudo guardar {{count}} cambio",
+      "refusedTitle_other": "No se pudieron guardar {{count}} cambios",
+      "refusedDesc_one": "El servidor lo rechazó, así que se quitó de este teléfono.",
+      "refusedDesc_other": "El servidor los rechazó, así que se quitaron de este teléfono.",
+      "noteRefused": "El servidor rechazó la nota \"{{title}}\", así que se quitó de este teléfono.",
+      "notKeptTitle": "Aún no se guardó en este teléfono",
+      "notKeptDesc": "Tus cambios se sincronizan cuando vuelvas a estar en línea. Mantén la app abierta hasta entonces."
     }
   }
 }
diff --git a/src/locales/hu.json b/src/locales/hu.json
index 109356bb1..5d72e90b1 100644
--- a/src/locales/hu.json
+++ b/src/locales/hu.json
@@ -1090,34 +1090,10 @@
     "save": "Mentés",
     "discuss": "Megvitatás",
     "flowcharts": "Folyamatábrák",
-    "exordio": "Exordio",
-    "exordioDesc": "A meggyőző nyitásod",
-    "hook": "Felvezetés",
-    "transition": "Átvezetés",
-    "caseStructure": "Esetstruktúra",
-    "caseStructureDesc": "Az érvelési kereted",
-    "thesis": "Tézis",
-    "framework": "Keretrendszer",
-    "burdenOfProof": "Bizonyítási teher",
-    "keyDefinitions": "Kulcsdefiníciók",
-    "noDefinitions": "Nincsenek megadott definíciók",
     "arguments": "Érvek",
-    "structuredArguments": "strukturált érv",
-    "predictedOpponent": "Az ellenfél várható esete",
-    "predictedOpponentDesc": "Amit valószínűleg érvelni fognak",
-    "likelyArguments": "Valószínű érvek",
-    "strategicWeaknesses": "Stratégiai gyengeségek",
-    "keyClashes": "Kulcs ütközések",
-    "preparedCounters": "Előkészített ellenérvek",
-    "preparedCountersDesc": "Használatra kész cáfolatok",
     "needsSource": "Forrás szükséges",
-    "reasoning": "Indoklás:",
     "evidence": "Bizonyíték:",
     "searchSuggestion": "Keresési javaslat:",
-    "impact": "Hatás:",
-    "target": "Célpont",
-    "counter": "Ellenérv:",
-    "rebuttal": "Cáfolat:",
     "exportedGdocs": "Eset exportálva Google Docs-ba!",
     "open": "Megnyitás",
     "exportFailed": "Nem sikerült exportálni Google Docs-ba",
@@ -1127,7 +1103,36 @@
     "undo": "Visszavonás",
     "resultTitle": "Az eseted",
     "unverified": "Ellenőrizetlen",
-    "unresearchedCaveat": "MI által készült, és ezt a bizonyítékot nem támasztja alá webes kutatás. Ellenőrizd a tényeket és a forrásokat, mielőtt egy fordulóban használod."
+    "unresearchedCaveat": "MI által készült, és ezt a bizonyítékot nem támasztja alá webes kutatás. Ellenőrizd a tényeket és a forrásokat, mielőtt egy fordulóban használod.",
+    "opening": "Nyitás",
+    "openingDesc": "Így kezdődik a beszéded",
+    "definition": "Mit értünk alatta:",
+    "roadmap": "Amit bemutatunk",
+    "argumentCount_one": "{{count}} érv",
+    "argumentCount_other": "{{count}} érv",
+    "point": "Állítás:",
+    "explanation": "Magyarázat:",
+    "whyItMatters": "Miért fontos:",
+    "ifTheySay": "Ha azt mondják…",
+    "ifTheySayDesc": "Várható állításaik és a válaszaid",
+    "theySay": "Azt mondják",
+    "weAnswer": "Válaszunk:",
+    "source": "Forrás:",
+    "whyWeWin": "Miért nyerünk",
+    "whyWeWinDesc": "Amire a bírónak emlékeznie kell",
+    "closingLine": "Zárómondat",
+    "closingLineDesc": "Az utolsó mondatod",
+    "sources": "Források",
+    "sourcesDesc": "Minden, amire az eseted hivatkozik",
+    "reinforce": "Érveink megerősítése",
+    "reinforceDesc": "Kb. 2 perc a csapatod korábbi érveiről",
+    "legacyJudgeBy": "Hogyan érdemes megítélni a vitát",
+    "legacyMustShow": "Amit be kell bizonyítanunk",
+    "legacyDefinitions": "Mit értünk a témán",
+    "legacyAlsoSay": "Ezt is mondhatják",
+    "legacyWeakSpots": "Hol vagyunk a leggyengébbek",
+    "legacyDecidingPoints": "Min dől el a vita",
+    "legacySayItLike": "Így mondd:"
   },
   "attackForm": {
     "argument": "Az érved",
@@ -1873,8 +1878,6 @@
     "unknown": "Ismeretlen",
     "standard": "Általános",
     "format": "formátum",
-    "contentionNumber": "{{number}}. érv",
-    "noThesis": "Nincs megadott tézis.",
     "assessmentSummary": "Az értékelés összefoglalása",
     "noSummary": "Nincs megadott összefoglalás.",
     "strengthAreas": "Erősségek",
@@ -1914,17 +1917,7 @@
       "unverified": "Nem ellenőrzött",
       "pending": "Függőben"
     },
-    "reasoning": "Indoklás",
     "evidence": "Bizonyíték",
-    "impact": "Hatás",
-    "hook": "Felvezetés",
-    "transition": "Átvezetés",
-    "noArguments": "Nincsenek megadott érvek.",
-    "noOpponentArgs": "Nincsenek megadott várható ellenfél érvek.",
-    "noCounters": "Nincsenek megadott ellenérvek.",
-    "target": "Célpont",
-    "counter": "Ellenérv",
-    "rebuttal": "Cáfolat",
     "debateCase": "Vitaeset",
     "side": "Oldal",
     "proposition": "Mellette",
@@ -1945,15 +1938,7 @@
     "howToUse": "Használat",
     "source": "Forrás",
     "noFactoids": "Nem találhatók tények.",
-    "exordio": "Exordio",
-    "caseStructure": "Esetstruktúra",
-    "thesis": "Tézis",
-    "framework": "Keretrendszer",
-    "burdenOfProof": "Bizonyítási teher",
-    "keyDefinitions": "Kulcsdefiníciók",
     "arguments": "Érvek",
-    "predictedOpponent": "Az ellenfél várható esete",
-    "counters": "Előkészített ellenérvek",
     "weaknesses": "Azonosított gyengeségek",
     "fallacies": "Észlelt téves következtetések",
     "crossExQuestions": "Keresztkérdezési kérdések",
@@ -1982,7 +1967,26 @@
     "factoidsSummary_one": "{{count}} tény • Ellenőrzött: {{verified}}",
     "factoidsSummary_other": "{{count}} tény • Ellenőrzött: {{verified}}",
     "topIdeasCount_one": "{{count}} legjobb ötlet",
-    "topIdeasCount_other": "{{count}} legjobb ötlet"
+    "topIdeasCount_other": "{{count}} legjobb ötlet",
+    "opening": "Nyitás",
+    "roadmap": "Amit bemutatunk",
+    "definition": "Mit értünk alatta",
+    "argumentNumber": "{{number}}. érv",
+    "point": "Állítás",
+    "whyItMatters": "Miért fontos",
+    "ifTheySay": "Ha azt mondják…",
+    "theySay": "Azt mondják",
+    "weAnswer": "Válaszunk",
+    "whyWeWin": "Miért nyerünk",
+    "closingLine": "Zárómondat",
+    "sources": "Források",
+    "reinforce": "Érveink megerősítése",
+    "legacyJudgeBy": "Hogyan érdemes megítélni a vitát",
+    "legacyMustShow": "Amit be kell bizonyítanunk",
+    "legacyDefinitions": "Mit értünk a témán",
+    "legacyAlsoSay": "Ezt is mondhatják",
+    "legacySayItLike": "Így mondd",
+    "untitledCase": "Névtelen eset"
   },
   "sparring": {
     "pro": "Mellette",
@@ -2029,10 +2033,10 @@
       "hard": "Kíméletlen"
     },
     "roleGuidance": {
-      "introductor": "Kezdj exordióval, határozd meg a kulcsfogalmakat, állítsd fel a keretet és a tézist, majd ismertesd az érvelés menetét. A teljes érveket hagyd az R1-re.",
-      "r1": "Építsd fel a fő érveket állítással, indoklással, alátámasztással és hatással. A végén előzd meg vagy válaszold meg a legerősebb ellenérvet.",
-      "r2": "Mélyítsd el az R1 érveit, válaszolj közvetlenül az ellenfélnek, nevezd meg a fő ütközési pontokat, és mérd össze a hatásokat. Ne csak ismételd az esetet.",
-      "conclusor": "Ne hozz új érvet. Kristályosítsd ki a döntő ütközési pontokat, mérlegeld a fordulót, és zárd le azzal, miért a te oldalad nyer."
+      "introductor": "Kezdj egy figyelemfelkeltő nyitással, mondd ki: „N érvvel bizonyítjuk, hogy…”, és röviden mutasd be az érveket. A téma egy szavát csak akkor magyarázd el egy mondatban, ha nem egyértelmű. A teljes érveket hagyd az R1-nek.",
+      "r1": "Fejtsd ki teljesen az érveket: az állítást, hogy miért igaz, a bizonyítékot forrással és évszámmal, és hogy miért fontos. A végén válaszolj arra, amit a másik csapat a legvalószínűbben mond.",
+      "r2": "Ne hozz új érvet. Kb. 2 percben erősítsd meg a csapatod érveit, majd kb. 4 percben válaszolj az övéikre: „Ha azt mondják…, mi azt feleljük…”.",
+      "conclusor": "Ne hozz új érvet. Mondj két-három okot, amiért az oldalad nyert, és zárj egy világos zárómondattal."
     },
     "category": {
       "Logic": "Logika",
@@ -2708,9 +2712,6 @@
       "done": "Kész",
       "openItem": "Megnyitás: {{title}}"
     },
-    "offline": {
-      "notice": "Offline: a mentett másolatokat látod. Az MI és a mentés megvárja a kapcsolatot."
-    },
     "debates": {
       "search": "Tételek keresése",
       "noMatches": "Nincs a keresésnek megfelelő vita.",
@@ -2969,6 +2970,65 @@
     "permissions": {
       "speechRecognition": "A DebateOwl szöveggé alakítja a hangodat, amikor kérdést, keresztkérdezési választ vagy vitapárbaj-beszédet diktálsz. A hangot az Apple dolgozza fel a felismeréshez.",
       "microphone": "A DebateOwl a mikrofont használja, amíg kérdést, keresztkérdezési választ vagy vitapárbaj-beszédet diktálsz."
+    },
+    "sidebar": {
+      "dashboard": "Áttekintés",
+      "sources": "Források",
+      "account": "Fiók és beállítások",
+      "noDebate": "Nincs aktuális vita",
+      "collapseHint": "Elrejti a szakasz eszközeit",
+      "expandHint": "Megjeleníti a szakasz eszközeit"
+    },
+    "trialBanner": {
+      "seePlan": "Csomag megtekintése"
+    },
+    "tour": {
+      "progress": "{{step}}. lépés / {{steps}}"
+    },
+    "a11y": {
+      "answerReady": "Kész a válasz",
+      "resultReady": "Elkészült: {{title}}"
+    },
+    "share": {
+      "shareLink": "Link megosztása",
+      "linkCopied": "Link másolva",
+      "failed": "Nem sikerült megosztási linket létrehozni. Próbáld újra.",
+      "limitReached": "Elérted a napi megosztási korlátot ({{limit}}). Próbáld újra holnap.",
+      "tooLarge": "Ez túl nagy ahhoz, hogy linkként megoszd.",
+      "signIn": "Jelentkezz be újra a link megosztásához.",
+      "timeout": "A link létrehozása túl sokáig tartott. Próbáld újra.",
+      "openWebsite": "Megnyitás a weboldalon",
+      "unknownKind": "Ez a megosztott tartalom csak a weboldalon nyitható meg."
+    },
+    "widget": {
+      "spar": "Gyakorlás",
+      "description": "A tételed és a felkészülésed egy pillantásra."
+    },
+    "quickActions": {
+      "startTimer": "Időmérő indítása"
+    },
+    "offlineQueue": {
+      "notice": "Offline: mentett másolatok láthatók. Az új jegyzetek, a forrásmódosítások és a kapcsolók akkor szinkronizálódnak, amikor újra lesz kapcsolat. Az MI és a többi módosítás megvárja a kapcsolatot.",
+      "pending_one": "{{count}} módosítás szinkronizálódik, amikor újra lesz kapcsolat",
+      "pending_other": "{{count}} módosítás szinkronizálódik, amikor újra lesz kapcsolat",
+      "syncing_one": "{{count}} módosítás vár szinkronizálásra",
+      "syncing_other": "{{count}} módosítás vár szinkronizálásra",
+      "waiting": "Szinkronizálásra vár",
+      "syncsWhenOnline": "Ezen a telefonon mentve. Akkor szinkronizálódik, amikor újra lesz kapcsolat.",
+      "syncingSoon": "Ezen a telefonon mentve. Szinkronizálódik, amint a szerver elérhető.",
+      "noteQueuedTitle": "A jegyzet ezen a telefonon mentve",
+      "noteQueuedDesc": "Akkor kerül a Könyvtárba, amikor újra lesz kapcsolat.",
+      "changeQueuedTitle": "Ezen a telefonon mentve",
+      "changeQueuedDesc": "Akkor szinkronizálódik, amikor újra lesz kapcsolat.",
+      "synced_one": "{{count}} módosítás szinkronizálva",
+      "synced_other": "{{count}} módosítás szinkronizálva",
+      "refusedTitle_one": "{{count}} módosítást nem sikerült menteni",
+      "refusedTitle_other": "{{count}} módosítást nem sikerült menteni",
+      "refusedDesc_one": "A szerver elutasította, ezért törlődött erről a telefonról.",
+      "refusedDesc_other": "A szerver elutasította őket, ezért törlődtek erről a telefonról.",
+      "noteRefused": "A szerver elutasította a(z) „{{title}}” jegyzetet, ezért törlődött erről a telefonról.",
+      "notKeptTitle": "Még nincs mentve ezen a telefonon",
+      "notKeptDesc": "A módosításaid szinkronizálódnak, amikor újra online leszel. Addig tartsd nyitva az alkalmazást."
     }
   }
 }
diff --git a/src/test/helpers/cases.ts b/src/test/helpers/cases.ts
new file mode 100644
index 000000000..86bec9b43
--- /dev/null
+++ b/src/test/helpers/cases.ts
@@ -0,0 +1,78 @@
+import type { GenerateOutput } from '@/lib/ai/schemas/generate';
+
+// A case in today's shape: an R2 speech with a short opening, one argument,
+// "If they say…" answers, a closing line and sources.
+export const NEW_CASE: GenerateOutput = {
+  opening: { hook: 'Picture a pupil who hides her phone to use AI at night.' },
+  caseStructure: { thesis: 'Today we will show 1 argument that proves a ban does more harm than good.' },
+  contentions: [{
+    id: '1',
+    title: 'One size fits all',
+    claim: 'A total ban ignores that children grow up.',
+    reasoning: 'A ban treats a 7-year-old and a 17-year-old the same.',
+    evidence: 'UNICEF said in 2025 that age limits alone do not keep children safe.',
+    needsSource: false,
+    impact: 'Older pupils lose a learning tool they use responsibly.',
+  }],
+  counters: [{
+    targetArgument: 'AI makes kids cheat.',
+    counterpoint: 'Pupils cheated before AI; a ban removes supervision, not cheating.',
+    source: 'OECD, 2024',
+  }],
+  closingLine: 'That is why it is clear that a ban is the wrong answer.',
+  sources: [
+    { org: 'UNICEF', year: '2025', claim: 'Age limits alone do not keep children safe', url: 'https://www.unicef.org/report' },
+    { org: 'Old Wiki', claim: 'A link that must never be followed', url: 'javascript:alert(1)' },
+  ],
+  metadata: { side: 'con', format: 'custom', generatedAt: '2026-10-27T10:00:00.000Z' },
+};
+
+// A case saved before the restructure, with every section it used to have.
+export const OLD_CASE: GenerateOutput = {
+  exordio: { hook: 'Imagine a city where the bus is free.', transition: 'That city is closer than you think.' },
+  caseStructure: {
+    thesis: 'Free transit is a net public good.',
+    framework: 'Net societal benefit.',
+    keyDefinitions: ['Public transport: publicly funded scheduled transit.'],
+    burdenOfProof: 'We must show a net gain in practice.',
+  },
+  contentions: [{
+    id: '1',
+    claim: 'Fares block the riders who need transit most.',
+    reasoning: 'Fares are a regressive barrier.',
+    evidence: 'Comparable cities report ridership gains.',
+    needsSource: false,
+    sourceQuery: '',
+    impact: 'More people reach work and school.',
+  }],
+  predictedOpponentCase: {
+    likelyArguments: ['Funding gap', 'Overcrowding'],
+    strategicWeaknesses: ['Assumes fares are the only funding model.'],
+    keyClashes: ['Who bears the cost.'],
+  },
+  counters: [{
+    targetArgument: 'Funding gap',
+    counterpoint: 'Fare collection has heavy overhead.',
+    rebuttal: 'Net cost is far below headline farebox revenue.',
+  }],
+  metadata: { side: 'pro', format: 'custom', generatedAt: '2026-01-06T10:00:00.000Z' },
+};
+
+// An R2 case in the shape of Adam's own R2 speech: who is speaking, the team's
+// earlier argument backed up, then "If they say…" answers. No new arguments.
+export const R2_CASE: GenerateOutput = {
+  opening: { hook: 'Schools present themselves as safe, but if that were true, thousands of children would not be suffering in silence every day.' },
+  caseStructure: { thesis: "I'm the R2 of my team, and I'm here to show that school safety is an illusion." },
+  contentions: [],
+  reinforce: [{
+    argument: 'Our second argument: bullying',
+    text: 'Our second argument was about bullying. In Spain, 1 in 5 pupils has been bullied (Educo, 2022), and 1 in 3 victims tells nobody (UNESCO, 2021).',
+  }],
+  counters: [{
+    targetArgument: 'Schools have emergency plans to protect pupils.',
+    counterpoint: 'Emergency plans do not stop everyday problems like bullying.',
+    source: 'UNESCO, 2021',
+  }],
+  closingLine: 'That is why it is clear that schools are NOT truly safe. Thank you.',
+  metadata: { side: 'con', format: 'custom', generatedAt: '2026-10-28T10:00:00.000Z' },
+};
diff --git a/src/test/i18n-untranslated.test.ts b/src/test/i18n-untranslated.test.ts
index 18ac0c738..b6e396c26 100644
--- a/src/test/i18n-untranslated.test.ts
+++ b/src/test/i18n-untranslated.test.ts
@@ -46,9 +46,7 @@ const SAME_AS_ENGLISH: Record<string, string[]> = {
     'hu tools:motions.wordingHouse',
     'hu tools:flow.letter',
   ],
-  'Exordio, the rhetoric term, and unit abbreviations': [
-    'es translation:generateResults.exordio', 'hu translation:generateResults.exordio',
-    'es translation:export.exordio', 'hu translation:export.exordio',
+  'Unit abbreviations': [
     'es translation:generateResults.durationMs', 'hu translation:generateResults.durationMs',
     'es translation:crossfire.duration3m', 'es translation:crossfire.duration5m', 'es translation:crossfire.duration8m',
   ],
diff --git a/src/test/lib/case-exports.test.ts b/src/test/lib/case-exports.test.ts
new file mode 100644
index 000000000..54133fb7a
--- /dev/null
+++ b/src/test/lib/case-exports.test.ts
@@ -0,0 +1,129 @@
+import { inflateRawSync } from 'node:zlib';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { exportCaseToDocx } from '@/lib/export-utils';
+import { exportCaseToPdf } from '@/lib/pdf-export-utils';
+import { caseText } from '@/components/features/tools/result-text';
+import { NEW_CASE, OLD_CASE, R2_CASE } from '../helpers/cases';
+
+// The labels and placeholders the restructure removed from every export.
+const OLD_LABELS = /Thesis|Framework|Burden of Proof|Predicted Opponent Case|Counterpoint|No framework provided|No burden of proof provided/i;
+
+// Every line the PDF draws, recorded by a stand-in for jsPDF. Drawing calls the
+// test does not need (colours, fonts, shapes, save) do nothing.
+const drawn = vi.hoisted(() => [] as string[]);
+
+vi.mock('jspdf', () => ({
+  jsPDF: function FakePdf(): object {
+    const doc: Record<string, unknown> = {
+      internal: { pageSize: { width: 210, height: 297 } },
+      // No font files to load in a test.
+      addFileToVFS: undefined,
+      text: (value: string | string[]) => { drawn.push(...[value].flat()); },
+      splitTextToSize: (value: string) => [value],
+      getNumberOfPages: () => 1,
+    };
+    return new Proxy(doc, { get: (target, key): unknown => (key in target ? Reflect.get(target, key) : (): undefined => undefined) });
+  },
+}));
+vi.mock('jspdf-autotable', () => ({ default: (): void => undefined }));
+
+/** The text of one file inside a .docx (a zip), read through its central directory. */
+function zipEntry(zip: Buffer, name: string): string {
+  const end = zip.lastIndexOf(Buffer.from([0x50, 0x4b, 0x05, 0x06]));
+  let entry = zip.readUInt32LE(end + 16);
+  for (let i = 0; i < zip.readUInt16LE(end + 10); i++) {
+    const nameLength = zip.readUInt16LE(entry + 28);
+    if (zip.toString('utf8', entry + 46, entry + 46 + nameLength) === name) {
+      const local = zip.readUInt32LE(entry + 42);
+      const start = local + 30 + zip.readUInt16LE(local + 26) + zip.readUInt16LE(local + 28);
+      const data = zip.subarray(start, start + zip.readUInt32LE(entry + 20));
+      return (zip.readUInt16LE(entry + 10) === 8 ? inflateRawSync(data) : data).toString('utf8');
+    }
+    entry += 46 + nameLength + zip.readUInt16LE(entry + 30) + zip.readUInt16LE(entry + 32);
+  }
+  throw new Error(`${name} is not in the archive`);
+}
+
+async function docxText(result: typeof NEW_CASE): Promise<string> {
+  let blob: Blob | undefined;
+  vi.spyOn(URL, 'createObjectURL').mockImplementation((value) => { blob = value as Blob; return 'blob:case'; });
+  vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => undefined);
+  expect(await exportCaseToDocx(result)).toBe(true);
+  const bytes = await new Promise<ArrayBuffer>((resolve) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result as ArrayBuffer);
+    reader.readAsArrayBuffer(blob!);
+  });
+  const xml = zipEntry(Buffer.from(bytes), 'word/document.xml');
+  const entities: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+  return xml.replace(/<\/w:p>/g, '\n').replace(/<[^>]+>/g, '').replace(/&(amp|lt|gt|quot|apos);/g, (_, name: string) => entities[name]);
+}
+
+async function pdfText(result: typeof NEW_CASE): Promise<string> {
+  drawn.length = 0;
+  expect(await exportCaseToPdf(result)).toBe(true);
+  return drawn.join('\n');
+}
+
+beforeEach(() => {
+  vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => undefined);
+});
+afterEach(() => vi.restoreAllMocks());
+
+describe.each([
+  ['DOCX', docxText],
+  ['PDF', pdfText],
+  ['clipboard', async (result: typeof NEW_CASE) => caseText(result)],
+])('%s case export', (_name, exportText) => {
+  it('writes a new case as opening, arguments, "If they say…", closing line and sources', async () => {
+    const text = await exportText(NEW_CASE);
+    for (const expected of [
+      NEW_CASE.opening!.hook,
+      NEW_CASE.caseStructure.thesis,
+      'One size fits all',
+      'A ban treats a 7-year-old and a 17-year-old the same.',
+      'Older pupils lose a learning tool they use responsibly.',
+      'AI makes kids cheat.',
+      'OECD, 2024',
+      NEW_CASE.closingLine!,
+      'UNICEF (2025) – Age limits alone do not keep children safe – https://www.unicef.org/report',
+    ]) expect(text).toContain(expected);
+    expect(text).not.toMatch(OLD_LABELS);
+    expect(text).not.toContain('javascript:');
+  });
+
+  it('still writes every section of a case saved before the restructure', async () => {
+    const text = await exportText(OLD_CASE);
+    for (const expected of [
+      'Imagine a city where the bus is free. That city is closer than you think.',
+      'Free transit is a net public good.',
+      'Net societal benefit.',
+      'We must show a net gain in practice.',
+      'Fares block the riders who need transit most.',
+      'Fare collection has heavy overhead.',
+      'Net cost is far below headline farebox revenue.',
+    ]) expect(text).toContain(expected);
+    // The old sections keep their content, under plain names.
+    expect(text).not.toMatch(OLD_LABELS);
+  });
+
+  it('writes an R2 case as backed-up arguments and answers, with no new arguments', async () => {
+    const text = await exportText(R2_CASE);
+    for (const expected of [
+      R2_CASE.caseStructure.thesis,
+      'Our second argument: bullying',
+      R2_CASE.reinforce![0].text,
+      'Schools have emergency plans to protect pupils.',
+      'UNESCO, 2021',
+      R2_CASE.closingLine!,
+    ]) expect(text).toContain(expected);
+    expect(text).not.toMatch(/Argument 1|ARGUMENT 1/);
+    expect(text).not.toMatch(OLD_LABELS);
+  });
+
+  it('writes a Conclusor case\'s reasons why we win when there are no arguments', async () => {
+    const text = await exportText({ ...NEW_CASE, contentions: [], counters: [], whyWeWin: ['They never answered our point about supervision.'] });
+    expect(text).toContain('They never answered our point about supervision.');
+    expect(text).not.toContain('One size fits all');
+  });
+});
diff --git a/src/test/lib/case-view.test.ts b/src/test/lib/case-view.test.ts
new file mode 100644
index 000000000..61edfee71
--- /dev/null
+++ b/src/test/lib/case-view.test.ts
@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'vitest';
+import { GenerateOutputSchema } from '@/lib/ai/schemas/generate';
+import { mergeCaseSources, readCase } from '@debatelab/core/ai/case-view';
+import { prefillFromGenerate } from '@/lib/crossfire/prefill';
+import { NEW_CASE, OLD_CASE, R2_CASE } from '../helpers/cases';
+
+describe('generated case schema', () => {
+  it('accepts a new case without any of the old sections', () => {
+    expect(GenerateOutputSchema.safeParse(NEW_CASE).success).toBe(true);
+  });
+
+  it('still accepts a case saved before the restructure, keeping its old sections', () => {
+    const parsed = GenerateOutputSchema.parse(OLD_CASE);
+    expect(parsed.caseStructure.burdenOfProof).toBe('We must show a net gain in practice.');
+    expect(parsed.predictedOpponentCase?.keyClashes).toEqual(['Who bears the cost.']);
+    expect(parsed.counters[0].rebuttal).toBe('Net cost is far below headline farebox revenue.');
+  });
+
+  it('accepts null where the model was told to leave a field out', () => {
+    const parsed = GenerateOutputSchema.parse({
+      ...NEW_CASE,
+      opening: { hook: 'Hook', definition: null },
+      contentions: [{ ...NEW_CASE.contentions[0], title: null }],
+      counters: [{ ...NEW_CASE.counters[0], source: null }],
+      whyWeWin: null,
+      closingLine: null,
+      sources: [{ org: 'UNICEF', year: null, claim: 'Claim', url: null }],
+    });
+    const view = readCase(parsed);
+    expect(view.opening.definition).toBeUndefined();
+    expect(view.arguments[0].title).toBeUndefined();
+    expect(view.whyWeWin).toEqual([]);
+    expect(view.sources).toEqual([{ org: 'UNICEF', claim: 'Claim', year: undefined, url: undefined }]);
+  });
+
+  it('keeps the new sections instead of stripping them as unknown keys', () => {
+    const parsed = GenerateOutputSchema.parse({ ...NEW_CASE, whyWeWin: ['They never answered our point.'] });
+    expect(parsed.opening?.hook).toBe(NEW_CASE.opening?.hook);
+    expect(parsed.contentions[0].title).toBe('One size fits all');
+    expect(parsed.counters[0].source).toBe('OECD, 2024');
+    expect(parsed.whyWeWin).toEqual(['They never answered our point.']);
+    expect(parsed.closingLine).toBe(NEW_CASE.closingLine);
+    expect(parsed.sources).toHaveLength(2);
+  });
+});
+
+describe('readCase', () => {
+  it('reads a new case into its sections and never links a non-web URL', () => {
+    const view = readCase(NEW_CASE);
+    expect(view.opening).toEqual({ hook: NEW_CASE.opening?.hook, definition: undefined, roadmap: NEW_CASE.caseStructure.thesis });
+    expect(view.arguments[0]).toMatchObject({ title: 'One size fits all', point: 'A total ban ignores that children grow up.' });
+    expect(view.ifTheySay).toEqual([{ theySay: 'AI makes kids cheat.', weAnswer: NEW_CASE.counters[0].counterpoint, inRound: undefined, source: 'OECD, 2024' }]);
+    expect(view.sources.map((source) => source.url)).toEqual(['https://www.unicef.org/report', undefined]);
+    expect(view.legacy).toEqual({ framework: undefined, burdenOfProof: undefined, definitions: [], likelyArguments: [], weaknesses: [], clashes: [] });
+  });
+
+  it('reads an old case: exordio becomes the hook and the old sections come through as legacy', () => {
+    const view = readCase(OLD_CASE);
+    expect(view.opening.hook).toBe('Imagine a city where the bus is free. That city is closer than you think.');
+    expect(view.opening.roadmap).toBe('Free transit is a net public good.');
+    expect(view.ifTheySay[0]).toMatchObject({ theySay: 'Funding gap', weAnswer: 'Fare collection has heavy overhead.', inRound: 'Net cost is far below headline farebox revenue.' });
+    expect(view.legacy).toEqual({
+      framework: 'Net societal benefit.',
+      burdenOfProof: 'We must show a net gain in practice.',
+      definitions: ['Public transport: publicly funded scheduled transit.'],
+      // "Funding gap" is already answered in the list, so only the unanswered one stays.
+      likelyArguments: ['Overcrowding'],
+      weaknesses: ['Assumes fares are the only funding model.'],
+      clashes: ['Who bears the cost.'],
+    });
+  });
+
+  it('reads an R2 case as backed-up arguments with no new ones, dropping empty blocks', () => {
+    const view = readCase({ ...R2_CASE, reinforce: [...R2_CASE.reinforce!, { argument: 'Empty', text: '  ' }] });
+    expect(view.arguments).toEqual([]);
+    expect(view.reinforce).toEqual([{ argument: 'Our second argument: bullying', text: R2_CASE.reinforce![0].text }]);
+    expect(view.ifTheySay).toHaveLength(1);
+  });
+
+  it('survives a stored case with missing or malformed sections', () => {
+    const broken = { caseStructure: { thesis: '' }, contentions: [null], counters: [{}], sources: [{}], metadata: {} } as unknown as typeof NEW_CASE;
+    const view = readCase(broken);
+    expect(view.arguments).toHaveLength(1);
+    expect(view.ifTheySay).toEqual([]);
+    expect(view.sources).toEqual([]);
+    expect(view.opening.roadmap).toBeUndefined();
+  });
+});
+
+describe('mergeCaseSources', () => {
+  it('keeps both lists after a section regenerates, each source once', () => {
+    const merged = mergeCaseSources(NEW_CASE.sources, [
+      { org: 'UNICEF', year: '2025', claim: 'Same report, new wording', url: 'https://www.unicef.org/report' },
+      { org: 'OECD', year: '2024', claim: 'Cheating predates AI' },
+    ]);
+    expect(merged?.map((source) => source.org)).toEqual(['UNICEF', 'OECD', 'Old Wiki']);
+    expect(mergeCaseSources(undefined, [])).toBeUndefined();
+  });
+});
+
+describe('Crossfire prefill from a case', () => {
+  it('leaves out empty old sections and includes a Conclusor\'s reasons', () => {
+    const fresh = prefillFromGenerate('Motion', { ...NEW_CASE, contentions: [], whyWeWin: ['They never answered our point.'] });
+    expect(fresh.argument).not.toContain('How to judge this debate');
+    expect(fresh.argument).not.toContain('What we have to show');
+    expect(fresh.argument).toContain('Why we win 1: They never answered our point.');
+
+    const old = prefillFromGenerate('Motion', OLD_CASE);
+    expect(old.argument).toContain('What we have to show: We must show a net gain in practice.');
+  });
+});
diff --git a/src/test/lib/flowchart.test.ts b/src/test/lib/flowchart.test.ts
index 21b4b0ad5..d9727315c 100644
--- a/src/test/lib/flowchart.test.ts
+++ b/src/test/lib/flowchart.test.ts
@@ -1,7 +1,7 @@
 import { beforeAll, describe, expect, it } from 'vitest';
 import i18n from '@/i18n';
 import { routeLoaders } from '@/lib/route-modules';
-import { edgeLabel, editNodeData, flowchartFromCase, nodeDescription, nodeLabel, starterFlowchart, studentNodeData, type FlowNodeData } from '@/lib/flowchart';
+import { caseHasFlowchart, edgeLabel, editNodeData, flowchartFromCase, nodeDescription, nodeLabel, starterFlowchart, studentNodeData, type FlowNodeData } from '@/lib/flowchart';
 import type { GenerateOutput } from '@/lib/ai/schemas/generate';
 
 const en = i18n.getFixedT('en');
@@ -106,4 +106,34 @@ describe('flowchartFromCase', () => {
         expect(Math.max(...xs) - Math.min(...xs)).toBeLessThanOrEqual(900);
         expect(new Set(nodes.map((node) => `${node.position.x},${node.position.y}`)).size).toBe(nodes.length);
     });
+
+    it('builds a new case\'s attacks from "If they say…", and a Conclusor case from its reasons why we win', () => {
+        const fresh = {
+            ...result,
+            predictedOpponentCase: undefined,
+            contentions: [{ ...result.contentions[0], title: 'Cleaner air' }],
+            counters: [{ targetArgument: 'Deliveries get harder', counterpoint: 'Night delivery windows' }],
+        } as GenerateOutput;
+        const built = flowchartFromCase(fresh, en);
+        expect(built.nodes.map((node) => [node.id, node.data.description])).toEqual([
+            ['thesis', 'Cities should ban cars downtown'],
+            ['c-0', 'Cleaner air\nAir quality improves\nNO2 fell 30% in Oslo'],
+            ['a-0', 'Deliveries get harder'],
+            ['r-0', 'Night delivery windows'],
+        ]);
+        expect(built.edges.map((edge) => `${edge.source}>${edge.target}`)).toEqual(['thesis>c-0', 'c-0>a-0', 'a-0>r-0']);
+
+        // R2 brings no new arguments: its backed-up arguments become the argument nodes.
+        const r2 = { ...fresh, contentions: [], reinforce: [{ argument: 'Our first argument: cleaner air', text: 'NO2 fell 30% in Oslo.' }] } as GenerateOutput;
+        expect(caseHasFlowchart(r2)).toBe(true);
+        expect(flowchartFromCase(r2, en).nodes.map((node) => node.data.description).slice(0, 3)).toEqual([
+            'Cities should ban cars downtown', 'Our first argument: cleaner air\nNO2 fell 30% in Oslo.', 'Deliveries get harder',
+        ]);
+
+        const conc = { ...fresh, contentions: [], counters: [], whyWeWin: ['They never answered air quality', 'Shops did fine'] } as GenerateOutput;
+        expect(caseHasFlowchart(conc)).toBe(true);
+        expect(flowchartFromCase(conc, en).nodes.map((node) => node.data.description)).toEqual([
+            'Cities should ban cars downtown', 'They never answered air quality', 'Shops did fine',
+        ]);
+    });
 });
diff --git a/src/test/pages/GeneratePage.test.tsx b/src/test/pages/GeneratePage.test.tsx
index a7ddec106..d2c814563 100644
--- a/src/test/pages/GeneratePage.test.tsx
+++ b/src/test/pages/GeneratePage.test.tsx
@@ -246,7 +246,7 @@ describe('GeneratePage Integration', () => {
             state: expect.objectContaining({
                 source: 'generate',
                 resolution: 'Existing motion',
-                argument: expect.stringContaining('Thesis: Existing Thesis'),
+                argument: expect.stringContaining('What we will show: Existing Thesis'),
             }),
         });
     });
diff --git a/src/test/scripts/staging-sync.test.ts b/src/test/scripts/staging-sync.test.ts
index 42ca4bcb5..e0ee28e72 100644
--- a/src/test/scripts/staging-sync.test.ts
+++ b/src/test/scripts/staging-sync.test.ts
@@ -5,12 +5,17 @@ import { describe, expect, it } from "vitest";
 // @ts-expect-error -- plain ESM script without type declarations
 import { assertNoUndeclared, assertStagingTarget, contentDrift, planSync, PRODUCTION_REF, STAGING_REF } from "../../../scripts/staging-sync.mjs";
 
-const staging = { ref: STAGING_REF, name: "debate-trainer-staging" };
-const production = { ref: PRODUCTION_REF, name: "debate-trainer" };
+const staging = { ref: STAGING_REF, name: "DebateOwl Staging" };
+const production = { ref: PRODUCTION_REF, name: "DebateOwl" };
 
 describe("staging sync target guard", () => {
-  it("accepts the staging project under its own name", () => {
-    expect(() => assertStagingTarget([production, staging], {})).not.toThrow();
+  it("accepts the staging project by its ref, whatever it is named", () => {
+    expect(assertStagingTarget([production, staging], {})).toBe(staging);
+    for (const name of ["debate-trainer-staging", "DebateOwl Staging", "Renamed again"]) {
+      expect(() => assertStagingTarget([production, { ref: STAGING_REF, name }], {})).not.toThrow();
+    }
+    // Older CLI output has only `id`.
+    expect(() => assertStagingTarget([{ id: STAGING_REF, name: "DebateOwl Staging" }], {})).not.toThrow();
   });
 
   it("refuses when SUPABASE_PROJECT_ID points anywhere else", () => {
@@ -18,9 +23,14 @@ describe("staging sync target guard", () => {
       .toThrow(/only targets staging/);
   });
 
-  it("refuses when the staging ref is missing or renamed", () => {
+  it("refuses when SUPABASE_PROJECT_ID is set to production even if staging is visible", () => {
+    expect(() => assertStagingTarget([staging], { SUPABASE_PROJECT_ID: ` ${PRODUCTION_REF} ` })).toThrow(/only targets staging/);
+    expect(() => assertStagingTarget([staging], { SUPABASE_PROJECT_ID: STAGING_REF })).not.toThrow();
+  });
+
+  it("refuses when the account cannot see the staging ref, even if a project is named like staging", () => {
     expect(() => assertStagingTarget([production], {})).toThrow(/cannot see/);
-    expect(() => assertStagingTarget([{ ref: STAGING_REF, name: "debate-trainer" }], {})).toThrow(/expected "debate-trainer-staging"/);
+    expect(() => assertStagingTarget([{ ref: PRODUCTION_REF, name: "DebateOwl Staging" }], {})).toThrow(/cannot see/);
   });
 });
 
diff --git a/supabase/functions/_shared/control-enforcement.test.ts b/supabase/functions/_shared/control-enforcement.test.ts
index 42cffb596..49dc207cb 100644
--- a/supabase/functions/_shared/control-enforcement.test.ts
+++ b/supabase/functions/_shared/control-enforcement.test.ts
@@ -3,6 +3,7 @@ import {
   enforceAttackControls,
   enforceBrainstormControls,
   enforceGenerateControls,
+  enforceGenerateSources,
   isAskStreamingModeAllowed,
   validateControlInput,
 } from "./control-enforcement.ts";
@@ -222,6 +223,89 @@ Deno.test("generate controls fail closed when the model returns fewer contention
   }
 });
 
+Deno.test("a Conclusor case without at least two reasons we win is rejected, not padded", () => {
+  for (const whyWeWin of [undefined, [], ["only one"], ["", "  ", "one"], "not a list"]) {
+    const output: Record<string, unknown> = { contentions: [{}, {}, {}], whyWeWin, metadata: {} };
+    let error: unknown;
+    try {
+      enforceGenerateControls(output, "pro", "custom", "standard", "conc");
+    } catch (caught) {
+      error = caught;
+    }
+    if (!(error instanceof Error) || !error.message.includes("Conclusor")) {
+      throw new Error(`conc output with whyWeWin=${JSON.stringify(whyWeWin)} must be rejected`);
+    }
+  }
+});
+
+Deno.test("an R2 case must back up the team's arguments and answer theirs, or it is rejected", () => {
+  const cases: Array<[string, Record<string, unknown>]> = [
+    ["no reinforce", { reinforce: [], counters: [{}, {}, {}, {}, {}], contentions: [], metadata: {} }],
+    ["only blank reinforce", { reinforce: [{ argument: "Our first", text: "  " }], counters: [{}, {}, {}, {}, {}], contentions: [], metadata: {} }],
+    ["too few answers", { reinforce: [{ argument: "Our first", text: "Backed up." }], counters: [{}, {}, {}], contentions: [], metadata: {} }],
+  ];
+  for (const [label, output] of cases) {
+    let rejected = false;
+    try {
+      enforceGenerateControls(output, "con", "custom", "standard", "r2");
+    } catch {
+      rejected = true;
+    }
+    if (!rejected) throw new Error(`R2 output with ${label} must be rejected`);
+  }
+
+  // New arguments from the model are dropped: R2 brings none.
+  const output: Record<string, unknown> = {
+    reinforce: [{ argument: "Our first", text: "Backed up." }],
+    counters: [{}, {}, {}, {}, {}],
+    contentions: [{ claim: "A new point", whyItMatters: "x" }],
+    metadata: {},
+  };
+  enforceGenerateControls(output, "con", "custom", "standard", "r2");
+  if ((output.contentions as unknown[]).length !== 0) throw new Error("R2 must not keep new arguments");
+});
+
+Deno.test("why it matters is filed under the key saved cases already use", () => {
+  const output: Record<string, unknown> = {
+    contentions: [{ claim: "a", whyItMatters: "People reach work." }, { claim: "b", impact: "Kept.", whyItMatters: "Ignored." }],
+    metadata: {},
+  };
+  enforceGenerateControls(output, "pro", "custom", "brief", "r1");
+  const [first, second] = output.contentions as Array<Record<string, unknown>>;
+  if (first.impact !== "People reach work." || "whyItMatters" in first) throw new Error("whyItMatters must move to impact");
+  if (second.impact !== "Kept." || "whyItMatters" in second) throw new Error("an existing impact must win");
+});
+
+Deno.test("case sources keep only links the research or Library supplied", () => {
+  const output: Record<string, unknown> = {
+    sources: [
+      { org: "UNICEF", year: 2025, claim: "Age limits alone do not keep children safe", url: "https://www.unicef.org/report#section" },
+      { org: "Made Up Institute", year: "2024", claim: "Invented figure", url: "https://made-up.example/study" },
+      { org: "Library page", claim: "From the student's sources", url: "https://library.example/page/" },
+      { org: "Script", claim: "Not a web link", url: "javascript:alert(1)" },
+      { org: "", claim: "" },
+      "not a source",
+      { org: "Educo", claim: "1 in 5 pupils are bullied" },
+    ],
+  };
+  enforceGenerateSources(output, ["https://www.unicef.org/report", "https://library.example/page"]);
+  const sources = output.sources as Array<Record<string, unknown>>;
+  const expected = [
+    { org: "UNICEF", claim: "Age limits alone do not keep children safe", year: "2025", url: "https://www.unicef.org/report#section" },
+    { org: "Made Up Institute", claim: "Invented figure", year: "2024" },
+    { org: "Library page", claim: "From the student's sources", url: "https://library.example/page/" },
+    { org: "Script", claim: "Not a web link" },
+    { org: "Educo", claim: "1 in 5 pupils are bullied" },
+  ];
+  if (JSON.stringify(sources) !== JSON.stringify(expected)) {
+    throw new Error(`unexpected sources: ${JSON.stringify(sources)}`);
+  }
+
+  const malformed: Record<string, unknown> = { sources: "UNICEF 2025" };
+  enforceGenerateSources(malformed, []);
+  if ("sources" in malformed) throw new Error("a non-list sources field must be removed");
+});
+
 Deno.test("generate controls fail closed for missing or invalid exact-length fields", () => {
   const cases: Record<string, unknown>[] = [
     { contentions: [{}] },
diff --git a/supabase/functions/_shared/control-enforcement.ts b/supabase/functions/_shared/control-enforcement.ts
index 3987c620d..c0380d2df 100644
--- a/supabase/functions/_shared/control-enforcement.ts
+++ b/supabase/functions/_shared/control-enforcement.ts
@@ -151,21 +151,83 @@ export function enforceGenerateControls(output: unknown, side: string, format: s
   }
   const generateOutput = output as {
     exordio?: unknown;
+    opening?: unknown;
     contentions?: unknown[];
+    counters?: unknown[];
+    whyWeWin?: unknown;
+    reinforce?: unknown;
     metadata?: { side?: string; format?: string; generatedAt?: string };
   };
   if (!generateOutput.metadata || typeof generateOutput.metadata !== "object" || Array.isArray(generateOutput.metadata)) {
     throw new Error("Generate response contains invalid metadata and cannot satisfy the requested output shape.");
   }
-  if (!Array.isArray(generateOutput.contentions)) {
-    throw new Error("Generate response is missing a valid contentions array and cannot satisfy the requested output shape.");
-  }
 
   generateOutput.metadata.side = side === "con" ? "con" : "pro";
   generateOutput.metadata.format = format || "custom";
   if (role !== "intro" && "exordio" in generateOutput) {
     delete generateOutput.exordio;
   }
+  // Only the Introductor may define a motion term, and only in one line.
+  const opening = generateOutput.opening;
+  if (role !== "intro" && opening && typeof opening === "object" && !Array.isArray(opening)) {
+    delete (opening as { definition?: unknown }).definition;
+  }
+
+  // The prompt asks for whyItMatters; saved cases keep it under impact.
+  if (Array.isArray(generateOutput.contentions)) {
+    for (const contention of generateOutput.contentions) {
+      if (!contention || typeof contention !== "object") continue;
+      const item = contention as { impact?: unknown; whyItMatters?: unknown };
+      if (item.impact === undefined && typeof item.whyItMatters === "string") item.impact = item.whyItMatters;
+      delete item.whyItMatters;
+    }
+  }
+
+  // R2 brings no new arguments: it backs up the team's earlier ones, then
+  // spends most of the speech on "If they say…" answers.
+  if (role === "r2") {
+    const reinforce = Array.isArray(generateOutput.reinforce)
+      ? generateOutput.reinforce.filter((item) =>
+        item && typeof item === "object" && typeof (item as { text?: unknown }).text === "string" && (item as { text: string }).text.trim())
+      : [];
+    const answers = Array.isArray(generateOutput.counters) ? generateOutput.counters : [];
+    // One full answer for each thing they are likely to say: their main
+    // arguments, supporting points and answers to our case.
+    const target = length === "brief" ? 5 : 6;
+    if (reinforce.length < 1) {
+      throw new Error("Generate response returned no reinforce items, but R2 must back up the team's arguments.");
+    }
+    if (answers.length < 4) {
+      throw new Error(`Generate response returned ${answers.length} counters, but R2 needs ${target}.`);
+    }
+    generateOutput.reinforce = reinforce.slice(0, 3);
+    generateOutput.counters = answers.slice(0, target);
+    generateOutput.contentions = [];
+    delete generateOutput.whyWeWin;
+    return;
+  }
+  delete generateOutput.reinforce;
+
+  // The Conclusor brings no new arguments: 2-3 reasons we win replace them.
+  if (role === "conc") {
+    const reasons = Array.isArray(generateOutput.whyWeWin)
+      ? generateOutput.whyWeWin.filter((item): item is string => typeof item === "string" && item.trim().length > 0)
+      : [];
+    const target = length === "brief" ? 2 : 3;
+    if (reasons.length < 2) {
+      throw new Error(`Generate response returned ${reasons.length} reasons why we win, but the Conclusor needs ${target}.`);
+    }
+    generateOutput.whyWeWin = reasons.slice(0, target);
+    generateOutput.contentions = [];
+    generateOutput.counters = [];
+    return;
+  }
+  delete generateOutput.whyWeWin;
+
+  if (!Array.isArray(generateOutput.contentions)) {
+    throw new Error("Generate response is missing a valid contentions array and cannot satisfy the requested output shape.");
+  }
+  if (!Array.isArray(generateOutput.counters)) generateOutput.counters = [];
   const target = length === "brief" ? 2 : length === "comprehensive" ? 4 : 3;
   if (generateOutput.contentions.length < target) {
     throw new Error(
@@ -174,3 +236,46 @@ export function enforceGenerateControls(output: unknown, side: string, format: s
   }
   generateOutput.contentions = generateOutput.contentions.slice(0, target);
 }
+
+const MAX_CASE_SOURCES = 12;
+
+function comparableUrl(value: string): string | undefined {
+  try {
+    const url = new URL(value.trim());
+    if (url.protocol !== "https:" && url.protocol !== "http:") return undefined;
+    url.hash = "";
+    return url.href.replace(/\/$/, "");
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Keeps the case's sources list honest: a link survives only when the research
+ * or the student's Library supplied it, so a link the model made up never
+ * reaches the page or an export. The organisation, year and claim stay.
+ */
+export function enforceGenerateSources(output: unknown, knownUrls: Iterable<string>) {
+  if (!output || typeof output !== "object" || !("sources" in output)) return;
+  const generateOutput = output as { sources?: unknown };
+  if (!Array.isArray(generateOutput.sources)) {
+    delete generateOutput.sources;
+    return;
+  }
+  const known = new Set([...knownUrls].map(comparableUrl).filter((url): url is string => Boolean(url)));
+  generateOutput.sources = generateOutput.sources.flatMap((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+    const source = value as Record<string, unknown>;
+    const org = typeof source.org === "string" ? source.org.trim() : "";
+    const claim = typeof source.claim === "string" ? source.claim.trim() : "";
+    if (!org && !claim) return [];
+    const year = typeof source.year === "string" || typeof source.year === "number" ? String(source.year).trim() : "";
+    const url = typeof source.url === "string" ? comparableUrl(source.url) : undefined;
+    return [{
+      org,
+      claim,
+      ...(year ? { year } : {}),
+      ...(url && known.has(url) ? { url: (source.url as string).trim() } : {}),
+    }];
+  }).slice(0, MAX_CASE_SOURCES);
+}
diff --git a/supabase/functions/_shared/debate-context.test.ts b/supabase/functions/_shared/debate-context.test.ts
index ca2695964..3ac934b35 100644
--- a/supabase/functions/_shared/debate-context.test.ts
+++ b/supabase/functions/_shared/debate-context.test.ts
@@ -2,6 +2,8 @@ import {
   boundOutputDigests,
   type DebateOutputCandidate,
   digestOutput,
+  MAX_CASE_DIGEST_CHARS,
+  MAX_CASE_PARAGRAPH_CHARS,
   MAX_CONTEXT_OUTPUTS,
   MAX_OUTPUT_DIGEST_CHARS,
   MAX_OUTPUTS_TOTAL_CHARS,
@@ -91,7 +93,9 @@ Deno.test("digests are bounded and whole results are dropped, never cut, when th
     contentions: Array.from({ length: 10 }, (_, n) => ({ claim: `Claim ${n}`, reasoning: "R".repeat(2_000), impact: "I".repeat(2_000) })),
   };
   const digest = digestOutput("case", longCase);
-  assert(digest.length <= MAX_OUTPUT_DIGEST_CHARS, "one result exceeded its digest bound");
+  assert(digest.length <= MAX_CASE_DIGEST_CHARS, "one case exceeded its digest bound");
+  const longAttack = { weaknesses: Array.from({ length: 10 }, () => ({ description: "D".repeat(2_000), howOpponentAttacks: "H".repeat(2_000) })) };
+  assert(digestOutput("attack", longAttack).length <= MAX_OUTPUT_DIGEST_CHARS, "an attack exceeded its digest bound");
   const items = Array.from({ length: 5 }, (_, n) => ({ id: String(n), digest }));
   const bounded = boundOutputDigests(items);
   const used = bounded.included.reduce((total, item) => total + item.digest.length, 0);
@@ -102,6 +106,34 @@ Deno.test("digests are bounded and whole results are dropped, never cut, when th
   assert(empty.empty.length === 1 && empty.omittedForSize.length === 0, "an empty result was reported as too large");
 });
 
+Deno.test("a case's R2 backing-up paragraphs, If they say answers and Conclusor reasons reach the prompt in full", () => {
+  const paragraph = (label: string) => `${label} opens the paragraph. ${"Evidence and explanation follow here. ".repeat(28)}${label} ENDS HERE.`;
+  const r2 = {
+    contentions: [],
+    reinforce: [
+      { argument: "Our first argument: fare-free transport helps those who need it most.", text: paragraph("Backing one") },
+      { argument: "Our second argument: free buses are faster.", text: paragraph("Backing two") },
+    ],
+    counters: Array.from({ length: 6 }, (_, n) => ({ targetArgument: `Their claim ${n + 1}`, counterpoint: paragraph(`Answer ${n + 1}`) })),
+    whyWeWin: [paragraph("Reason one")],
+  };
+  assert(paragraph("x").length > 1_000, "the test paragraphs should be as long as a real R2's");
+  const digest = digestOutput("case", r2);
+  for (const label of ["Backing one", "Backing two", "Answer 1", "Answer 6", "Reason one"]) {
+    assert(digest.includes(`${label} ENDS HERE.`), `${label} was cut`);
+  }
+  assert(!digest.includes("…"), "nothing in a normal R2 should be shortened");
+  assert(boundOutputDigests([{ digest }]).included.length === 1, "a full R2 must fit the total budget");
+
+  const huge = digestOutput("case", {
+    reinforce: [{ argument: "A", text: "R".repeat(50_000) }],
+    counters: Array.from({ length: 20 }, () => ({ targetArgument: "T".repeat(5_000), counterpoint: "C".repeat(50_000) })),
+  });
+  assert(huge.length <= MAX_CASE_DIGEST_CHARS, "a huge case exceeded its digest bound");
+  assert(!huge.includes("R".repeat(MAX_CASE_PARAGRAPH_CHARS)), "one paragraph exceeded its bound");
+  assert((huge.match(/If they say/g) ?? []).length <= 8, "more than 8 answers were kept");
+});
+
 Deno.test("each feature receives only the debate material its guarantees allow", () => {
   const loaded = {
     debateId: DEBATE,
diff --git a/supabase/functions/_shared/debate-context.ts b/supabase/functions/_shared/debate-context.ts
index 178c09011..a9287ead4 100644
--- a/supabase/functions/_shared/debate-context.ts
+++ b/supabase/functions/_shared/debate-context.ts
@@ -45,8 +45,18 @@ export const MAX_AUTO_OUTPUTS_PER_KIND = 2;
 export const MAX_PINNED_OUTPUTS = 3;
 /** Characters one saved result may contribute. */
 export const MAX_OUTPUT_DIGEST_CHARS = 2_500;
+/**
+ * Characters one saved case may contribute. A case is read out in the round,
+ * so its R2 "backing up" paragraphs, "If they say" answers and Conclusor
+ * reasons reach the prompt in full: an R2 with 6-8 answers runs ~10,000.
+ */
+export const MAX_CASE_DIGEST_CHARS = 12_000;
+/** Characters kept from one of those spoken paragraphs; a safety bound, not a summary length. */
+export const MAX_CASE_PARAGRAPH_CHARS = 2_000;
+/** "If they say" answers kept from one case; R2 writes at most 8. */
+export const MAX_CASE_COUNTERS = 8;
 /** Characters all saved results together may contribute. */
-export const MAX_OUTPUTS_TOTAL_CHARS = 8_000;
+export const MAX_OUTPUTS_TOTAL_CHARS = 16_000;
 
 /**
  * Saved results that help each feature, in order of usefulness. Results of
@@ -179,13 +189,16 @@ function digestCase(data: Record<string, unknown>): string {
   const counters = list(data.counters).map(record).filter(Boolean) as Record<string, unknown>[];
   return lines([
     text(structure.thesis, 300) && `Thesis: ${text(structure.thesis, 300)}`,
-    text(structure.framework, 240) && `Framework: ${text(structure.framework, 240)}`,
+    text(structure.framework, 240) && `How to judge this debate: ${text(structure.framework, 240)}`,
     ...contentions.slice(0, 4).map((item, index) => lines([
-      `Contention ${index + 1}: ${text(item.claim, 200)}`,
-      text(item.reasoning, 320) && `  Warrant: ${text(item.reasoning, 320)}`,
-      text(item.impact, 240) && `  Impact: ${text(item.impact, 240)}`,
+      `Argument ${index + 1}: ${text(item.title, 80) ? `${text(item.title, 80)}. ` : ""}${text(item.claim, 200)}`,
+      text(item.reasoning, 320) && `  Explanation: ${text(item.reasoning, 320)}`,
+      text(item.impact, 240) && `  Why it matters: ${text(item.impact, 240)}`,
     ])),
-    ...counters.slice(0, 3).map((item) => `Prepared answer to "${text(item.targetArgument, 120)}": ${text(item.counterpoint, 200)}`),
+    ...list(data.reinforce).map(record).filter(Boolean).slice(0, 3).map((item) =>
+      text(item!.text, MAX_CASE_PARAGRAPH_CHARS) && `Backing up ${text(item!.argument, 200) || "an argument"}: ${text(item!.text, MAX_CASE_PARAGRAPH_CHARS)}`),
+    ...list(data.whyWeWin).slice(0, 3).map((item) => text(item, MAX_CASE_PARAGRAPH_CHARS) && `Why we win: ${text(item, MAX_CASE_PARAGRAPH_CHARS)}`),
+    ...counters.slice(0, MAX_CASE_COUNTERS).map((item) => `If they say "${text(item.targetArgument, 200)}", we answer: ${text(item.counterpoint, MAX_CASE_PARAGRAPH_CHARS)}`),
   ]);
 }
 
@@ -273,7 +286,8 @@ export function digestOutput(kind: DebateContextOutputKind, data: unknown): stri
     : kind === "chat" ? digestChat(data)
     : kind === "crossfire" ? digestCrossfire(value)
     : digestSparring(value);
-  return digest.length > MAX_OUTPUT_DIGEST_CHARS ? `${digest.slice(0, MAX_OUTPUT_DIGEST_CHARS - 1)}…` : digest;
+  const max = kind === "case" ? MAX_CASE_DIGEST_CHARS : MAX_OUTPUT_DIGEST_CHARS;
+  return digest.length > max ? `${digest.slice(0, max - 1)}…` : digest;
 }
 
 export interface DebateOutputDigest extends DebateOutputRef {
diff --git a/supabase/functions/_shared/output-caps.test.ts b/supabase/functions/_shared/output-caps.test.ts
index 78f4f7d09..766fee2f7 100644
--- a/supabase/functions/_shared/output-caps.test.ts
+++ b/supabase/functions/_shared/output-caps.test.ts
@@ -2,7 +2,7 @@
 // leaves a model no room to answer. These pin the formula from outside it.
 
 import { assertEquals } from "jsr:@std/assert@1.0.19";
-import { outputTokenLimit, REPLY_TOKEN_CAPS, TRUNCATION_RETRY_FACTOR } from "./output-caps.ts";
+import { outputTokenLimit, REASONING_FLOOR_TOKENS, REPLY_TOKEN_CAPS, type ReplyCap, TRUNCATION_RETRY_FACTOR } from "./output-caps.ts";
 import type { ReasoningEffort } from "./model-catalog.ts";
 
 // OpenRouter's Claude budget: max(max_tokens * share, 1024).
@@ -22,7 +22,7 @@ Deno.test("every cap leaves its full reply after Claude's reasoning budget and a
   for (const [cap, reply] of Object.entries(REPLY_TOKEN_CAPS)) {
     for (const effort of EFFORTS) {
       for (const replyTokens of [reply, reply * TRUNCATION_RETRY_FACTOR]) {
-        const limit = outputTokenLimit(replyTokens, effort, 128_000);
+        const limit = outputTokenLimit(replyTokens, effort, 128_000, REASONING_FLOOR_TOKENS[cap as ReplyCap]);
         const claudeBudget = Math.max(Math.floor(limit * CLAUDE_SHARE[effort]), 1_024);
         if (limit - claudeBudget < replyTokens) throw new Error(`${cap} at ${effort}: Claude keeps ${limit - claudeBudget} of ${replyTokens}`);
         if (limit - replyTokens < 2_048) throw new Error(`${cap} at ${effort}: only ${limit - replyTokens} tokens for reasoning`);
@@ -30,3 +30,13 @@ Deno.test("every cap leaves its full reply after Claude's reasoning budget and a
     }
   }
 });
+
+Deno.test("a case keeps 10,000 tokens for reasoning at low effort, on the first try and the retry", () => {
+  // Claude Haiku reasoned for up to 10,000 tokens on an R2 case at low effort;
+  // with 3,000 of room one reply was cut off and its retry nearly timed out.
+  const floor = REASONING_FLOOR_TOKENS.generate;
+  assertEquals(outputTokenLimit(REPLY_TOKEN_CAPS.generate, "low", 128_000, floor), 22_000);
+  assertEquals(outputTokenLimit(REPLY_TOKEN_CAPS.generate * TRUNCATION_RETRY_FACTOR, "low", 128_000, floor), 34_000);
+  // A floor below the effort's own room changes nothing.
+  assertEquals(outputTokenLimit(1_500, "high", 128_000, 1_000), 9_692);
+});
diff --git a/supabase/functions/_shared/output-caps.ts b/supabase/functions/_shared/output-caps.ts
index 4f87b3787..93327f2a9 100644
--- a/supabase/functions/_shared/output-caps.ts
+++ b/supabase/functions/_shared/output-caps.ts
@@ -57,6 +57,17 @@ const REASONING_SHARE_PERCENT: Record<ReasoningEffort, number> = { low: 20, medi
  */
 const REASONING_HEADROOM: Record<ReasoningEffort, number> = { low: 2_048, medium: 4_096, high: 8_192 };
 
+/**
+ * More reasoning room than the effort's floor, for a reply that measured it.
+ * A case is long JSON written after a lot of planning: Claude Haiku at low
+ * effort reasoned for 6,000-10,000 tokens on an R2 case, far past its share
+ * of 15,000, and one reply was cut off and finished only at 128 s of the
+ * 130 s budget. The room only bounds the reply, so it costs nothing unless used.
+ */
+export const REASONING_FLOOR_TOKENS: Partial<Record<ReplyCap, number>> = {
+  generate: 10_000,
+};
+
 /**
  * The max_tokens to send so the reply keeps `replyTokens` after reasoning:
  * after Claude's full budget, and after the headroom for every other model.
@@ -66,7 +77,9 @@ export function outputTokenLimit(
   replyTokens: number,
   effort: ReasoningEffort,
   modelMaxTokens: number,
+  reasoningFloor = 0,
 ): number {
   const afterBudget = Math.ceil((replyTokens * 100) / (100 - REASONING_SHARE_PERCENT[effort]));
-  return Math.min(modelMaxTokens, Math.max(afterBudget, replyTokens + REASONING_HEADROOM[effort]));
+  const headroom = Math.max(REASONING_HEADROOM[effort], reasoningFloor);
+  return Math.min(modelMaxTokens, Math.max(afterBudget, replyTokens + headroom));
 }
diff --git a/supabase/functions/_shared/prompts/generate.ts b/supabase/functions/_shared/prompts/generate.ts
index fb5f79b65..4289c782c 100644
--- a/supabase/functions/_shared/prompts/generate.ts
+++ b/supabase/functions/_shared/prompts/generate.ts
@@ -7,51 +7,56 @@ export const GENERATE_PROMPT = `You are an experienced competitive debater and c
 
 If WEB RESEARCH RESULTS are attached below, treat them as the primary source for current real-world data, statistics, and sources. Prefer evidence from the last two years before the current date. If no research is attached, do not claim that current sources were checked and mark evidence gaps honestly.
 
-=== DEBATE FORMAT (4-6-6-3) ===
+=== THE SPEECH STRUCTURE ===
 
-This is a 4-speaker team debate format. Each speaker has a distinct job:
+Write the case the way school debaters actually prepare it, in plain words:
+1. OPENING: a hook, then the line "Today we will show N arguments that prove..." (or the speaker's own version of it).
+2. ARGUMENTS: each with a short title, a one-sentence point, a plain explanation of why it is true, evidence with a named source and year, and why it matters.
+3. IF THEY SAY...: the opponent's likely claims, each followed by our answer and, when there is one, the source behind the answer.
+4. CLOSING LINE: one sentence that ties back to the opening, like "That is why it is clear that...".
+5. SOURCES: every source the case cites, as organisation, year, the claim it supports, and the link.
+
+Do not use debate theory terms anywhere in the output: no technical labels for parts of a case, no talk of "links", "brightlines", "uniqueness" or "turns", and no scoring of size, likelihood or speed. Write everything in the everyday words a 14-year-old uses in class.
+
+=== THE FOUR SPEAKERS (4-6-6-3) ===
+
+This is a 4-speaker team format. The role decides what the speech contains:
 
 --- INTRODUCTOR (4 minutes) ---
-The Introductor sets the entire narrative. Their job:
-1. EXORDIO: Open with a clear, specific hook, rhetorical question, or vivid scenario. Use a real anecdote or statistic only when the provided research supports it. Never invent one. Then bridge smoothly into the topic.
-2. DEFINITIONS: Define key terms strategically (not dictionary definitions, frame them to favor your side).
-3. FRAMEWORK: Establish the evaluative lens (utilitarian, rights-based, pragmatic, etc.).
-4. THESIS: State your team's central claim clearly and memorably.
-5. ARGUMENT ROADMAP: Preview the structure, "Our team will show three things..."
-The Introductor does NOT present full arguments, they set up the battlefield.
+Opens the team's case. A hook (a vivid scenario, a question, or a fact from the research), then "we will show N arguments that prove..." and the arguments in short form: title, point, and one piece of evidence each. If, and only if, a word in the motion is genuinely unclear (for example "AI tools" or "minors"), add ONE plain line saying how the team understands it in opening.definition. Otherwise leave opening.definition out. Never write a list of definitions.
 
 --- R1 - First Speaker (6 minutes) ---
-R1 is the workhorse. Their job:
-- 4 minutes CONSTRUCTIVE: Build 2-3 core arguments with full warrant chains. Each argument needs: claim → reasoning → evidence → impact. Go DEEP, not wide. Every link in the chain must be airtight.
-- 2 minutes REBUTTAL: Anticipate and preemptively address the strongest opponent arguments. Use turns, mitigations, and no-link responses.
-R1 provides the substance. They make the team's case undeniable with concrete evidence and tight logic.
+Builds the team's case in full. A short opening line, then the arguments in depth: each explanation walks through why it is true, step by step, and each piece of evidence names its source and year. Then the "If they say..." answers to the strongest opposing claims.
 
 --- R2 - Second Speaker (6 minutes) ---
-R2 is the strategist. Their job:
-- EXTEND R1's arguments: Don't just repeat, deepen. Add new evidence, new warranting, responses to likely attacks on R1's case.
-- CLASH: Directly engage with opponent arguments. Identify the central disagreements and explain why your side wins each clash.
-- WEIGHING: Compare impacts. Use magnitude, probability, and timeframe to show why your harms/benefits matter more.
-R2 wins the debate by controlling the narrative and winning the key clashes.
+R2 brings NO new arguments: leave contentions as an empty array. The speech has four parts, in this order:
+1. Opening (a few sentences). A hook that turns the motion around ("Schools present themselves as safe, but if that were true, thousands of children would not be suffering in silence every day."), then who is speaking and what they will prove: "I'm the R2 of my team, and I'm here to show that...". Put the hook in opening.hook and the "I'm the R2..." line in caseStructure.thesis.
+2. Backing up our case (about 2 minutes, write it in reinforce). Go back to the arguments the Introductor and R1 already made and make them stronger. Each item names the earlier argument it returns to ("Our second argument was about bullying.") and then, in one spoken paragraph of about 100-120 words (keep to it, even though the answers in part 3 are much longer): the strongest fact for it with its source and year ("In Spain, 1 in 5 pupils has been bullied (Educo, 2022)"), what that means in plain words, one more fact or study if the research has it, and a sentence that ties it back to the motion ("If schools were really safe, these numbers would not look like this."). Never introduce a point the team has not made. If CURRENT DEBATE CONTEXT includes the team's earlier case, back up those arguments by name; otherwise back up the strongest arguments for our side as "our first argument" and "our second argument".
+3. If they say... (about 4 minutes, the bulk of the speech, written in counters). Prepare one block for each thing the other side is likely to say: their 2-3 main arguments, then the supporting points they will use to back them up, and the answers they will give to our arguments. The speaker underlines the blocks the other side actually used, then speaks them and builds on them, so each block must be complete enough to say in full. Each item:
+   - targetArgument: what they say, in one sentence, the way they would put it ("Teachers and the school solve almost all bullying.").
+   - counterpoint: our full spoken answer, built like this:
+     a) Push back in the first sentence, never by agreeing or conceding ("We accept...", "That is a fair worry", "we agree" are not allowed): say straight away why their point does not hold ("That is what the adults see, but more than 60% of pupils say their school does nothing.").
+     b) Give at least two specific facts against it, each with a number where the research has one, naming the source and year in the sentence ("1 in 3 victims never tells anyone (UNESCO, 2021)").
+     c) Say in plain words what those facts mean for real people ("There is a gap between what teachers say and what pupils live.").
+     d) Ask a pointed question that turns their point around ("If the rules worked, why does 1 in 5 pupils still suffer?").
+     e) Tie it to our own case by name ("This is exactly our second argument: ...").
+   - source: the source of the main fact as "Organisation, year".
+   Every number and fact must come from the attached research or Library. Never invent or estimate one: if the research has no number for a point, make the point with reasoning instead. Every source an answer names must also appear in the sources list. Answer the argument, not the person.
+4. Closing line: one sentence that sums up and ends the speech, like "That is why it is clear that schools are NOT truly safe. Thank you."
+Keep the sentences short and direct, the way a confident student speaks in class: say "we", never hedge ("This is a fair question", "we do not pretend"), and never describe a study's method. Not every "If they say..." block is spoken, so the written answers can run longer than the four minutes.
 
 --- CONCLUSOR (3 minutes) ---
-The Conclusor crystallizes. Their job:
-- NO NEW ARGUMENTS: Only synthesize and weigh what's already been said.
-- KEY CLASHES: Identify the 2-3 most important disagreements in the round and explain why your side wins each one.
-- WEIGHING: Even if the opponent is partially right, explain why your side still wins on balance.
-- STRONG CLOSE: End with a powerful, memorable statement that ties back to the exordio or thesis.
-The Conclusor is the last voice the judge hears. Make it count.
+Closes the debate. NO new arguments: leave contentions and counters as empty arrays. Instead write whyWeWin: 2-3 short paragraphs, each summarising one reason our side won the debate, drawing on what the team already argued. Then the closing line. The opening is one sentence that sets up the summary.
 
 === WRITING STYLE, Sound like a REAL debater ===
 
 DO:
 - Match the requested audience, length, and tone. Use familiar words for beginners and keep brief cases compact.
-- Use debate terminology naturally: "weighing", "impacts", "links", "warrants", "brightlines", "uniqueness", "magnitude", "probability", "timeframe", "turns", "mitigations"
-- Write arguments as you would speak them in round, confident, persuasive, conversational
-- Vary sentence length. Mix short punchy sentences with longer analytical ones.
+- Write every field as something the speaker can say out loud: confident, persuasive, conversational.
+- Vary sentence length. Mix short punchy sentences with longer explanations.
 - Use rhetorical questions: "What happens when we ignore this?"
-- Use transitions that sound human: "Look, here's the thing...", "What does this mean in practice?", "And this is where it gets interesting..."
 - Be assertive: "This matters because..." not "One might argue that..."
-- Use analogies and vivid examples that make abstract points concrete
+- Use analogies and vivid examples that make abstract points concrete.
 
 DO NOT:
 - Say "It is important to note" or "It should be noted"
@@ -59,48 +64,46 @@ DO NOT:
 - Say "In conclusion" or "To summarize"
 - Say "This demonstrates that" or "This clearly shows"
 - Say "One could argue" or "It could be said"
-- Say "It is worth mentioning" or "It is crucial to understand"
 - Use any robotic AI filler phrases. If it sounds like a Wikipedia article, rewrite it.
-- Start every sentence with "The", vary your sentence openings
+- Start every sentence with "The", vary your sentence openings.
 
 === JSON SCHEMA ===
 
-The output MUST include the "exordio" field when the role is "intro". For other roles, omit "exordio".
-
 {
-  "exordio": {
-    "hook": "A compelling opening, anecdote, startling statistic, rhetorical question, or vivid scenario that grabs attention. Should be 2-4 sentences. Make it vivid and specific, not generic.",
-    "transition": "A smooth 1-2 sentence bridge from the hook into the topic and your team's position."
+  "opening": {
+    "hook": "1-2 sentences that grab attention: a vivid scenario, a question, or a fact from the research. Never invent a statistic or anecdote.",
+    "definition": "Introductor only, and only when a motion term is genuinely unclear: one line saying how we understand it. Otherwise omit this field."
   },
   "caseStructure": {
-    "thesis": "A punchy, memorable thesis statement",
-    "framework": "The lens/value through which to evaluate this debate",
-    "keyDefinitions": ["definition1", "definition2"],
-    "burdenOfProof": "Our burden - what we must prove to win the ballot"
+    "thesis": "The roadmap line: 'Today we will show N arguments that prove...' in the speaker's voice."
   },
   "contentions": [
     {
       "id": "1",
-      "claim": "Clear, tagline-style claim",
-      "reasoning": "The warrant - WHY this claim is true. Provide 2-3 logical links with clear causation chains.",
-      "evidence": "Specific stats, studies, expert quotes FROM THE PROVIDED RESEARCH. Cite sources with dates.",
+      "title": "A short title of 2-6 words",
+      "claim": "The point: one sentence a judge can write down.",
+      "reasoning": "The explanation: why the point is true, in plain words, step by step.",
+      "evidence": "A statistic, study, or quote FROM THE PROVIDED RESEARCH, naming the source and year in the sentence, e.g. 'UNICEF said in 2025 that...'.",
       "needsSource": false,
       "sourceQuery": "",
-      "impact": "A cohesive, speech-ready impact paragraph. Explain why the judge should care using magnitude, probability, and timeframe naturally, but never label them as separate parameters."
+      "whyItMatters": "1-2 plain sentences on what this means for real people."
     }
   ],
-  "predictedOpponentCase": {
-    "likelyArguments": ["5-8 arguments they will run"],
-    "strategicWeaknesses": ["Honest assessment of our vulnerabilities"],
-    "keyClashes": ["Where the debate will be won or lost"]
-  },
   "counters": [
     {
-      "targetArgument": "Their argument",
-      "counterpoint": "Our response - turn, mitigate, or take out",
-      "rebuttal": "How to phrase this in round"
+      "targetArgument": "What they will say, in one sentence.",
+      "counterpoint": "Our answer: one speakable paragraph.",
+      "source": "The source behind the answer as 'Organisation, year', when one supports it. Otherwise omit."
     }
   ],
+  "reinforce": [
+    { "argument": "R2 only: the team's earlier argument this returns to, e.g. 'Our second argument: bullying'", "text": "R2 only: one spoken paragraph of about 120-150 words backing it up. Omit for other roles." }
+  ],
+  "whyWeWin": ["Conclusor only: 2-3 short summaries of why our side won. Omit for other roles."],
+  "closingLine": "One sentence that ties back to the opening.",
+  "sources": [
+    { "org": "Organisation or publication", "year": "2025", "claim": "What this source supports, in a few words", "url": "https://the exact link from the research" }
+  ],
   "metadata": {
     "side": "pro",
     "format": "custom",
@@ -108,47 +111,55 @@ The output MUST include the "exordio" field when the role is "intro". For other
   }
 }
 
-ROLE-SPECIFIC OUTPUT GUIDELINES:
-- "intro": MUST include "exordio" with hook and transition. Contention COUNT follows the Length Instruction exactly; keep them high-level roadmap points (lighter on evidence, heavier on framing).
-- "r1": Omit "exordio". Provide DEEP contentions at the Length Instruction count, with extensive evidence and warrants. Counters should be preemptive rebuttals.
-- "r2": Omit "exordio". Contentions are extensions + clash responses at the Length Instruction count. Focus predictedOpponentCase and counters heavily on weighing analysis.
-- "conc": Omit "exordio". Provide contentions framed as crystallization points ("Even if they prove X, we still win because Y"). Counters should be final-round weighing responses.
+CONTROL PRECEDENCE: The Length Instruction sets the EXACT number of items it names: contentions, reinforce and counters items for R2, or whyWeWin items for the Conclusor. Role guidance shapes their depth and order only.
 
-CONTROL PRECEDENCE: When role guidance and the Length Instruction appear to conflict, the Length Instruction sets the EXACT number of contentions. Role guidance shapes their depth and framing only.
-
-SPEECH-READY CONTENTIONS: Each contention must be something the requested speaker can deliver in round:
+SPEECH-READY ARGUMENTS: Each contention must be something the requested speaker can deliver in round:
 - claim: one sentence a judge can write down.
-- reasoning: the warrant. Spell out every causal step from the status quo to the claim, so a listener can see why it is true. Never state a conclusion as its own reason.
-- evidence: say how a specific research or Library source proves the warrant, naming the source and year in the sentence. When no attached source supports it, describe the evidence still needed and set needsSource to true.
-- impact: why the judge should care, then weigh it. Compare it with the other side's most likely impact on size, likelihood, speed, or reversibility, in plain spoken sentences.
-- For "r2" and "conc", every rebuttal in counters must say why our side still wins that clash, not only that the opponent is wrong.
+- reasoning: spell out every step from how things are now to the point, so a listener can see why it is true. Never state a conclusion as its own reason.
+- evidence: say how a specific research or Library source proves the point, naming the source and year in the sentence. When no attached source supports it, describe the evidence still needed and set needsSource to true.
+- whyItMatters: why it matters to real people, compared with what the other side is likely to say, in plain spoken sentences.
+
+SOURCES LIST: List each source the case actually cites once. Copy the link exactly as it appears in the attached research or Library; never invent or guess a link, and leave "url" out when you have none. When no research is attached, the list may be empty.
 
-TEAM CONSISTENCY: If CURRENT DEBATE CONTEXT includes an earlier case or brainstorm for the same side, keep the team line consistent. Reuse its thesis, framework, and definitions unless this request changes them, and extend rather than repeat earlier contentions when the role is "r2" or "conc". Follow the debate's agreed definitions and judge expectations.
+TEAM CONSISTENCY: If CURRENT DEBATE CONTEXT includes an earlier case or brainstorm for the same side, keep the team line consistent. Reuse its opening line and arguments unless this request changes them, and build on rather than repeat earlier arguments when the role is "r2" or "conc". Follow the debate's agreed definitions and judge expectations.
 
 REQUIREMENTS:
 1. Side must be exactly "pro" or "con".
 2. Generate contentions appropriate to the role (see above).
-3. Include 5-8 predicted opponent arguments with pre-written counters.
+3. Introductor and R1: include 5-8 counters, one per likely opposing claim. R2: the exact number of counters the Length Instruction gives, covering their main arguments, supporting points and answers to our case. Conclusor: none.
 4. Use attached WEB RESEARCH when present. Cite only sources that appear in it.
 5. Set needsSource to false only when the attached research supports the contention. Set it to true when the contention still needs evidence.
 6. Write the ENTIRE output in the language specified by the user. All arguments, evidence, descriptions, and analysis must be in that language.
-7. Every contention should read like something a debater can actually say in a speech. Do not output table-like notes or field labels inside prose.`;
+7. Every field should read like something a debater can actually say in a speech. Do not output table-like notes or field labels inside prose.`;
 
 export function buildGenerateUserPrompt(input: Record<string, unknown>, searchContext: string): string {
   const language = asString(input.language, "en");
   const length = asString(input.length, "standard");
   const audience = asString(input.audience, "intermediate");
   const tone = asString(input.tone, "formal");
-  const lengthInstruction = {
-    brief: "Return exactly 2 contentions. Keep each contention compact: one short warrant chain, one evidence point, and one impact.",
-    standard: "Return exactly 3 contentions. Use moderate reasoning depth with clear warrants, evidence, and impacts.",
-    comprehensive: "Return exactly 4 contentions. Use deeper warrant chains, more clash framing, and more developed impact comparison.",
-  }[length] || "Return exactly 3 contentions. Use moderate reasoning depth with clear warrants, evidence, and impacts.";
+  const role = asString(input.role, "intro");
+  const lengthInstruction = role === "r2"
+    ? ({
+      brief: "Return no contentions. Return exactly 2 reinforce items and exactly 5 counters, each answer about 140-170 words.",
+      standard: "Return no contentions. Return exactly 2 reinforce items and exactly 6 counters, each answer about 170-220 words.",
+      comprehensive: "Return no contentions. Return exactly 2 reinforce items and exactly 6 counters, each answer about 220-270 words.",
+    }[length] || "Return no contentions. Return exactly 2 reinforce items and exactly 6 counters, each answer about 170-220 words.")
+    : role === "conc"
+    ? ({
+      brief: "Return no contentions and no counters. Return exactly 2 whyWeWin items, each two or three sentences.",
+      standard: "Return no contentions and no counters. Return exactly 3 whyWeWin items, each two or three sentences.",
+      comprehensive: "Return no contentions and no counters. Return exactly 3 whyWeWin items, each a short developed paragraph.",
+    }[length] || "Return no contentions and no counters. Return exactly 3 whyWeWin items, each two or three sentences.")
+    : ({
+      brief: "Return exactly 2 contentions. Keep each contention compact: a short explanation, one evidence point, and why it matters.",
+      standard: "Return exactly 3 contentions. Give each a clear explanation, evidence, and why it matters.",
+      comprehensive: "Return exactly 4 contentions. Give each a step-by-step explanation, more evidence, and a fuller why it matters.",
+    }[length] || "Return exactly 3 contentions. Give each a clear explanation, evidence, and why it matters.");
   const audienceInstruction = {
-    beginner: "Assume a newer debater: define debate jargon briefly and use straightforward explanation density.",
-    intermediate: "Assume a trained debater: use normal tournament vocabulary with concise explanations.",
-    advanced: "Assume an advanced debater: use dense strategic framing, weighing, and clash vocabulary without over-explaining basics.",
-  }[audience] || "Assume a trained debater: use normal tournament vocabulary with concise explanations.";
+    beginner: "Assume a newer debater: use everyday words and explain each step simply.",
+    intermediate: "Assume a trained debater: use clear, concise explanations.",
+    advanced: "Assume an advanced debater: pack in more evidence and sharper comparisons without over-explaining basics.",
+  }[audience] || "Assume a trained debater: use clear, concise explanations.";
   const toneInstruction = {
     formal: "Use polished, judge-facing language with controlled phrasing.",
     conversational: "Use natural spoken-round phrasing without slang or filler.",
@@ -157,7 +168,7 @@ export function buildGenerateUserPrompt(input: Record<string, unknown>, searchCo
   return `Motion: ${asString(input.motion)}
 Side: ${asString(input.side, "pro")}
 Format: ${asString(input.format, "custom")}
-Role: ${asString(input.role, "intro")}
+Role: ${role}
 Length: ${length}
 Length Instruction: ${lengthInstruction}
 Audience: ${audience}
diff --git a/supabase/functions/_shared/prompts/prompt-examples.test.ts b/supabase/functions/_shared/prompts/prompt-examples.test.ts
index 0d8bff0b3..b72e694e5 100644
--- a/supabase/functions/_shared/prompts/prompt-examples.test.ts
+++ b/supabase/functions/_shared/prompts/prompt-examples.test.ts
@@ -10,7 +10,7 @@ function assert(condition: unknown, message: string): asserts condition {
 
 // The feature-specific quality rules each prompt must carry.
 const QUALITY_RULES: Record<Feature, string[]> = {
-  generate: ["SPEECH-READY CONTENTIONS", "weigh it", "TEAM CONSISTENCY"],
+  generate: ["SPEECH-READY ARGUMENTS", "Do not use debate theory terms", "never invent or guess a link", "TEAM CONSISTENCY"],
   attack: ["TARGET, FLAW, RESPONSE", "exact words from CASE TEXT", "word for word"],
   brainstorm: ["GENUINELY DIFFERENT DIRECTIONS", "same response are one idea"],
   factoids: ["CUTTABLE AND HONEST", "limitations: never empty", "Never round, combine, or extrapolate"],
diff --git a/supabase/functions/_shared/prompts/prompt-examples.ts b/supabase/functions/_shared/prompts/prompt-examples.ts
index 7cd94916c..d11520fad 100644
--- a/supabase/functions/_shared/prompts/prompt-examples.ts
+++ b/supabase/functions/_shared/prompts/prompt-examples.ts
@@ -36,7 +36,7 @@ function debate(side: "pro" | "con" | "both", outputs: DebatePromptContext["outp
   };
 }
 
-const PRO_CASE_DIGEST = "Thesis: Primary homework costs family time and sleep for almost no learning gain.\nContention 1: Homework adds little for young pupils\n  Warrant: Studies find small or no gains before age 11.\n  Impact: Pupils lose rest and play for no benefit.";
+const PRO_CASE_DIGEST = "Thesis: Primary homework costs family time and sleep for almost no learning gain.\nArgument 1: Homework adds little for young pupils\n  Explanation: Studies find small or no gains before age 11.\n  Why it matters: Pupils lose rest and play for no benefit.";
 
 const RESEARCH = `=== WEB RESEARCH RESULTS ===
 
@@ -67,7 +67,7 @@ export const PROMPT_EXAMPLES: PromptExample[] = [
     feature: "generate",
     side: "con",
     input: { motion: MOTION, side: "con", format: "custom", role: "conc", length: "brief", audience: "beginner", tone: "formal", language: "es" },
-    debateContext: debate("con", [{ kind: "case", side: "con", title: "Our R1 case", digest: "Thesis: Short homework builds reading habits a ban would break.\nContention 1: Reading at home improves literacy\n  Impact: Weak readers fall further behind." }]),
+    debateContext: debate("con", [{ kind: "case", side: "con", title: "Our R1 case", digest: "Thesis: Short homework builds reading habits a ban would break.\nArgument 1: Reading at home improves literacy\n  Why it matters: Weak readers fall further behind." }]),
     searchContext: RESEARCH,
   },
   {
diff --git a/supabase/functions/_shared/prompts/sparring.ts b/supabase/functions/_shared/prompts/sparring.ts
index 1a57b1b3a..2b107c4b8 100644
--- a/supabase/functions/_shared/prompts/sparring.ts
+++ b/supabase/functions/_shared/prompts/sparring.ts
@@ -9,10 +9,10 @@ export const SPARRING_PROMPT = `You are DebateOwl's live debate sparring opponen
 The user request contains an action, session context, and at most 12 completed speeches. The context includes the motion, the user's side (pro or con), format (standard, ld, or pf), difficulty (easy, medium, or hard), current turn when responding, and output language. Follow the requested language for every prose field.
 
 The "standard" format is DebateOwl's school 4-6-6-3 format. Both sides speak in this order and must perform the named job:
-- Introductor (4 minutes): open with a concise exordio, define the key terms strategically, establish the framework and thesis, then preview the team's arguments. Set the battlefield. Do not deliver the team's full constructive case.
-- R1 (6 minutes): spend roughly four minutes building the team's core constructive arguments with claim, warrant, support, and impact, then use roughly two minutes to anticipate or answer the strongest opposing material already available.
-- R2 (6 minutes): extend and deepen R1 rather than repeating it, answer the opponent directly, identify the central clashes, and compare impacts using magnitude, probability, and timeframe in natural speech.
-- Conclusor (3 minutes): introduce no new arguments. Crystallize the two or three decisive clashes, weigh the round, explain why the side wins even if part of the opponent's case is true, and close memorably.
+- Introductor (4 minutes): open with a hook, then "we will show N arguments that prove...", and give each argument in short form. Explain a word in the motion in one plain line only when it is genuinely unclear. Do not deliver the team's full arguments.
+- R1 (6 minutes): spend roughly four minutes building the team's arguments in full (the point, why it is true, evidence with its source and year, and why it matters), then use roughly two minutes to answer the strongest opposing points already available.
+- R2 (6 minutes): bring no new arguments. Spend about two minutes backing up the team's earlier arguments by name with stronger evidence, then about four minutes answering the other side point by point ("If they say X, we answer Y"), and end with one closing line.
+- Conclusor (3 minutes): introduce no new arguments. Give the two or three reasons the side won, explain why it still wins even if part of the opponent's case is true, and close memorably.
 
 For action "respond": generate the AI side's speech for the current turn. Match the current turn's side and role, engage with the strongest relevant user point from the transcript, and keep the speech useful for the stated time limit. When format is "standard", follow the matching school-role duties above exactly. When format is "ld" or "pf", perform the conventional job named by that format's current turn rather than importing the school roles. Difficulty is a real control. Difficulty changes argument pressure, not vocabulary. Easy should use plain words and make one clear argument while leaving an obvious opening, medium should answer the central warrant and press a meaningful clash, and hard should apply stronger strategic pressure without becoming more ornate. Return exactly:
 {
diff --git a/supabase/functions/ai/control-matrix.test.ts b/supabase/functions/ai/control-matrix.test.ts
index db941a48e..5bbc5aff4 100644
--- a/supabase/functions/ai/control-matrix.test.ts
+++ b/supabase/functions/ai/control-matrix.test.ts
@@ -27,12 +27,32 @@ Deno.test("generate length and role controls preserve the output contract", () =
     for (const role of ["intro", "r1", "r2", "conc"] as const) {
       const output: Record<string, unknown> = {
         exordio: { hook: "hook", transition: "transition" },
+        opening: { hook: "hook", definition: "definition" },
         contentions: [{}, {}, {}, {}],
+        counters: Array.from({ length: 9 }, () => ({})),
+        reinforce: [{ argument: "Our first argument", text: "backed up" }, { argument: "", text: "  " }],
+        whyWeWin: ["a", "b", "c", "d"],
         metadata: {},
       };
       enforceGenerateControls(output, "pro", "custom", length, role);
-      assert((output.contentions as unknown[]).length === targets[length], `generate.${length} output count`);
+      if (role === "r2") {
+        // R2 brings no new arguments: it backs up the team's and answers theirs.
+        assert((output.contentions as unknown[]).length === 0, `generate.${length}.r2 has no contentions`);
+        assert((output.reinforce as unknown[]).length === 1, `generate.${length}.r2 keeps only reinforce items with text`);
+        assert((output.counters as unknown[]).length === (length === "brief" ? 5 : 6), `generate.${length}.r2 answer count`);
+        assert(!("whyWeWin" in output), "generate.r2 has no whyWeWin");
+      } else if (role === "conc") {
+        // The Conclusor brings 2-3 reasons we win and no new arguments.
+        assert((output.contentions as unknown[]).length === 0, `generate.${length}.conc has no contentions`);
+        assert((output.counters as unknown[]).length === 0, `generate.${length}.conc has no counters`);
+        assert((output.whyWeWin as unknown[]).length === (length === "brief" ? 2 : 3), `generate.${length}.conc whyWeWin count`);
+      } else {
+        assert((output.contentions as unknown[]).length === targets[length], `generate.${length} output count`);
+        assert(!("whyWeWin" in output), `generate.${role} has no whyWeWin`);
+        assert(!("reinforce" in output), `generate.${role} has no reinforce`);
+      }
       assert((role === "intro") === ("exordio" in output), `generate.${role} exordio shape`);
+      assert((role === "intro") === ("definition" in (output.opening as object)), `generate.${role} definition only for the Introductor`);
     }
   }
 });
diff --git a/supabase/functions/ai/features/generate.ts b/supabase/functions/ai/features/generate.ts
index 09a69e9f2..19cd0a0d6 100644
--- a/supabase/functions/ai/features/generate.ts
+++ b/supabase/functions/ai/features/generate.ts
@@ -12,7 +12,7 @@ import {
   getResearchSources,
   withResearchPreferences,
 } from "../../_shared/research.ts";
-import { enforceGenerateControls } from "../../_shared/control-enforcement.ts";
+import { enforceGenerateControls, enforceGenerateSources } from "../../_shared/control-enforcement.ts";
 import { boundPromptSources } from "../../_shared/prompts.ts";
 import { JEV_MODEL } from "../../_shared/jev.ts";
 import {
@@ -112,6 +112,13 @@ export async function handleGenerate(ctx: FeatureContext): Promise<Response> {
     metadata.provider = provider;
   }
   enforceGenerateControls(output, side, format, length, role);
+  // Links the model saw in this request: research pages, search results, Library origins.
+  enforceGenerateSources(output, [
+    ...research.readContent.map((page) => page.url),
+    ...research.searches.flatMap((search) => search.results.map((result) => result.url)),
+    ...research.rankedResults.map((result) => result.url),
+    ...boundPromptSources(sources).flatMap((source) => source.origin ? [source.origin] : []),
+  ].filter((url): url is string => typeof url === "string" && url.length > 0));
 
   // Build discovered sources from research
   const activeAssessmentByKey = new Map(sourceAssessments.map((assessment) => [assessment.key, assessment]));
diff --git a/supabase/functions/ai/prompt-builder.test.ts b/supabase/functions/ai/prompt-builder.test.ts
index 8babfa8fe..941b01e5d 100644
--- a/supabase/functions/ai/prompt-builder.test.ts
+++ b/supabase/functions/ai/prompt-builder.test.ts
@@ -86,7 +86,12 @@ Deno.test("generate prompt matrix preserves every school role and length rule",
 
       assertIncludes(prompt, `Role: ${role}`);
       assertIncludes(prompt, `Length: ${length}`);
-      assertIncludes(prompt, `Length Instruction: Return exactly ${contentionCount} contentions`);
+      assertIncludes(prompt, role === "conc"
+        ? `Length Instruction: Return no contentions and no counters. Return exactly ${length === "brief" ? 2 : 3} whyWeWin items`
+        : role === "r2"
+          // R2 brings no new arguments: one full answer for each thing they are likely to say.
+          ? `Length Instruction: Return no contentions. Return exactly 2 reinforce items and exactly ${length === "brief" ? 5 : 6} counters`
+          : `Length Instruction: Return exactly ${contentionCount} contentions`);
       assertIncludes(prompt, "Language: Hungarian (hu)");
       assertIncludes(prompt, "RESEARCH CONTEXT");
     }
diff --git a/supabase/functions/ai/provider.ts b/supabase/functions/ai/provider.ts
index a49172eaf..5c0f42f7d 100644
--- a/supabase/functions/ai/provider.ts
+++ b/supabase/functions/ai/provider.ts
@@ -13,6 +13,7 @@ import {
 } from "../_shared/model-catalog.ts";
 import {
   outputTokenLimit,
+  REASONING_FLOOR_TOKENS,
   REPLY_TOKEN_CAPS,
   type ReplyCap,
   TRUNCATION_RETRY_FACTOR,
@@ -294,14 +295,15 @@ export async function callAI(
   outputSchema?: JsonOutputSchema,
 ): Promise<AIResult> {
   const replyTokens = REPLY_TOKEN_CAPS[cap];
+  const reasoningFloor = REASONING_FLOOR_TOKENS[cap] ?? 0;
   try {
-    return await callAIOnce(provider, model, systemPrompt, messages, reasoningEffort, replyTokens, signal, stream, outputSchema);
+    return await callAIOnce(provider, model, systemPrompt, messages, reasoningEffort, replyTokens, signal, stream, outputSchema, reasoningFloor);
   } catch (err) {
     if (err instanceof OutputTruncatedError) {
       console.warn(`[AI] Reply hit its ${cap} cap (${replyTokens} tokens, ${model}, effort ${reasoningEffort}); retrying with ${replyTokens * TRUNCATION_RETRY_FACTOR}`);
       stream?.reset();
       return await retryOnce(err.usage, "truncation_retry", () =>
-        callAIOnce(provider, model, systemPrompt, messages, reasoningEffort, replyTokens * TRUNCATION_RETRY_FACTOR, signal, stream, outputSchema)
+        callAIOnce(provider, model, systemPrompt, messages, reasoningEffort, replyTokens * TRUNCATION_RETRY_FACTOR, signal, stream, outputSchema, reasoningFloor)
       );
     }
     if (!(err instanceof InvalidJsonResponseError)) throw attachMissingUsage(err, "call");
@@ -319,6 +321,7 @@ export async function callAI(
         signal,
         stream,
         outputSchema,
+        reasoningFloor,
       )
     );
   }
@@ -384,6 +387,7 @@ export async function callAIOnce(
   signal?: AbortSignal,
   stream?: GenerationStream,
   outputSchema?: JsonOutputSchema,
+  reasoningFloor = 0,
 ): Promise<AIResult> {
   if (provider !== OPENROUTER_PROVIDER) throw new Error(`Unsupported provider: ${provider}`);
   return await callOpenRouter(
@@ -394,6 +398,7 @@ export async function callAIOnce(
     signal,
     stream,
     outputSchema,
+    reasoningFloor,
   );
 }
 
@@ -418,6 +423,7 @@ export async function callOpenRouter(
   signal?: AbortSignal,
   stream?: GenerationStream,
   outputSchema?: JsonOutputSchema,
+  reasoningFloor = 0,
 ): Promise<AIResult> {
   const apiKey = Deno.env.get("OPENROUTER_API_KEY");
   if (!apiKey) throw new Error("OPENROUTER_API_KEY missing");
@@ -426,7 +432,7 @@ export async function callOpenRouter(
   const payload: Record<string, unknown> = {
     model,
     messages: withPromptCaching(model, messages),
-    max_tokens: outputTokenLimit(replyTokens, reasoningEffort, modelEntry.maxTokens),
+    max_tokens: outputTokenLimit(replyTokens, reasoningEffort, modelEntry.maxTokens, reasoningFloor),
     // With require_parameters, a schema routes only to endpoints that enforce it.
     response_format: outputSchema
       ? { type: "json_schema", json_schema: { name: outputSchema.name, strict: true, schema: outputSchema.schema } }
diff --git a/supabase/functions/export-gdoc/generate_test.ts b/supabase/functions/export-gdoc/generate_test.ts
new file mode 100644
index 000000000..5666004c8
--- /dev/null
+++ b/supabase/functions/export-gdoc/generate_test.ts
@@ -0,0 +1,101 @@
+for (const [key, value] of Object.entries({
+  SUPABASE_URL: "https://supabase.test",
+  SUPABASE_ANON_KEY: "test-anon-key",
+  SUPABASE_SERVICE_ROLE_KEY: "test-service-role-key",
+})) Deno.env.set(key, value);
+
+const { buildGenerateContent } = await import("./index.ts");
+
+/** The document text, in the order the export inserts it. */
+function documentText(data: Parameters<typeof buildGenerateContent>[0]): string {
+  return buildGenerateContent(data).requests
+    .flatMap((request) => "insertText" in request && request.insertText ? [request.insertText.text] : [])
+    .join("");
+}
+
+function assertIncludes(text: string, expected: string) {
+  if (!text.includes(expected)) throw new Error(`document is missing "${expected}"\n---\n${text}`);
+}
+
+// The labels and placeholders the restructure removed from every export.
+const OLD_LABELS = /Thesis|Framework|Burden of Proof|Predicted Opponent Case|Counterpoint|No framework provided|No burden of proof provided/i;
+
+function assertExcludes(text: string, unexpected: RegExp) {
+  if (unexpected.test(text)) throw new Error(`document must not contain ${unexpected}\n---\n${text}`);
+}
+
+Deno.test("Google Docs export writes a new case's opening, arguments, answers, closing line and sources", () => {
+  const text = documentText({
+    opening: { hook: "Picture a pupil who hides her phone to use AI at night.", definition: "By minors we mean under-16s." },
+    caseStructure: { thesis: "Today we will show 1 argument that proves a ban does more harm than good." },
+    contentions: [{ title: "One size fits all", claim: "A total ban ignores that children grow up.", reasoning: "A 7-year-old is not a 17-year-old.", evidence: "UNICEF said in 2025 that age limits alone fail.", impact: "Older pupils lose a learning tool." }],
+    counters: [{ targetArgument: "AI makes kids cheat.", counterpoint: "Pupils cheated before AI.", source: "OECD, 2024" }],
+    closingLine: "That is why a ban is the wrong answer.",
+    sources: [
+      { org: "UNICEF", year: "2025", claim: "Age limits alone fail", url: "https://www.unicef.org/report" },
+      { org: "Old Wiki", claim: "Never linked", url: "javascript:alert(1)" },
+    ],
+    metadata: { side: "con", format: "custom", generatedAt: "2026-10-27T10:00:00.000Z" },
+  });
+  for (const expected of [
+    "Opening\n", "Picture a pupil", "What we mean: By minors we mean under-16s.",
+    "Argument 1: One size fits all\n", "Point: A total ban ignores", "Explanation: A 7-year-old", "Why it matters: Older pupils",
+    "If they say…\n", "They say: AI makes kids cheat.\n", "We answer: Pupils cheated before AI.", "Source: OECD, 2024",
+    "Closing line\n", "That is why a ban is the wrong answer.",
+    "Sources\n", "• UNICEF (2025) – Age limits alone fail – https://www.unicef.org/report\n", "• Old Wiki – Never linked\n",
+  ]) assertIncludes(text, expected);
+  assertExcludes(text, OLD_LABELS);
+  assertExcludes(text, /javascript:/);
+});
+
+Deno.test("Google Docs export still writes a case saved before the restructure", () => {
+  const text = documentText({
+    exordio: { hook: "Imagine a city where the bus is free.", transition: "That city is closer than you think." },
+    caseStructure: { thesis: "Free transit is a net public good.", framework: "Net societal benefit.", burdenOfProof: "We must show a net gain.", keyDefinitions: ["Transit: scheduled buses."] },
+    contentions: [{ claim: "Fares block riders.", reasoning: "Fares are regressive.", evidence: "Cities report gains.", impact: "More people reach work." }],
+    predictedOpponentCase: { likelyArguments: ["Funding gap", "Overcrowding"] },
+    counters: [{ targetArgument: "Funding gap", counterpoint: "Collection has overhead.", rebuttal: "Net cost is small." }],
+    metadata: { side: "pro", format: "custom" },
+  });
+  for (const expected of [
+    "Imagine a city where the bus is free. That city is closer than you think.",
+    "Free transit is a net public good.", "How to judge this debate: Net societal benefit.", "What we have to show: We must show a net gain.",
+    "What we mean by the motion: Transit: scheduled buses.", "Argument 1: Fares block riders.\n",
+    "We answer: Collection has overhead.", "Say it like this: Net cost is small.", "They may also say\n", "• Overcrowding\n",
+  ]) assertIncludes(text, expected);
+  // An argument the answers already cover is not listed again.
+  assertExcludes(text, /• Funding gap/);
+  // The old sections keep their content but none of the old labels.
+  assertExcludes(text, OLD_LABELS);
+});
+
+Deno.test("Google Docs export gives a Conclusor case its reasons why we win", () => {
+  const text = documentText({
+    caseStructure: { thesis: "Here is why we won." },
+    contentions: [],
+    counters: [],
+    whyWeWin: ["They never answered our point.", "Only we showed who gets to school."],
+    metadata: { side: "pro" },
+  });
+  assertIncludes(text, "Why we win\n1. They never answered our point.\n2. Only we showed who gets to school.\n");
+  assertExcludes(text, /Arguments\n|If they say/);
+});
+
+Deno.test("Google Docs export gives R2 its backed-up arguments and answers, with no new arguments", () => {
+  const text = documentText({
+    opening: { hook: "Schools look safe, but if that were true, thousands of children would not suffer in silence." },
+    caseStructure: { thesis: "I'm the R2 of my team, and I'm here to show that schools are not safe." },
+    contentions: [],
+    reinforce: [
+      { argument: "Our second argument: bullying", text: "In Spain, 1 in 5 pupils has been bullied (Educo, 2022)." },
+      { argument: "", text: "  " },
+    ],
+    counters: [{ targetArgument: "Schools have emergency plans.", counterpoint: "Emergency plans do not stop everyday bullying.", source: "UNESCO, 2021" }],
+    closingLine: "That is why it is clear that schools are NOT truly safe. Thank you.",
+    metadata: { side: "con" },
+  });
+  assertIncludes(text, "Backing up our case\nOur second argument: bullying\nIn Spain, 1 in 5 pupils has been bullied (Educo, 2022).\n");
+  assertIncludes(text, "They say: Schools have emergency plans.\n");
+  assertExcludes(text, /Arguments\n|Argument 1/);
+  assertExcludes(text, OLD_LABELS);
+});
diff --git a/supabase/functions/export-gdoc/index.ts b/supabase/functions/export-gdoc/index.ts
index 4f3206de2..24df74841 100644
--- a/supabase/functions/export-gdoc/index.ts
+++ b/supabase/functions/export-gdoc/index.ts
@@ -294,26 +294,43 @@ function createDocumentBuilder() {
 // GENERATE MODE
 // ============================================================
 interface GenerateData {
-    caseStructure?: { thesis?: string; framework?: string; burdenOfProof?: string };
-    contentions?: { claim?: string; reasoning?: string; evidence?: string; impact?: string }[];
+    opening?: { hook?: string; definition?: string };
+    exordio?: { hook?: string; transition?: string };
+    caseStructure?: { thesis?: string; framework?: string; burdenOfProof?: string; keyDefinitions?: string[] };
+    contentions?: { title?: string; claim?: string; reasoning?: string; evidence?: string; impact?: string }[];
     predictedOpponentCase?: { likelyArguments?: string[] };
-    counters?: { targetArgument?: string; counterpoint?: string; rebuttal?: string }[];
+    counters?: { targetArgument?: string; counterpoint?: string; rebuttal?: string; source?: string }[];
+    reinforce?: { argument?: string; text?: string }[];
+    whyWeWin?: string[];
+    closingLine?: string;
+    sources?: { org?: string; year?: string; claim?: string; url?: string }[];
     metadata?: { side?: string; format?: string; generatedAt?: string };
-    exordio?: { hook?: string; transition?: string };
 }
 
-function buildGenerateContent(data: GenerateData) {
+function present(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function presentList(value: unknown): string[] {
+    return Array.isArray(value) ? value.map(present).filter((item): item is string => Boolean(item)) : [];
+}
+
+// Mirrors readCase in packages/core/src/ai/case-view.ts: new cases have an
+// opening, arguments (or R2's backed-up arguments, or the Conclusor's reasons
+// why we win), "If they say…", a closing line and sources. Older saved cases
+// keep extra sections, which appear under plain names only when they have content.
+export function buildGenerateContent(data: GenerateData) {
     const {
         requests, insertText, applyTitle, applySubtitle,
         applySectionHeader, applySubHeader, applyLabel, applyBody, applyBullet, applyEmphasis
     } = createDocumentBuilder();
 
-    const thesis = data.caseStructure?.thesis?.trim() || 'Untitled Thesis';
+    const roadmap = present(data.caseStructure?.thesis) || 'Untitled case';
     const motion = (data.metadata as Record<string, unknown>)?.motion as string | undefined;
-    const thesisTitle = motion || (thesis.length > 200 ? thesis.substring(0, 197) + '...' : thesis);
+    const caseTitle = motion || (roadmap.length > 200 ? roadmap.substring(0, 197) + '...' : roadmap);
 
     // Title - Centered, large, bold
-    const titleRange = insertText(`${thesisTitle}\n`);
+    const titleRange = insertText(`${caseTitle}\n`);
     applyTitle(titleRange);
 
     // Metadata - Centered subtitle
@@ -323,109 +340,102 @@ function buildGenerateContent(data: GenerateData) {
     const metaRange = insertText(`${side} • ${format} • ${date}\n`);
     applySubtitle(metaRange);
 
-    // Exordio Section (if present)
-    if (data.exordio && (data.exordio.hook || data.exordio.transition)) {
-        const exordioSectionRange = insertText('Exordio\n');
-        applySectionHeader(exordioSectionRange);
-        if (data.exordio.hook) {
-            const hookLabel = insertText('Hook: ');
-            applyLabel(hookLabel);
-            applyBody(insertText(`${data.exordio.hook}\n`));
-        }
-        if (data.exordio.transition) {
-            const transitionLabel = insertText('Transition: ');
-            applyLabel(transitionLabel);
-            applyBody(insertText(`${data.exordio.transition}\n`));
-        }
-    }
-
-    // Thesis Section
-    const thesisSectionRange = insertText('Thesis\n');
-    applySectionHeader(thesisSectionRange);
-    const thesisBodyRange = insertText(`${thesis}\n`);
-    applyEmphasis(thesisBodyRange);
-
-    // Framework Section
-    const framework = data.caseStructure?.framework?.trim() || 'No framework provided.';
-    const frameworkSectionRange = insertText('Framework\n');
-    applySectionHeader(frameworkSectionRange);
-    applyBody(insertText(`${framework}\n`));
-
-    // Burden of Proof Section
-    const burden = data.caseStructure?.burdenOfProof?.trim() || 'No burden of proof provided.';
-    const burdenSectionRange = insertText('Burden of Proof\n');
-    applySectionHeader(burdenSectionRange);
-    applyBody(insertText(`${burden}\n`));
-
-    // Contentions Section
-    const contentionsSectionRange = insertText('Arguments\n');
-    applySectionHeader(contentionsSectionRange);
-    const contentions = data.contentions || [];
-    if (contentions.length === 0) {
-        applyBody(insertText('No arguments provided.\n'));
-    } else {
+    const section = (title: string) => applySectionHeader(insertText(`${title}\n`));
+    const labelled = (label: string, text: string | undefined) => {
+        if (!text) return;
+        applyLabel(insertText(`${label}: `));
+        applyBody(insertText(`${text}\n`));
+    };
+    const bullets = (items: string[]) => items.forEach((item) => applyBullet(insertText(`• ${item}\n`)));
+
+    // Opening
+    const hook = present(data.opening?.hook)
+        ?? ([present(data.exordio?.hook), present(data.exordio?.transition)].filter(Boolean).join(' ') || undefined);
+    section('Opening');
+    if (hook) applyBody(insertText(`${hook}\n`));
+    labelled('What we mean', present(data.opening?.definition));
+    applyEmphasis(insertText(`${roadmap}\n`));
+    labelled('How to judge this debate', present(data.caseStructure?.framework));
+    labelled('What we have to show', present(data.caseStructure?.burdenOfProof));
+    const definitions = presentList(data.caseStructure?.keyDefinitions);
+    if (definitions.length) labelled('What we mean by the motion', definitions.join('; '));
+
+    // Arguments
+    const contentions = Array.isArray(data.contentions) ? data.contentions : [];
+    if (contentions.length) {
+        section('Arguments');
         contentions.forEach((c, i) => {
-            // Contention header with number
-            const claimRange = insertText(`Argument ${i + 1}: ${c?.claim || 'Untitled'}\n`);
-            applySubHeader(claimRange);
-
-            // Labeled body content
-            if (c?.reasoning) {
-                const reasonLabel = insertText('Reasoning: ');
-                applyLabel(reasonLabel);
-                applyBody(insertText(`${c.reasoning}\n`));
-            }
-            if (c?.evidence) {
-                const evidenceLabel = insertText('Evidence: ');
-                applyLabel(evidenceLabel);
-                applyBody(insertText(`${c.evidence}\n`));
-            }
-            if (c?.impact) {
-                const impactLabel = insertText('Impact: ');
-                applyLabel(impactLabel);
-                applyBody(insertText(`${c.impact}\n`));
-            }
+            const title = present(c?.title);
+            const point = present(c?.claim);
+            applySubHeader(insertText(`Argument ${i + 1}: ${title ?? point ?? 'Untitled'}\n`));
+            if (title) labelled('Point', point);
+            labelled('Explanation', present(c?.reasoning));
+            labelled('Evidence', present(c?.evidence));
+            labelled('Why it matters', present(c?.impact));
         });
     }
 
-    // Predicted Opponent Case Section
-    const predictedSectionRange = insertText('Predicted Opponent Case\n');
-    applySectionHeader(predictedSectionRange);
-    const likelyArgs = data.predictedOpponentCase?.likelyArguments || [];
-    if (likelyArgs.length === 0) {
-        applyBody(insertText('No predicted arguments.\n'));
-    } else {
-        likelyArgs.forEach(arg => {
-            const bulletRange = insertText(`• ${arg}\n`);
-            applyBullet(bulletRange);
+    // R2: the team's earlier arguments, backed up, instead of new ones
+    const reinforce = (Array.isArray(data.reinforce) ? data.reinforce : []).filter((item) => present(item?.text));
+    if (reinforce.length) {
+        section('Backing up our case');
+        reinforce.forEach((item) => {
+            const argument = present(item?.argument);
+            if (argument) applySubHeader(insertText(`${argument}\n`));
+            applyBody(insertText(`${present(item?.text)}\n`));
         });
     }
 
-    // Prepared Counters Section
-    const countersSectionRange = insertText('Prepared Counters\n');
-    applySectionHeader(countersSectionRange);
-    const counters = data.counters || [];
-    if (counters.length === 0) {
-        applyBody(insertText('No counters provided.\n'));
-    } else {
-        counters.forEach((c, i) => {
-            const targetRange = insertText(`Counter ${i + 1}: ${c?.targetArgument || 'Unknown Target'}\n`);
-            applySubHeader(targetRange);
+    // Conclusor: why we win
+    const reasons = presentList(data.whyWeWin);
+    if (reasons.length) {
+        section('Why we win');
+        reasons.forEach((reason, i) => applyBody(insertText(`${i + 1}. ${reason}\n`)));
+    }
 
-            if (c?.counterpoint) {
-                const counterLabel = insertText('Counterpoint: ');
-                applyLabel(counterLabel);
-                applyBody(insertText(`${c.counterpoint}\n`));
-            }
-            if (c?.rebuttal) {
-                const rebuttalLabel = insertText('Rebuttal: ');
-                applyLabel(rebuttalLabel);
-                applyBody(insertText(`${c.rebuttal}\n`));
-            }
-        });
+    // If they say…
+    const counters = (Array.isArray(data.counters) ? data.counters : [])
+        .filter((c) => present(c?.targetArgument) || present(c?.counterpoint) || present(c?.rebuttal));
+    const answered = new Set(counters.map((c) => present(c?.targetArgument)?.toLowerCase()));
+    const likelyArgs = presentList(data.predictedOpponentCase?.likelyArguments)
+        .filter((argument) => !answered.has(argument.toLowerCase()));
+    if (counters.length || likelyArgs.length) {
+        section('If they say…');
+        counters.forEach((c) => {
+            const counterpoint = present(c?.counterpoint);
+            const rebuttal = present(c?.rebuttal);
+            applySubHeader(insertText(`They say: ${present(c?.targetArgument) ?? ''}\n`));
+            labelled('We answer', counterpoint ?? rebuttal);
+            if (counterpoint && rebuttal && rebuttal !== counterpoint) labelled('Say it like this', rebuttal);
+            labelled('Source', present(c?.source));
+        });
+        if (likelyArgs.length) {
+            applySubHeader(insertText('They may also say\n'));
+            bullets(likelyArgs);
+        }
+    }
+
+    const closingLine = present(data.closingLine);
+    if (closingLine) {
+        section('Closing line');
+        applyEmphasis(insertText(`${closingLine}\n`));
+    }
+
+    const sources = (Array.isArray(data.sources) ? data.sources : []).flatMap((source) => {
+        const org = present(source?.org);
+        const year = present(source?.year);
+        const claim = present(source?.claim);
+        const url = present(source?.url);
+        const label = [org, year && `(${year})`].filter(Boolean).join(' ');
+        const line = [label, claim, url && /^https?:\/\//i.test(url) ? url : undefined].filter(Boolean).join(' – ');
+        return line ? [line] : [];
+    });
+    if (sources.length) {
+        section('Sources');
+        bullets(sources);
     }
 
-    return { requests, title: `Debate Case: ${thesisTitle}` };
+    return { requests, title: `Debate Case: ${caseTitle}` };
 }
 
 // ============================================================