@@ -90,8 +90,12 @@ A configured mock provider bypasses Supabase for local and test behavior. It is
 
 Shared research, source ranking, URL validation, and prompt construction live under [`supabase/functions/_shared/`](../supabase/functions/_shared/).
 
+Research makes two small model calls of its own: Ask decides whether a question needs web search, and deep research writes follow-up search queries. Both run on `BACKGROUND_MODEL` (Claude Haiku 5.5 at low effort) in [`supabase/functions/_shared/model-catalog.ts`](../supabase/functions/_shared/model-catalog.ts), not on the model the user picked; only the answer uses that model. Their usage is still added to the parent request's row.
+
 The import endpoint validates public HTTP URLs, resolves redirect targets, blocks private networks, and enforces response timeout, content type, and size limits. Research paths bound source count and content before prompt construction.
 
+[`supabase/functions/_shared/prompt-budget.ts`](../supabase/functions/_shared/prompt-budget.ts) holds the limits that set how many input tokens a request pays for: characters kept per fetched page, search snippets per research prompt, earlier Ask messages, and the Ask context cap. A research prompt lists each source once: a page read in full is not repeated as a search snippet, and a URL that several queries found appears a single time. For `anthropic/*` models the system prompt carries a `cache_control` breakpoint, so a repeat of the same prefix within five minutes is billed at the cache-read price; a prompt below the model's minimum cacheable length is sent uncached at the normal price.
+
 Every AI request in a Current Debate carries a `debateContext` of IDs and preferences, never text: the debate, the side the request prepares, the Library source IDs, and the saved results to read. [`src/lib/debate/context.ts`](../src/lib/debate/context.ts) chooses the default with the rules in [`supabase/functions/_shared/debate-context.ts`](../supabase/functions/_shared/debate-context.ts): the debate's active sources, pinned results first, then up to three of the newest results of the types that feature uses, for the requested side. A compact line above each tool's primary button shows that selection, and Review changes it for one request, or for a whole Crossfire or Sparring round, where Review appears only before the round starts; pins persist in `debate_context_pins`. [`supabase/functions/_shared/debate-context-loader.ts`](../supabase/functions/_shared/debate-context-loader.ts) loads the motion, settings, instructions, sources, and result digests with every query filtered by the caller and the one debate, before quota or provider work. The prompt renders that material in delimited blocks followed by rules that it cannot override. Live sparring stays transcript-only: the scorecard sees only the motion and settings. Crossfire omits free-form instructions. Whole results are dropped when their budget is spent, and a Crossfire round that would pass its 100,000-character prompt budget drops its saved results. In both cases `meta.debateContext` reports what reached the model and what was set aside. A debate deleted on another device returns 404, and the browser reloads its debate list. One-off requests send no debate context. The retired per-user custom system prompt is no longer sent or honored; operator prompts in `global_prompts` remain. Jev scores relevance, importance, and evidence strength after the existing deterministic quality floor, while failures preserve the prior order. Generate also records a bounded source-use snapshot in the saved case output. Semantic counts and the latest case-use flag live in the existing source `metadata` JSON, so the Library can default to Smart ordering without a schema migration.
 
 Ordinary Ask remains stateless while a conversation is in progress. The browser sends only the newest eight messages within a UTF-8 byte budget. Inside a debate, each finished exchange is recorded into one chat for that debate; in one-off mode, pressing Save persists the chat and its messages; Workspace threads use their separate durable server-side context path. Legacy local-only sources are not sent to the authenticated AI endpoint because they have no persisted UUID to authorize and load.
 
@@ -176,16 +176,28 @@ const routes = [
   ["ask", "You are a debate coach chat bot", ask],
 ];
 
