Tell a saved debates list from the server's

An offline or unreachable read answered with the saved copy looked like a
server answer, so the five-day question could still open from it; and a
failed refresh kept a copy another refresh had painted. cachedReadFrom says
where its answer came from, and the debates provider tracks whether the
list on screen is a copy.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Programcode

apps/mobile/src/lib/debate-context.tsx

@@ -9,7 +9,7 @@ import {
   continueDebate,
   createDebate,
   deleteDebate,
-  fetchDebates,
+  fetchDebatesFrom,
   sortDebates,
   switchDebate,
   updateDebate,
@@ -63,6 +63,8 @@ export function DebateProvider({ children }: { children: ReactNode }) {
   const refreshes = useRef(0);
   const owner = useRef(userId);
   const generation = useRef(0);
+  // The list on screen is a saved copy (painted while loading, or answered offline), not the server's.
+  const showingCopy = useRef(false);
 
   const refresh = useCallback(async () => {
     const forUser = owner.current;
@@ -71,30 +73,29 @@ export function DebateProvider({ children }: { children: ReactNode }) {
     const request = ++refreshes.current;
     const gen = generation.current;
     const current = () => generation.current === gen && owner.current === forUser && refreshes.current === request && writes.current === writesBefore;
-    // Whether this request painted the saved copy, which a failed refresh must not leave on screen.
-    let paintedCopy = false;
     return await runRequest(async () => {
-      const show = (next: Awaited<ReturnType<typeof fetchDebates>>) => {
+      const show = (next: Awaited<ReturnType<typeof fetchDebatesFrom>>['value']) => {
         if (!current()) return;
-        paintedCopy = true;
+        showingCopy.current = true;
         setFresh(false);
         setDebates((previous) => keepIfSame(previous, next.debates));
         setCurrentId(next.currentId);
         setStatus('ready');
       };
-      const next = await fetchDebates(forUser, show);
+      const { value: next, fromCopy } = await fetchDebatesFrom(forUser, show);
       if (!current()) return;
       // Refreshes run on every Debate tab focus; an unchanged list keeps its identity so the tabs do not re-render.
       setDebates((previous) => keepIfSame(previous, next.debates));
       setCurrentId(next.currentId);
       setStatus('ready');
-      setFresh(true);
+      showingCopy.current = fromCopy;
+      setFresh(!fromCopy);
     }, async (cause) => {
       // A switch or create since this refresh began already holds newer state.
       if (!current()) return;
       console.warn('Could not load debates:', cause instanceof Error ? cause.message : cause);
-      // Keep a list the server already gave; a copy painted by this refresh must not hide its refusal.
-      setStatus((previous) => (previous === 'ready' && !paintedCopy ? previous : 'error'));
+      // Keep a list the server gave; a saved copy on screen must not hide its refusal.
+      setStatus((previous) => (previous === 'ready' && !showingCopy.current ? previous : 'error'));
     });
   }, []);
 
@@ -106,6 +107,7 @@ export function DebateProvider({ children }: { children: ReactNode }) {
     setOneOff(false);
     setStatus('loading');
     setFresh(false);
+    showingCopy.current = false;
     if (!userId) return;
     void refresh();
     // Pick up debates started or switched on the website while the app was in the background.

apps/mobile/src/lib/debates.ts

@@ -1,4 +1,4 @@
-import { afterWrite, cachedRead, pickFailure, readAll, readFailed, updateCopy, type CopyMark, type CopyScope } from './offline-cache';
+import { afterWrite, cachedRead, cachedReadFrom, pickFailure, readAll, readFailed, updateCopy, type CopyMark, type CopyScope } from './offline-cache';
 import { supabase } from './supabase';
 
 /**
@@ -112,6 +112,11 @@ export function fetchDebates(userId: string, onCopy?: (value: DebateList) => voi
   return cachedRead(userId, 'debates', 'all', () => loadDebates(userId), undefined, onCopy);
 }
 
+/** fetchDebates, saying whether the list is the saved copy rather than the server's answer. */
+export function fetchDebatesFrom(userId: string, onCopy?: (value: DebateList) => void): Promise<{ value: DebateList; fromCopy: boolean }> {
+  return cachedReadFrom(userId, 'debates', 'all', () => loadDebates(userId), undefined, onCopy);
+}
+
 async function loadDebates(userId: string): Promise<DebateList> {
   const [debatesResult, currentResult] = await Promise.all([
     supabase.from('debates').select(DEBATE_COLUMNS).eq('user_id', userId).order('last_activity_at', { ascending: false }),

apps/mobile/src/lib/offline-cache.test.ts

@@ -184,6 +184,14 @@ describe('which failures fall back', () => {
     await expect(cachedRead('user-a', 'sources', 'debate-1', offlineFailure)).resolves.toEqual(['source']);
   });
 
+  // The five-day question waits for a list the server gave (debate-context.tsx), never a copy.
+  it('says when the answer is the saved copy rather than the server', async () => {
+    const { cachedReadFrom, setCacheOwner } = await load();
+    setCacheOwner('user-a');
+    await expect(cachedReadFrom('user-a', 'debates', 'all', async () => ['debate'])).resolves.toEqual({ value: ['debate'], fromCopy: false });
+    await expect(cachedReadFrom('user-a', 'debates', 'all', offlineFailure)).resolves.toEqual({ value: ['debate'], fromCopy: true });
+  });
+
   it('throws a refused session, a policy error or any other server answer instead of serving the copy', async () => {
     const { cachedRead, readFailed, setCacheOwner } = await load();
     setCacheOwner('user-a');

apps/mobile/src/lib/offline-cache.ts

@@ -322,6 +322,11 @@ function noteShown(storageKey: string, group: CacheGroup, fromCopy: boolean, mar
  * A screen passes its load's `mark` so a copy it shows stops counting once it moves on.
  */
 export async function cachedRead<T>(userId: string, group: CacheGroup, key: string, load: () => Promise<T>, mark?: CopyMark, onCopy?: (value: T) => void): Promise<T> {
+  return (await cachedReadFrom(userId, group, key, load, mark, onCopy)).value;
+}
+
+/** cachedRead, also saying whether the answer is the saved copy (offline or unreachable) rather than the server's. */
+export async function cachedReadFrom<T>(userId: string, group: CacheGroup, key: string, load: () => Promise<T>, mark?: CopyMark, onCopy?: (value: T) => void): Promise<{ value: T; fromCopy: boolean }> {
   const ticket = ++tickets;
   const gen = generation;
   const storageKey = entryKey(userId, group, key);
@@ -331,7 +336,7 @@ export async function cachedRead<T>(userId: string, group: CacheGroup, key: stri
     if (copy && gen === generation && userId === owner) {
       settle(ticket);
       if (gen === generation) noteShown(storageKey, group, true, mark);
-      return copy.value;
+      return { value: copy.value, fromCopy: true };
     }
   }
   let value: T;
@@ -365,11 +370,11 @@ export async function cachedRead<T>(userId: string, group: CacheGroup, key: stri
     const copy = await readCopy<T>(userId, group, key).catch(() => undefined);
     if (!copy || gen !== generation || userId !== owner) throw cause;
     if (gen === generation) noteShown(storageKey, group, true, mark);
-    return copy.value;
+    return { value: copy.value, fromCopy: true };
   }
   if (gen === generation) noteShown(storageKey, group, false, mark);
   writeCopy(userId, group, key, value, ticket, gen).catch(warn('Could not keep a saved copy'));
-  return value;
+  return { value, fromCopy: false };
 }
 
 /**