@@ -170,9 +170,9 @@ A run that produces nothing costs nothing. When an `ai` request fails on the ser
 
 Client startup loads Sentry and PostHog asynchronously when configured. Product events and exceptions use the privacy-filtering facade in [`src/lib/observability.ts`](../src/lib/observability.ts), so SDK loading or failure cannot block rendering. Sentry events carry the build's commit SHA as the release and the Vercel environment name. Route crashes keep the original error type and stack frames but replace the message, which can carry user text. Vercel Analytics and Speed Insights run only in the web build and load outside the application render boundary.
 
-The facade accepts only the event names and property values listed in it. `ai_request_failed` says why a request failed: `tool`, `error_code` (one of `limit_reached`, `model_restricted`, `auth_expired`, `timeout`, `network`, `aborted`, `provider_error`, `invalid_response`, `server_error`, `unknown`, mapped from the client's AI error classes in [`src/lib/ai/failure-reason.ts`](../src/lib/ai/failure-reason.ts)), `http_status`, `stage` (`request`, `stream`, `parse`), `streaming` and `duration_ms`. The same file decides each failure's next step: the plan dialog, Sign in again, or Retry. The activation events in [`src/lib/activation-events.ts`](../src/lib/activation-events.ts) are `signup_completed` (`method`), `trial_started`, `paywall_shown` (`reason`, `tool`), `first_ai_success` (`tool`) and `welcome_completed`. The once-per-account ones remember what they sent in this browser's local storage. PostHog keeps its own state in memory and is never told who the user is, so it cannot join one student's events across page loads.
+The facade accepts only the event names and property values listed in it. `ai_request_failed` says why a request failed: `tool`, `error_code` (one of `limit_reached`, `model_restricted`, `auth_expired`, `timeout`, `network`, `aborted`, `provider_error`, `invalid_response`, `server_error`, `unknown`, mapped from the client's AI error classes in [`src/lib/ai/failure-reason.ts`](../src/lib/ai/failure-reason.ts)), `http_status`, `stage` (`request`, `stream`, `parse`), `streaming` and `duration_ms`. The same file decides each failure's next step: the plan dialog, Sign in again, or Retry. The activation events in [`src/lib/activation-events.ts`](../src/lib/activation-events.ts) are `signup_completed` (`method`), `trial_started`, `paywall_shown` (`reason`, `tool`), `first_ai_success` (`tool`) and `welcome_completed`. The once-per-account ones remember what they sent in this browser's local storage. `first_ai_success` is sent only for an account made in the last seven days, so an older account's next answer is not counted as its first. PostHog keeps its own state in memory and is never told who the user is, so it cannot join one student's events across page loads.
 
-Every `React.lazy` component and route loader goes through `loadChunk` in [`src/lib/lazy-chunk.ts`](../src/lib/lazy-chunk.ts). After a deploy removes an old file, the page reloads once per path (guarded in `sessionStorage`, shared with the `vite:preloadError` listener) instead of crashing on a module that loaded as nothing.
+Every `React.lazy` component and route loader goes through `loadChunk` in [`src/lib/lazy-chunk.ts`](../src/lib/lazy-chunk.ts). After a deploy removes an old file, the page reloads once per path in ten minutes (the time is kept in `sessionStorage` and shared with the `vite:preloadError` listener, so a file still missing after the reload stays an error while a later deploy can reload again) instead of crashing on a module that loaded as nothing.
 
 CI and staging must not upload authenticated browser captures. Logging must not expose tokens, provider keys, user content, or protected staging values.
 
 
@@ -19,7 +19,7 @@ import { focusCurrentDebate, noteTourChunkFailure, tourChunkGaveUp } from "@/lib
 import { OfflineIndicator } from "@/components/OfflineIndicator";
 import { StagingBanner } from "@/components/StagingBanner";
 import { captureException, captureProductEvent, toTelemetrySafeError } from "@/lib/observability";
-import { captureSignupCompleted, captureTrialStarted, captureWelcomeCompleted } from "@/lib/activation-events";
+import { captureSignupCompleted, captureTrialStarted, captureWelcomeCompleted, rememberActivationAccount } from "@/lib/activation-events";
 import { useSubscription } from "@/hooks/use-subscription";
 import { lazyChunk, loadChunk, namedChunk } from "@/lib/lazy-chunk";
 import { appLayoutLoader, localizedRouteLoaders, preloadStartupRoute, routeLoaders, type RouteLoader } from "@/lib/route-modules";
@@ -273,12 +273,13 @@ export function ToolRouteAnalytics(): null {
   return null;
 }
 
-/** signup_completed and trial_started, once per new account. AppLayout's trial banner shares this subscription read. */
+/** signup_completed and trial_started, once per new account, and the account first_ai_success checks. AppLayout's trial banner shares this subscription read. */
 export function ActivationAnalytics(): null {
   const { user } = useAuth();
   const { tier, loading } = useSubscription();
 
   useEffect(() => {
+    rememberActivationAccount(user ?? null);
     if (user) captureSignupCompleted(user);
   }, [user]);
 
 
@@ -55,17 +55,31 @@ function signedInUserId(): string | null {
   }
 }
 
-/** The first answer an account gets from any tool. */
-export function captureFirstAISuccess(tool: string): void {
-  captureOncePerAccount('first_ai_success', signedInUserId(), { tool });
-}
-
 export interface ActivationUser {
   id: string;
   created_at?: string;
   app_metadata?: Record<string, unknown>;
 }
 
+// A first answer counts only for an account this young. Older accounts had
+// answers before this event existed, so their next one is not their first.
+const FIRST_SUCCESS_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+
+let activationAccount: ActivationUser | null = null;
+
+/** The signed-in account, so captureFirstAISuccess can tell a new account from an old one. */
+export function rememberActivationAccount(user: ActivationUser | null): void {
+  activationAccount = user;
+}
+
+/** The first answer a new account gets from any tool. */
+export function captureFirstAISuccess(tool: string, now = Date.now()): void {
+  const accountId = signedInUserId();
+  if (!accountId || activationAccount?.id !== accountId) return;
+  if (!isNewAccount(activationAccount, now, FIRST_SUCCESS_WINDOW_MS)) return;
+  captureOncePerAccount('first_ai_success', accountId, { tool });
+}
+
 export type SignupMethod = 'demo' | 'email' | 'google';
 
 export function signupMethod(user: ActivationUser): SignupMethod | null {
@@ -76,9 +90,9 @@ export function signupMethod(user: ActivationUser): SignupMethod | null {
   return null;
 }
 
-export function isNewAccount(user: ActivationUser, now = Date.now()): boolean {
+export function isNewAccount(user: ActivationUser, now = Date.now(), windowMs = NEW_ACCOUNT_WINDOW_MS): boolean {
   const created = user.created_at ? Date.parse(user.created_at) : NaN;
-  return Number.isFinite(created) && now - created >= 0 && now - created <= NEW_ACCOUNT_WINDOW_MS;
+  return Number.isFinite(created) && now - created >= 0 && now - created <= windowMs;
 }
 
 /** A first sign-in to an account created in the last day. Returns whether it was sent. */
 
@@ -1,4 +1,8 @@
 const RELOAD_PREFIX = 'debatelab-stale-chunk:';
+// One automatic reload per path in this window. A file still missing after
+// the reload stays an error instead of refreshing the tab again, while a
+// later deploy in the same tab can still reload once.
+export const STALE_CHUNK_RELOAD_WINDOW_MS = 10 * 60 * 1000;
 
 type ReloadTarget = Pick<Window, 'addEventListener' | 'sessionStorage' | 'location'> & {
   navigator: Pick<Navigator, 'onLine'>;
@@ -19,17 +23,23 @@ export function resetStaleChunkReloadForTests(): void {
 /**
  * Reloads the page once per path for a chunk the deployed build no longer has.
  * Returns whether a reload was started. A second failure on the same path
- * stays put, so a missing file cannot refresh the tab forever. Offline the
+ * within STALE_CHUNK_RELOAD_WINDOW_MS stays put, so a missing file cannot
+ * refresh the tab forever. Offline the
  * chunk is not stale, only unreachable: a reload could replace the page with
  * the browser's offline error, so the error stands instead.
  */
-export function reloadOnceForStaleChunk(target: ReloadTarget = window): boolean {
+export function reloadOnceForStaleChunk(target: ReloadTarget = window, now: number = Date.now()): boolean {
   if (reloadRequested) return true;
   if (target.navigator.onLine === false) return false;
   const key = `${RELOAD_PREFIX}${target.location.pathname || '/'}`;
   try {
-    if (target.sessionStorage.getItem(key) === '1') return false;
-    target.sessionStorage.setItem(key, '1');
+    // The value is when this path last reloaded. A '1' from an older build has no time and counts as old.
+    const stored = target.sessionStorage.getItem(key);
+    if (stored !== null && stored !== '1') {
+      const last = Number(stored);
+      if (!Number.isFinite(last) || now - last < STALE_CHUNK_RELOAD_WINDOW_MS) return false;
+    }
+    target.sessionStorage.setItem(key, String(now));
   } catch {
     return false;
   }
 
@@ -2690,7 +2690,7 @@
   },
   "serverErrors": {
     "signInRequired": "Please sign in to continue.",
-    "sessionExpired": "Authentication failed. Your session may have expired. Please sign in again.",
+    "sessionExpired": "We couldn't confirm you're signed in. Sign in again to keep going.",
     "accessDenied": "Access denied. Your session may have expired. Please sign in again.",
     "banned": "Your account has been suspended. Please contact support.",
     "requestTooLarge": "Request is too large. Shorten the input and try again.",
 
@@ -2597,7 +2597,7 @@
     "unexpected": "Se produjo un error inesperado",
     "offline": "Comprueba tu conexión e inténtalo de nuevo.",
     "notCharged": "No se te ha cobrado esta solicitud.",
-    "signInAgain": "Volver a iniciar sesión"
+    "signInAgain": "Vuelve a iniciar sesión"
   },
   "clock": {
     "timeUp": "Se acabó el tiempo.",
@@ -2690,7 +2690,7 @@
   },
   "serverErrors": {
     "signInRequired": "Inicia sesión para continuar.",
-    "sessionExpired": "No se pudo verificar tu sesión. Puede que haya caducado. Vuelve a iniciar sesión.",
+    "sessionExpired": "No pudimos comprobar que has iniciado sesión. Vuelve a iniciar sesión para continuar.",
     "accessDenied": "Acceso denegado. Puede que tu sesión haya caducado. Vuelve a iniciar sesión.",
     "banned": "Tu cuenta está suspendida. Ponte en contacto con soporte.",
     "requestTooLarge": "La solicitud es demasiado grande. Acorta el texto e inténtalo de nuevo.",
 
@@ -2597,7 +2597,7 @@
     "unexpected": "Váratlan hiba történt",
     "offline": "Ellenőrizd a kapcsolatot, és próbáld újra.",
     "notCharged": "Ezt a kérést nem számoltuk el.",
-    "signInAgain": "Bejelentkezés újra"
+    "signInAgain": "Jelentkezz be újra"
   },
   "clock": {
     "timeUp": "Lejárt az idő.",
@@ -2690,7 +2690,7 @@
   },
   "serverErrors": {
     "signInRequired": "A folytatáshoz jelentkezz be.",
-    "sessionExpired": "A hitelesítés nem sikerült. Lehet, hogy lejárt a munkameneted. Jelentkezz be újra.",
+    "sessionExpired": "Nem sikerült ellenőrizni, hogy be vagy-e jelentkezve. Jelentkezz be újra a folytatáshoz.",
     "accessDenied": "Hozzáférés megtagadva. Lehet, hogy lejárt a munkameneted. Jelentkezz be újra.",
     "banned": "A fiókodat felfüggesztettük. Fordulj az ügyfélszolgálathoz.",
     "requestTooLarge": "A kérés túl nagy. Rövidítsd le a szöveget, és próbáld újra.",
 
@@ -11,6 +11,7 @@ vi.mock('@/lib/supabase/client', () => ({ getActiveUserId: () => activeUser.id }
 import {
   captureFirstAISuccess,
   captureOncePerAccount,
+  rememberActivationAccount,
   captureSignupCompleted,
   captureTrialStarted,
   captureWelcomeCompleted,
@@ -28,21 +29,34 @@ describe('activation events', () => {
     localStorage.clear();
     captureProductEventMock.mockReset();
     activeUser.id = null;
+    rememberActivationAccount(null);
   });
 
   it('sends first_ai_success once per account, and again for another account', () => {
     activeUser.id = 'user-a';
-    captureFirstAISuccess('ask');
-    captureFirstAISuccess('generate');
+    rememberActivationAccount(newUser('user-a', { provider: 'email' }));
+    captureFirstAISuccess('ask', NOW);
+    captureFirstAISuccess('generate', NOW);
     activeUser.id = 'user-b';
-    captureFirstAISuccess('crossfire');
+    rememberActivationAccount(newUser('user-b', { provider: 'google' }));
+    captureFirstAISuccess('crossfire', NOW);
 
     expect(sent('first_ai_success')).toEqual([
       ['first_ai_success', { tool: 'ask' }],
       ['first_ai_success', { tool: 'crossfire' }],
     ]);
   });
 
+  it('does not count an older account\'s next answer as its first', () => {
+    activeUser.id = 'old-user';
+    rememberActivationAccount({ id: 'old-user', created_at: '2026-09-01T00:00:00Z' });
+    captureFirstAISuccess('ask', NOW);
+    // An account the page has not read yet is not guessed at either.
+    activeUser.id = 'unknown-user';
+    captureFirstAISuccess('ask', NOW);
+    expect(sent('first_ai_success')).toHaveLength(0);
+  });
+
   it('sends nothing without an account or when storage cannot remember', () => {
     captureFirstAISuccess('ask');
     const blocked = { getItem: () => { throw new Error('blocked'); }, setItem: (): void => undefined };
 
@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { installStaleChunkReload, resetStaleChunkReloadForTests } from '@/lib/reload-stale-chunk';
+import { STALE_CHUNK_RELOAD_WINDOW_MS, installStaleChunkReload, reloadOnceForStaleChunk, resetStaleChunkReloadForTests } from '@/lib/reload-stale-chunk';
 
 function fakeWindow() {
   const listeners = new Map<string, (event: Event) => void>();
@@ -45,6 +45,25 @@ describe('stale chunk reload', () => {
     expect(reload).toHaveBeenCalledTimes(1);
   });
 
+  it('reloads again for a later deploy, but not twice inside the window', () => {
+    const { target, reload } = fakeWindow();
+    const start = 1_000_000;
+    const asWindow = target as unknown as Window;
+    expect(reloadOnceForStaleChunk(asWindow, start)).toBe(true);
+    resetStaleChunkReloadForTests();
+    expect(reloadOnceForStaleChunk(asWindow, start + 5_000)).toBe(false);
+    resetStaleChunkReloadForTests();
+    expect(reloadOnceForStaleChunk(asWindow, start + STALE_CHUNK_RELOAD_WINDOW_MS + 1)).toBe(true);
+    expect(reload).toHaveBeenCalledTimes(2);
+  });
+
+  it('treats a value it cannot read as a recent reload', () => {
+    const { target, reload } = fakeWindow();
+    target.sessionStorage.setItem('debatelab-stale-chunk:/app/ask', 'not-a-time');
+    expect(reloadOnceForStaleChunk(target as unknown as Window)).toBe(false);
+    expect(reload).not.toHaveBeenCalled();
+  });
+
   it('never reloads while offline, where a missing chunk is unreachable rather than stale', () => {
     const { target, listeners, reload } = fakeWindow();
     target.navigator.onLine = false;