@@ -1,6 +1,6 @@
 # Case generation
 
-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.
+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. An R2 case makes five provider calls, all `generate` in `providerCalls()`: a plan, then four parts written at the same time; the last one in the list still carries `Role: r2`. 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
 
 
@@ -82,7 +82,7 @@ Every structured answer is shown while the model writes it. A page passes a `liv
 
 A streamed run keeps its worker alive with `EdgeRuntime.waitUntil` ([`_shared/background.ts`](../supabase/functions/_shared/background.ts)) from the first event until the HTTP layer has read the last one. Supabase otherwise counts the response as sent once its headers are out and may retire the worker mid-run (`EarlyDrop`). Streamed Ask (`ai-stream`) is held the same way until the browser has read its final event. A run still unanswered about 142 s after its request arrived is aborted and gets a retryable timeout `result` instead of a connection cut at the 150 s wall clock; when the aborted run answers within 2 s, that answer is sent instead, so it says `charged: false` when the units went back. Storing the result and waiting for the browser to read it are cut short to finish before the wall clock. The request sends its id as `resultKey`. The function then writes a row to `ai_run_results` when the run starts, and stores the `result` there before sending it ([`ai/run-results.ts`](../supabase/functions/ai/run-results.ts); one row per user and feature, readable only by its owner). When the stream drops, stalls (no keepalive for 45 s), or delivers a result it cannot read, [`src/lib/ai/run-recovery.ts`](../src/lib/ai/run-recovery.ts) polls that row until the run's result appears, then resolves or fails exactly as if the event had arrived. A row still without a status long after it started is a run its worker never finished. A browser Stop, reload, or closed tab still cancels the run. The server cannot tell those from a lost connection, so it stops spending as soon as the connection goes.
 
-A reply that hits its token cap is written again once with twice the cap, after a `reset`. The Generate cap (12,000 tokens) leaves room for a full comprehensive case on Claude Haiku, so a long case finishes on its first attempt. Claude rejects an assistant prefill, so a cut-off reply cannot be continued where it stopped. Sparring calls send a strict `json_schema` (`sparringOutputSchema` in `ai/sparring-persistence.ts`). Anthropic's structured outputs take no numeric or array-size limits, so the 0-25 range, the four categories, and the 12-item lists are enforced by the parser. When a reply parses but has the wrong shape, the log records only the failing field path, never the model's text. The call is then retried once with a repair prompt that names the field. A second failure answers `invalid_output` (502, logged as `invalid_output`), which the browser shows as a malformed answer. The judge also retries once when Claude is briefly unavailable or its stream breaks. The round has already paid, so retries cost the student nothing.
+A reply that hits its token cap is written again once with twice the cap, after a `reset`. The Generate cap (12,000 tokens) leaves room for a full comprehensive case on Claude Haiku, so a long case finishes on its first attempt. Claude rejects an assistant prefill, so a cut-off reply cannot be continued where it stopped. An R2 case is the longest reply (the speech and 10-12 full answers), and one call wrote it in up to 124 s of the 130 s budget, which cannot grow because both Supabase projects are on the Free plan and stop a worker at 150 s. So [`ai/r2-case.ts`](../supabase/functions/ai/r2-case.ts) asks for a short plan first (our two arguments and the claims to answer, at low effort), then writes four parts at the same time at the student's model and effort: part 1 the speech and its share of the answers, streamed to the browser, the others only answers. Each part has its own smaller cap (`caseWriterPart`), which also keeps its reasoning budget small enough to finish well inside the budget. One failed part fails the case, stops the others, and bills every call. Sparring calls send a strict `json_schema` (`sparringOutputSchema` in `ai/sparring-persistence.ts`). Anthropic's structured outputs take no numeric or array-size limits, so the 0-25 range, the four categories, and the 12-item lists are enforced by the parser. When a reply parses but has the wrong shape, the log records only the failing field path, never the model's text. The call is then retried once with a repair prompt that names the field. A second failure answers `invalid_output` (502, logged as `invalid_output`), which the browser shows as a malformed answer. The judge also retries once when Claude is briefly unavailable or its stream breaks. The round has already paid, so retries cost the student nothing.
 
 For a validated Crossfire next turn, the server returns the reply first with a short-lived signed sidecar token. The client then requests a Jev classification of only the newest completed question-answer exchange. The token is atomically claimed through its own one-use counter, separate from the product's daily AI quota. The optional directness, concession, and follow-up signal is attached by turn ID to the answer; a missing, slow, replayed, forged, or failed sidecar never delays or invalidates the main reply. Draft version 1 remains compatible because turn signals are optional.
 
 
@@ -91,13 +91,33 @@ const r2Answer = (index) => ({
 // theirs, and the Conclusor brings reasons why we win. Neither R2 nor the
 // Conclusor brings new arguments.
 const generate = (user) => {
+  // R2 is planned, then written in parts (supabase/functions/ai/r2-case.ts).
+  const planCount = /PLANNING STEP[\s\S]*?theirClaims: exactly (\d+)/.exec(user)?.[1];
+  if (planCount) {
+    return {
+      ourArguments: [
+        { title: "Fares shut people out", claim: "Fares keep the riders who need transit most off the bus." },
+        { title: "More people ride", claim: "Free fares bring more passengers onto public transport." },
+      ],
+      theirClaims: Array.from({ length: Number(planCount) }, (_, index) => `Free transit claim ${index + 1}: it costs the city too much.`),
+    };
+  }
+  const part = /=== WRITING PART (\d+) OF \d+: claims (\d+)-(\d+) ===/.exec(user);
+  if (part && part[1] !== "1") {
+    const [first, last] = [Number(part[2]), Number(part[3])];
+    return {
+      counters: Array.from({ length: last - first + 1 }, (_, index) => r2Answer(first - 1 + index)),
+      sources: [{ org: "UITP", year: "2024", claim: "Ridership rose after fares were removed", url: "https://www.uitp.org/free-fares-2024" }],
+    };
+  }
   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" ? 10 : 12;
+  // R2: one full answer for each thing they are likely to say; part 1 of a
+  // split R2 case writes only its own share of them.
+  const answers = part ? Number(part[3]) - Number(part[2]) + 1 : length === "brief" ? 10 : 12;
   return {
     opening: {
       hook: `${MARK} opening hook: picture a nurse who skips the night bus because the fare is a tenth of her shift's pay.`,
 