+// A cacheable system prompt arrives as text parts instead of a plain string.
+function messageText(message) {
+  const content = message?.content;
+  if (Array.isArray(content)) return content.map((part) => part?.text ?? "").join("");
+  return String(content ?? "");
+}
+
 function classify(body) {
   const messages = Array.isArray(body.messages) ? body.messages : [];
-  const system = String(messages.find((message) => message.role === "system")?.content ?? "");
+  const systemMessage = messages.find((message) => message.role === "system");
+  const system = messageText(systemMessage);
   const user = String(messages.at(-1)?.content ?? "");
+  const shape = {
+    messageCount: messages.length,
+    cacheBreakpoint: Array.isArray(systemMessage?.content) && systemMessage.content.some((part) => part?.cache_control),
+  };
   if (body.stream === true && system.includes("Answer in clear Markdown that can stream smoothly")) {
-    return { feature: "ask-stream", system, user };
+    return { feature: "ask-stream", system, user, ...shape };
   }
   const route = routes.find(([, marker]) => system.includes(marker));
-  if (!route) return { feature: null, system, user };
-  return { feature: route[0], system, user, output: route[2](user, system) };
+  if (!route) return { feature: null, system, user, ...shape };
+  return { feature: route[0], system, user, ...shape, output: route[2](user, system) };
 }
 
 function jevAnswers(questions) {
@@ -358,8 +370,9 @@ createServer(async (req, res) => {
   }
 
   const body = JSON.parse(await readBody(req));
-  const { feature, system, user, output } = classify(body);
-  requests.push({ feature, model: body.model, stream: body.stream === true, system, user });
+  const { output, ...record } = classify(body);
+  const { feature } = record;
+  requests.push({ ...record, model: body.model, stream: body.stream === true });
   if (!feature) return json(res, 500, { error: { message: "Fake OpenRouter does not recognize this prompt" } });
 
   const failure = failures.find((item) => item.count > 0 && (!item.feature || item.feature === feature));
 
@@ -172,6 +172,12 @@ export interface SessionState {
   setFactoidsForm: (data: Partial<FactoidsInput>) => void;
 
   setGenerateResult: (result: GenerateOutput | null) => void;
+  /**
+   * Debate the current Generate result belongs to. Null is one-off work.
+   * Undefined means a result restored before this was recorded.
+   */
+  generateResultDebateId: string | null | undefined;
+  setGenerateResultDebateId: (debateId: string | null) => void;
   setGenerateLoading: (loading: boolean) => void;
   setGenerateRegeneratingSection: (section: string | null) => void;
   saveCurrentCase: (title: string) => Promise<void>;
@@ -316,6 +322,7 @@ function sessionWorkForAccount(ownerUserId: string | null): Partial<SessionState
     askStreamingAssistant: null,
     pendingFlowchartData: null,
     generateForm: {},
+    generateResultDebateId: undefined,
     attackForm: {},
     brainstormForm: {},
     factoidsForm: {},
@@ -541,11 +548,13 @@ export const useSessionStore = create<SessionState>()(
       sourceLibrary: [] as Source[],
 
       generateForm: {},
+      generateResultDebateId: undefined as string | null | undefined,
       attackForm: {},
       brainstormForm: {},
       factoidsForm: {},
 
       setGenerateForm: (data) => set((state) => ({ generateForm: mergeFormState(state.generateForm, data) })),
+      setGenerateResultDebateId: (debateId) => set({ generateResultDebateId: debateId }),
       setAttackForm: (data) => set((state) => ({ attackForm: mergeFormState(state.attackForm, data) })),
       setBrainstormForm: (data) => set((state) => ({ brainstormForm: mergeFormState(state.brainstormForm, data) })),
       setFactoidsForm: (data) => set((state) => ({ factoidsForm: mergeFormState(state.factoidsForm, data) })),
@@ -895,13 +904,37 @@ export const useSessionStore = create<SessionState>()(
         set((state) => ({ savedCases: [savedItem, ...state.savedCases] }));
       },
       deleteSavedCase: async (id) => {
-        set((state) => ({ savedCases: state.savedCases.filter((c) => c.id !== id) }));
-        const userId = await getUserId();
-        await applyUserScopedIdFilter(supabase.from('cases').delete(), userId, id);
+        const previous = get().savedCases;
+        set({ savedCases: previous.filter((item) => item.id !== id) });
+        try {
+          const userId = await getUserId();
+          // A missing session must not report success for a row the server still has.
+          if (!userId) throw new Error('[SessionStore] Could not confirm the signed-in user to delete a case');
+          throwOnWriteError(
+            await applyUserScopedIdFilter(supabase.from('cases').delete(), userId, id),
+            'delete case',
+          );
+        } catch (error) {
+          set({ savedCases: previous });
+          throw error;
+        }
       },
       loadSavedCase: (id) => {
         const item = get().savedCases.find((c) => c.id === id);
-        if (item) set({ generateResult: item.data });
+        if (!item) return;
+        const motion = item.data.metadata?.motion?.trim();
+        const side = item.data.metadata?.side;
+        set({
+          generateResult: item.data,
+          // Null means this case is one-off, so a later regenerate does not
+          // borrow whichever debate happens to be open.
+          generateResultDebateId: item.debateId ?? null,
+          generateForm: {
+            ...get().generateForm,
+            ...(motion ? { motion } : {}),
+            ...(side ? { side } : {}),
+          },
+        });
       },
 
       setAttackResult: (result) => {
@@ -1307,6 +1340,7 @@ export const useSessionStore = create<SessionState>()(
         askPersistedCount: 0,
         pendingFlowchartData: null,
         generateForm: {},
+        generateResultDebateId: undefined,
         attackForm: {},
         brainstormForm: {},
         factoidsForm: {},
 
@@ -36,14 +36,16 @@ import { useDebateMotionGate } from '@/components/features/debate/DebateMotionGa
 
 export default function GeneratePage() {
   const workspace = useWorkspaceToolScope('generate');
-  const { generateResult, generateLoading, generateRegeneratingSection: regeneratingSection, generateForm, setGenerateResult, setGenerateLoading, setGenerateRegeneratingSection, saveCurrentCase, setPendingFlowchartData, autosavedCases, recordResult, updateRecordedResult } = useSessionStore(useShallow((state) => ({
+  const { generateResult, generateLoading, generateRegeneratingSection: regeneratingSection, generateForm, generateResultDebateId, setGenerateResult, setGenerateLoading, setGenerateRegeneratingSection, setGenerateResultDebateId, saveCurrentCase, setPendingFlowchartData, autosavedCases, recordResult, updateRecordedResult } = useSessionStore(useShallow((state) => ({
     generateResult: state.generateResult,
     generateLoading: state.generateLoading,
     generateRegeneratingSection: state.generateRegeneratingSection,
     generateForm: state.generateForm,
+    generateResultDebateId: state.generateResultDebateId,
     setGenerateResult: state.setGenerateResult,
     setGenerateLoading: state.setGenerateLoading,
     setGenerateRegeneratingSection: state.setGenerateRegeneratingSection,
+    setGenerateResultDebateId: state.setGenerateResultDebateId,
     saveCurrentCase: state.saveCurrentCase,
     setPendingFlowchartData: state.setPendingFlowchartData,
     autosavedCases: state.autosavedCases,
@@ -107,6 +109,7 @@ export default function GeneratePage() {
       setGenerateResult(result);
       setRecordedCaseId(null);
       setResultDebateId(target.debateId);
+      setGenerateResultDebateId(target.debateId);
       await workspace.attach(data, result);
       if (target.debateId) {
         setRecordedCaseId(await recordInDebate(() => recordResult('case', { title: data.motion, input: data, output: result, debateId: target.debateId, side: data.side })));
@@ -135,26 +138,31 @@ export default function GeneratePage() {
 
   const handleRegenerateSection = (section: string) => {
     if (generateLoading || regeneratingSection) return;
-    if (!generateForm?.motion || !generateResult) {
+    const motion = generateResult?.metadata?.motion?.trim() || generateForm?.motion;
+    if (!motion || !generateResult) {
       toast({ title: t('generate.regenerateUnavailable', 'Cannot regenerate yet'), description: t('generate.regenerateUnavailableDesc', 'Generate a case first, then retry a section.'), variant: 'destructive' });
       return;
     }
 
     const data: GenerateInput = {
-      motion: generateForm.motion,
-      side: generateForm.side || 'pro',
-      format: generateForm.format || 'custom',
-      role: generateForm.role || 'r1',
-      length: generateForm.length || 'standard',
-      audience: generateForm.audience || 'intermediate',
-      tone: generateForm.tone || 'formal',
+      motion,
+      side: generateResult.metadata?.side || generateForm?.side || 'pro',
+      format: generateForm?.format || 'custom',
+      role: generateForm?.role || 'r1',
+      length: generateForm?.length || 'standard',
+      audience: generateForm?.audience || 'intermediate',
+      tone: generateForm?.tone || 'formal',
     };
 
     // Regenerate against the result's own debate, never whichever is current now.
+    // A loaded case records that debate on the store; this page's state only
+    // knows it until the student leaves and comes back.
     const current = selectCurrentDebate(useDebateStore.getState());
     const debateId = resultDebateId !== undefined
       ? resultDebateId
-      : sameMotion(current?.motion, data.motion) ? activeDebateId() : null;
+      : generateResultDebateId !== undefined
+        ? generateResultDebateId
+        : sameMotion(current?.motion, data.motion) ? activeDebateId() : null;
     // One section at a time: each regeneration merges into the result it started from.
     const base = generateResult;
     setGenerateRegeneratingSection(section);
 
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
   findCustomerOwnedByUser,
+  hasOpenSubscription,
   isAllowedCheckoutRedirectUrl,
 } from "../../supabase/functions/create-checkout/checkout-security";
 
@@ -28,4 +29,15 @@ describe("checkout security", () => {
     expect(findCustomerOwnedByUser(customers, "user-123")).toBe("cus_correct");
     expect(findCustomerOwnedByUser(customers, "missing-user")).toBeNull();
   });
+
+  it("treats a subscription that can still bill as a reason to refuse another checkout", () => {
+    expect(hasOpenSubscription([{ status: "active" }, { status: "canceled" }])).toBe(true);
+    expect(hasOpenSubscription([{ status: "trialing" }])).toBe(true);
+    expect(hasOpenSubscription([{ status: "past_due" }])).toBe(true);
+    expect(hasOpenSubscription([{ status: "paused" }])).toBe(true);
+    expect(hasOpenSubscription([{ status: "unpaid" }])).toBe(true);
+    expect(hasOpenSubscription([{ status: "canceled" }, { status: "incomplete" }, { status: "incomplete_expired" }])).toBe(false);
+    expect(hasOpenSubscription([])).toBe(false);
+    expect(hasOpenSubscription(null)).toBe(false);
+  });
 });
@@ -45,6 +45,10 @@ const mockAddAskMessage = vi.fn();
 const mockSetAskLoading = vi.fn();
 let mockGenerateResult: any = null;
 let mockGenerateForm: any = { motion: 'Existing motion', side: 'pro', format: 'bp', role: 'intro', length: 'brief', audience: 'beginner', tone: 'formal' };
+let mockGenerateResultDebateId: string | null | undefined;
+const mockSetGenerateResultDebateId = vi.fn((debateId: string | null) => {
+    mockGenerateResultDebateId = debateId;
+});
 
 let mockRegeneratingSection: string | null = null;
 const mockStoreListeners = new Set<() => void>();
@@ -60,10 +64,12 @@ vi.mock('@/lib/stores/session-store', async () => {
         generateLoading: false,
         generateRegeneratingSection: mockRegeneratingSection,
         generateForm: mockGenerateForm,
+        generateResultDebateId: mockGenerateResultDebateId,
         autosavedCases: [] as any[],
         setGenerateResult: mockSetGenerateResult,
         setGenerateLoading: mockSetGenerateLoading,
         setGenerateRegeneratingSection: mockSetRegeneratingSection,
+        setGenerateResultDebateId: mockSetGenerateResultDebateId,
         saveCurrentCase: mockSaveCurrentCase,
         addAskMessage: mockAddAskMessage,
         setAskLoading: mockSetAskLoading,
@@ -127,6 +133,7 @@ describe('GeneratePage Integration', () => {
         vi.clearAllMocks();
         mockGenerateResult = null;
         mockRegeneratingSection = null;
+        mockGenerateResultDebateId = undefined;
         mockGenerateForm = { motion: 'Existing motion', side: 'pro', format: 'bp', role: 'intro', length: 'brief', audience: 'beginner', tone: 'formal' };
     });
 
@@ -331,6 +338,29 @@ describe('GeneratePage Integration', () => {
         expect((generateCase as Mock).mock.calls[1][3]).toBeNull();
     });
 
+    it('regenerates a loaded case with that case\'s motion and debate', async () => {
+        seedCurrentDebate({ motion: 'Existing motion' });
+        mockGenerateResultDebateId = 'loaded-debate';
+        mockGenerateResult = {
+            caseStructure: { thesis: 'Loaded thesis' },
+            contentions: [] as any[],
+            predictedOpponentCase: {},
+            counters: [] as any[],
+            metadata: { side: 'con', format: 'custom', motion: 'Loaded motion', generatedAt: '2026-01-01T00:00:00Z' },
+        };
+        (generateCase as Mock).mockResolvedValue({ result: mockGenerateResult, discoveredSources: [] });
+
+        render(<BrowserRouter><GeneratePage /></BrowserRouter>);
+        fireEvent.click(screen.getByTestId('regenerate-section'));
+
+        await waitFor(() => expect(generateCase).toHaveBeenCalledTimes(1));
+        expect((generateCase as Mock).mock.calls[0][0]).toEqual(expect.objectContaining({
+            motion: 'Loaded motion',
+            side: 'con',
+        }));
+        expect((generateCase as Mock).mock.calls[0][3]).toBe('loaded-debate');
+    });
+
     it('after a reload, regenerates in the Current Debate only when the motion matches', async () => {
         const result = { caseStructure: { thesis: 'Restored' }, contentions: [] as any[], predictedOpponentCase: {}, counters: [] as any[], metadata: {} };
         (generateCase as Mock).mockResolvedValue({ result, discoveredSources: [] });