@@ -26,6 +26,18 @@ export const REPLY_TOKEN_CAPS = {
    * limit. The cap only bounds the reply, so room costs nothing unless used.
    */
   generate: 12_000,
+  /**
+   * The R2 plan: our two arguments and the claims the other side will make,
+   * one line each. Written at low effort before the parts below.
+   */
+  casePlan: 1_500,
+  /**
+   * One of the parts an R2 case is written in at the same time: the speech
+   * and three answers, or three answers. A part is a quarter of the case, so
+   * its smaller cap also keeps its reasoning budget (a share of max_tokens)
+   * small enough that the slowest part finishes well inside the 130 s budget.
+   */
+  caseWriterPart: 6_000,
   attack: 4_000,
   brainstorm: 4_000,
   factoids: 4_000,
@@ -66,6 +78,7 @@ const REASONING_HEADROOM: Record<ReasoningEffort, number> = { low: 2_048, medium
  */
 export const REASONING_FLOOR_TOKENS: Partial<Record<ReplyCap, number>> = {
   generate: 10_000,
+  caseWriterPart: 10_000,
 };
 
 /**
 
@@ -151,17 +151,38 @@ export const SPEECH_MINUTES: Record<string, number> = { intro: 4, r1: 6, r2: 6,
 /** A student speaks about this many words a minute in a round. */
 export const SPOKEN_WORDS_PER_MINUTE = 130;
 
+/** Arguments per length setting, as the Length Instruction asks for them. */
+const CONTENTION_COUNT: Record<string, number> = { brief: 2, standard: 3, comprehensive: 4 };
+/** Words the opening hook, the thesis line and the closing line take together. */
+const FRAME_WORDS = 90;
+const roundTo5 = (words: number) => Math.max(5, Math.round(words / 5) * 5);
+
+/**
+ * Word targets for each spoken field of one argument, so the arguments add up
+ * to the speech's budget. A single total is not enough: a model asked for
+ * "about 600 words" wrote 750-820, while per-field targets it can follow.
+ */
+function argumentWordTargets(spokenWords: number, length: string): string {
+  const count = CONTENTION_COUNT[length] ?? 3;
+  const perArgument = Math.floor((spokenWords - FRAME_WORDS) / count);
+  const claim = Math.min(20, roundTo5(perArgument * 0.12));
+  const reasoning = roundTo5(perArgument * 0.45);
+  const evidence = roundTo5(perArgument * 0.28);
+  const whyItMatters = roundTo5(perArgument * 0.15);
+  return `With ${count} arguments, each argument is about ${perArgument} spoken words: claim one sentence of at most ${claim} words, reasoning about ${reasoning} words, evidence about ${evidence} words, whyItMatters about ${whyItMatters} words. opening.hook and caseStructure.thesis at most 35 words each, closingLine one sentence of at most 25 words. Aim for these numbers, not under them: a shorter field leaves the speaker's time unused, a longer one runs past it.`;
+}
+
 /** The word budget the speaker reads out, stated in the request so speeches fit their time. */
-export function speechBudgetInstruction(role: string): string | undefined {
+export function speechBudgetInstruction(role: string, length = "standard"): string | undefined {
   const minutes = SPEECH_MINUTES[role];
   if (!minutes) return undefined;
   const words = minutes * SPOKEN_WORDS_PER_MINUTE;
   const head = `${minutes} minutes, about ${words} spoken words at ${SPOKEN_WORDS_PER_MINUTE} words a minute.`;
   switch (role) {
     case "intro":
-      return `${head} The opening, the "we will show" line, the arguments in short form and the closing line together stay within ${words} words. The "If they say..." answers are a separate short prep list.`;
+      return `${head} The opening, the "we will show" line, the arguments in short form and the closing line together stay within ${words} words. ${argumentWordTargets(words, length)} The "If they say..." answers are a separate short prep list.`;
     case "r1":
-      return `${head} The opening, the arguments and the closing line together stay within about ${words - 180} words, leaving time for the "If they say..." answers the speaker picks.`;
+      return `${head} The opening, the arguments and the closing line together stay within about ${words - 180} words, leaving time for the "If they say..." answers the speaker picks. ${argumentWordTargets(words - 180, length)}`;
     case "r2":
       return `${head} The opening, the backing-up paragraphs and the closing line together stay within about 300 words (about 2 minutes); the rest of the time is for the "If they say..." blocks the other side actually used.`;
     default:
@@ -202,7 +223,7 @@ export function buildGenerateUserPrompt(input: Record<string, unknown>, searchCo
     conversational: "Use natural spoken-round phrasing without slang or filler.",
     aggressive: "Use sharper strategic phrasing and clearer attack language while staying professional.",
   }[tone] || "Use polished, judge-facing language with controlled phrasing.";
-  const speechBudget = speechBudgetInstruction(role);
+  const speechBudget = speechBudgetInstruction(role, length);
   return `Motion: ${asString(input.motion)}
 Side: ${asString(input.side, "pro")}
 Format: ${asString(input.format, "custom")}
@@ -217,3 +238,53 @@ ${outputLanguageInstruction(language)}
 
 ${searchContext}`;
 }
+
+// === R2 written in parts ===
+// One R2 case is about 12 full answers plus the speech, which one call wrote
+// in up to 124 s of the 130 s budget. A short plan call picks our arguments
+// and the claims to answer; the parts then write at the same time from it.
+
+/** "If they say..." answers in an R2 case, by length. */
+export function r2CounterCount(length: string): number {
+  return length === "brief" ? 10 : 12;
+}
+
+/** Words per R2 answer, by length (the Length Instruction's range). */
+export function r2AnswerWords(length: string): string {
+  return ({ brief: "100-130", standard: "120-150", comprehensive: "150-180" } as Record<string, string>)[length] ?? "120-150";
+}
+
+export interface R2Plan {
+  ourArguments: Array<{ title: string; claim: string }>;
+  theirClaims: string[];
+}
+
+export function r2PlanInstruction(counterCount: number): string {
+  return `=== PLANNING STEP: do not write the case yet ===
+This R2 case is written in parts at the same time, all from the plan you write now. This step overrides the Length Instruction and the output format: return ONLY this JSON object, in the output language:
+{"ourArguments": [{"title": "a few words", "claim": "one sentence"}, {"title": "a few words", "claim": "one sentence"}], "theirClaims": ["one sentence", "..."]}
+- ourArguments: exactly 2. The team's earlier arguments when CURRENT DEBATE CONTEXT has them, by their own names; otherwise the two strongest arguments for our side that the research backs.
+- theirClaims: exactly ${counterCount} different things the other side is likely to say, each one sentence the way they would put it: first their 2-3 main arguments, then the supporting points they will use to back each of them up, then the answers they will give to each of our two arguments. No two claims make the same point. Prefer claims the attached research lets us answer with facts.`;
+}
+
+/**
+ * The instruction for one part. Part 1 writes the speech (opening, backing up
+ * our case, closing) and its share of the answers; every other part writes
+ * only answers. Answers are numbered across the whole case.
+ */
+export function r2PartInstruction(plan: R2Plan, claims: string[], firstNumber: number, part: number, parts: number, length: string): string {
+  const ours = plan.ourArguments.map((argument, index) => `${index + 1}. ${argument.title}: ${argument.claim}`).join("\n");
+  const list = claims.map((claim, index) => `${firstNumber + index}) ${claim}`).join("\n");
+  const answers = `exactly ${claims.length} counters, one for each of these claims, in this order, each using the claim as its targetArgument:\n${list}\nEach answer about ${r2AnswerWords(length)} words, built as the R2 rules ask, and tied to our arguments by name.`;
+  const head = `=== WRITING PART ${part} OF ${parts}: claims ${firstNumber}-${firstNumber + claims.length - 1} ===
+This R2 case is written in ${parts} parts at the same time, from one plan. This part overrides the Length Instruction's counts.
+Our arguments, in this order (call them "our first argument" and "our second argument"):
+${ours}`;
+  return part === 1
+    ? `${head}
+Write the opening, caseStructure, exactly ${plan.ourArguments.length} reinforce items (one for each of our arguments, in order), the closingLine, and ${answers}
+contentions stays an empty array. sources lists every source this part names.`
+    : `${head}
+Write only "If they say..." answers: return a JSON object with only "counters" and "sources". Write ${answers}
+No opening, reinforce, whyWeWin or closingLine: another part writes them. sources lists every source this part names.`;
+}
@@ -1,6 +1,7 @@
 import { logUsage } from "../../_shared/entitlements.ts";
 import { mergeNormalizedUsage } from "../../_shared/cost.ts";
 import { callAI } from "../provider.ts";
+import { writeR2Case } from "../r2-case.ts";
 import { isRecord } from "../request.ts";
 import { cleanGeneratedText } from "../text.ts";
 import { buildUserPrompt } from "../prompt-builder.ts";
@@ -87,7 +88,11 @@ export async function handleGenerate(ctx: FeatureContext): Promise<Response> {
   const systemPrompt = await buildSystemPromptFor(feature, research);
   const userPrompt = buildUserPrompt(feature, sanitizedInput, searchContext);
   const messages = [{ role: "user", content: userPrompt }];
-  const aiResult = recordMainResult(await callAI(provider, model, systemPrompt, messages, reasoningEffort, "generate", workSignal, ctx.stream));
+  // R2 is the longest reply by far, so it is planned and written in parts at
+  // the same time to finish well inside the request budget (see r2-case.ts).
+  const aiResult = recordMainResult(role === "r2"
+    ? await writeR2Case({ callAI, provider, model, reasoningEffort, systemPrompt, userPrompt, length, signal: workSignal, stream: ctx.stream })
+    : await callAI(provider, model, systemPrompt, messages, reasoningEffort, "generate", workSignal, ctx.stream));
   const output = cleanGeneratedText(aiResult.output);
 
   // Preserve model evidence warnings when research exists. If research