Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

52.0 KB
Raw Blame
import { act, render, screen, waitFor } from '@testing-library/react';
import { useEffect } from 'react';
import { beforeEach, describe, expect, it, vi } from 'vitest';

import * as coreStateApi from '../../services/coreStateApi';
import * as tauriCommands from '../../utils/tauriCommands';
import { __resetForTests as resetConfigRecoveryNotice } from '../../lib/configRecoveryNotice';
import { getCoreStateSnapshot, setCoreStateSnapshot } from '../../lib/coreState/store';
import { store } from '../../store';
import { notificationReceived } from '../../store/notificationSlice';
import { setActiveUserId } from '../../store/userScopedStorage';
import CoreStateProvider, {
  coreStatePollFailureDebugMessage,
  coreStatePollFailureWarningMessage,
  useCoreState,
} from '../CoreStateProvider';

vi.mock('../../services/coreStateApi');
vi.mock('../../services/analytics', () => ({ syncAnalyticsConsent: vi.fn() }));

type Snapshot = Awaited<ReturnType<typeof coreStateApi.fetchCoreAppSnapshot>>;

function makeSnapshot(overrides: {
  userId?: string | null;
  sessionToken?: string | null;
  isAuthenticated?: boolean;
  authUser?: unknown | null;
  currentUser?: unknown | null;
}): Snapshot {
  return {
    auth: {
      isAuthenticated: overrides.isAuthenticated ?? Boolean(overrides.userId),
      userId: overrides.userId ?? null,
      user: (overrides.authUser ?? null) as never,
      profileId: null,
    },
    sessionToken: overrides.sessionToken ?? null,
    currentUser: (overrides.currentUser ?? null) as never,
    onboardingCompleted: false,
    chatOnboardingCompleted: false,
    analyticsEnabled: false,
    localState: {},
    runtime: { localAi: null as never, service: null as never },
  };
}

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { promise, resolve, reject };
}

function makeJwt(payload: Record<string, unknown>): string {
  const encode = (value: Record<string, unknown>) =>
    window.btoa(JSON.stringify(value)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');

  return `${encode({ alg: 'none', typ: 'JWT' })}.${encode(payload)}.signature`;
}

type CoreStateContextValue = ReturnType<typeof useCoreState>;

function Consumer({ captureCtx }: { captureCtx?: (ctx: CoreStateContextValue) => void }) {
  const state = useCoreState();
  useEffect(() => {
    captureCtx?.(state);
  });
  return (
    <div>
      <span data-testid="user">{state.snapshot.auth.userId ?? 'none'}</span>
      <span data-testid="token">{state.snapshot.sessionToken ?? 'none'}</span>
      <span data-testid="teams">{state.teams.map(t => t.team._id).join(',')}</span>
      <span data-testid="members">
        {Object.entries(state.teamMembersById)
          .map(([k, v]) => `${k}:${v.length}`)
          .join(',')}
      </span>
      <span data-testid="invites">
        {Object.entries(state.teamInvitesById)
          .map(([k, v]) => `${k}:${v.length}`)
          .join(',')}
      </span>
      <span data-testid="ready">{state.isReady ? 'ready' : 'boot'}</span>
    </div>
  );
}

function resetCoreStateStore() {
  setCoreStateSnapshot({
    isBootstrapping: true,
    isReady: false,
    snapshot: {
      auth: { isAuthenticated: false, userId: null, user: null, profileId: null },
      sessionToken: null,
      currentUser: null,
      onboardingCompleted: false,
      chatOnboardingCompleted: false,
      analyticsEnabled: true,
      localState: { encryptionKey: null, onboardingTasks: null, keyringConsent: null },
      keyringStatus: {
        available: true,
        failureReason: null,
        activeMode: 'os_keyring',
        backendName: 'os',
      },
      runtime: { localAi: null, service: null },
    },
    teams: [],
    teamMembersById: {},
    teamInvitesById: {},
  });
}

describe('CoreStateProvider — identity-change cache clearing', () => {
  const fetchSnapshot = vi.mocked(coreStateApi.fetchCoreAppSnapshot);
  const listTeams = vi.mocked(coreStateApi.listTeams);
  const getTeamMembers = vi.mocked(coreStateApi.getTeamMembers);
  const getTeamInvites = vi.mocked(coreStateApi.getTeamInvites);

  beforeEach(() => {
    fetchSnapshot.mockReset();
    listTeams.mockReset();
    getTeamMembers.mockReset();
    getTeamInvites.mockReset();
    resetCoreStateStore();
    setActiveUserId(null);
  });

  it('clears teams/members/invites when the userId changes between refreshes', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([{ team: { _id: 'team-u1' }, role: 'owner' } as never]);
    getTeamMembers.mockResolvedValue([{ userId: 'u1' } as never]);
    getTeamInvites.mockResolvedValue([{ id: 'invite-u1' } as never]);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('user').textContent).toBe('u1'));
    await waitFor(() => expect(screen.getByTestId('teams').textContent).toBe('team-u1'));

    // Seed team-scoped caches we expect to be wiped on identity flip.
    await act(async () => {
      await ctx!.refreshTeamMembers('team-u1');
      await ctx!.refreshTeamInvites('team-u1');
    });
    expect(screen.getByTestId('members').textContent).toBe('team-u1:1');
    expect(screen.getByTestId('invites').textContent).toBe('team-u1:1');

    // Flip identity: next refresh returns u2.
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u2', sessionToken: 'tok2' }));
    listTeams.mockResolvedValue([]);
    await act(async () => {
      await ctx!.refresh();
    });

    await waitFor(() => expect(screen.getByTestId('user').textContent).toBe('u2'));
    expect(screen.getByTestId('teams').textContent).toBe('');
    expect(screen.getByTestId('members').textContent).toBe('');
    expect(screen.getByTestId('invites').textContent).toBe('');
  });

  it('clears scoped caches when transitioning authenticated → unauthenticated', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([{ team: { _id: 'team-a' }, role: 'owner' } as never]);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('teams').textContent).toBe('team-a'));

    fetchSnapshot.mockResolvedValue(
      makeSnapshot({ userId: null, sessionToken: null, isAuthenticated: false })
    );
    await act(async () => {
      await ctx!.refresh();
    });

    await waitFor(() => expect(screen.getByTestId('user').textContent).toBe('none'));
    expect(screen.getByTestId('teams').textContent).toBe('');
  });

  it('preserves teams cache when identity is unchanged across refreshes', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValueOnce([
      { team: { _id: 'team-x' }, role: 'owner' } as never,
      { team: { _id: 'team-y' }, role: 'member' } as never,
    ]);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('teams').textContent).toBe('team-x,team-y'));

    // Subsequent refresh returns same identity — team cache must be preserved
    // because refreshTeams is not re-issued by normal refresh.
    await act(async () => {
      await ctx!.refresh();
    });

    expect(screen.getByTestId('teams').textContent).toBe('team-x,team-y');
    expect(listTeams).toHaveBeenCalledTimes(1);
  });

  it('sets isReady=true once the first snapshot resolves', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: null, sessionToken: null }));
    listTeams.mockResolvedValue([]);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    expect(screen.getByTestId('ready').textContent).toBe('boot');
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));
  });

  it('does not commit a poll snapshot after the provider unmounts (#1934)', async () => {
    const pendingSnapshot = deferred<Snapshot>();
    fetchSnapshot.mockReturnValue(pendingSnapshot.promise);
    listTeams.mockResolvedValue([]);

    const { unmount } = render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    expect(screen.getByTestId('ready').textContent).toBe('boot');

    unmount();

    await act(async () => {
      pendingSnapshot.resolve(makeSnapshot({ userId: 'late-user', sessionToken: 'late-token' }));
      await pendingSnapshot.promise;
    });

    const snapshot = getCoreStateSnapshot();
    expect(snapshot.isReady).toBe(false);
    expect(snapshot.snapshot.auth.userId).toBeNull();
    expect(snapshot.snapshot.sessionToken).toBeNull();
  });

  it('warns when the initial core state poll fails', async () => {
    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});

    try {
      fetchSnapshot.mockRejectedValue(new Error('core offline'));

      render(
        <CoreStateProvider>
          <Consumer />
        </CoreStateProvider>
      );

      await waitFor(() =>
        expect(warnSpy).toHaveBeenCalledWith('[core-state] bootstrap poll failed (attempt 1/5):', {
          message: 'core offline',
        })
      );
    } finally {
      warnSpy.mockRestore();
    }
  });

  it('backs off poll interval after bootstrap budget is exhausted', async () => {
    vi.useFakeTimers();
    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});

    try {
      fetchSnapshot.mockRejectedValue(new Error('core unavailable'));
      listTeams.mockResolvedValue([]);

      render(
        <CoreStateProvider>
          <Consumer />
        </CoreStateProvider>
      );

      // Initial load fires immediately
      await act(async () => {
        await vi.advanceTimersByTimeAsync(0);
      });

      // Advance through MAX_BOOTSTRAP_RETRIES (5) polls at 2s intervals
      for (let i = 0; i < 5; i++) {
        await act(async () => {
          await vi.advanceTimersByTimeAsync(2000);
        });
      }

      // After budget exhaustion, next poll fires at 10s — not at 2s
      const callsBefore = fetchSnapshot.mock.calls.length;
      await act(async () => {
        await vi.advanceTimersByTimeAsync(2000);
      });
      expect(fetchSnapshot.mock.calls.length).toBe(callsBefore);

      // Advance remaining 8s (total 10s) — poll fires now
      await act(async () => {
        await vi.advanceTimersByTimeAsync(8000);
      });
      expect(fetchSnapshot.mock.calls.length).toBe(callsBefore + 1);
    } finally {
      vi.useRealTimers();
      warnSpy.mockRestore();
    }
  });

  it('reverts to normal poll interval after recovery from backoff', async () => {
    vi.useFakeTimers();
    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});

    try {
      fetchSnapshot.mockRejectedValue(new Error('core unavailable'));
      listTeams.mockResolvedValue([]);

      render(
        <CoreStateProvider>
          <Consumer />
        </CoreStateProvider>
      );

      // Exhaust bootstrap budget: initial load + 5 scheduled polls
      await act(async () => {
        await vi.advanceTimersByTimeAsync(0);
      });
      for (let i = 0; i < 5; i++) {
        await act(async () => {
          await vi.advanceTimersByTimeAsync(2000);
        });
      }

      // Make the next (backoff) poll succeed — resets counter to 0
      fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: null, sessionToken: null }));
      await act(async () => {
        await vi.advanceTimersByTimeAsync(10000);
      });

      // After recovery, the next poll should fire at the normal 2s interval
      const callsBefore = fetchSnapshot.mock.calls.length;
      await act(async () => {
        await vi.advanceTimersByTimeAsync(2000);
      });
      expect(fetchSnapshot.mock.calls.length).toBe(callsBefore + 1);
    } finally {
      vi.useRealTimers();
      warnSpy.mockRestore();
    }
  });

  it('backfills snapshot.currentUser from auth.user when currentUser is missing', async () => {
    fetchSnapshot.mockResolvedValue(
      makeSnapshot({
        userId: 'u1',
        sessionToken: 'tok1',
        authUser: { first_name: 'Ada', username: 'ada' },
        currentUser: null,
      })
    );
    listTeams.mockResolvedValue([]);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));
    await waitFor(() =>
      expect(ctx?.snapshot.currentUser).toEqual({ first_name: 'Ada', username: 'ada' })
    );
  });

  it('ignores malformed session-token-updated events (#1937)', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: null, sessionToken: null }));
    listTeams.mockResolvedValue([]);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:session-token-updated', {
          detail: { sessionToken: 'not-a-jwt' },
        })
      );
    });

    expect(screen.getByTestId('token').textContent).toBe('none');
    expect(fetchSnapshot).toHaveBeenCalledTimes(1);
  });

  it('ignores expired JWT-shaped session-token-updated events (#1937)', async () => {
    const expiredToken = makeJwt({ exp: Math.floor(Date.now() / 1000) - 60 });
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: null, sessionToken: null }));
    listTeams.mockResolvedValue([]);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:session-token-updated', {
          detail: { sessionToken: expiredToken },
        })
      );
    });

    expect(screen.getByTestId('token').textContent).toBe('none');
    expect(fetchSnapshot).toHaveBeenCalledTimes(1);
  });

  it('accepts unexpired JWT-shaped session-token-updated events (#1937)', async () => {
    const token = makeJwt({ exp: Math.floor(Date.now() / 1000) + 60 });
    fetchSnapshot
      .mockResolvedValueOnce(makeSnapshot({ userId: null, sessionToken: null }))
      .mockResolvedValueOnce(
        makeSnapshot({ userId: null, sessionToken: token, isAuthenticated: true })
      );
    listTeams.mockResolvedValue([]);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:session-token-updated', { detail: { sessionToken: token } })
      );
    });

    expect(screen.getByTestId('token').textContent).toBe(token);
  });

  it('storeSessionToken skips refreshTeams for a local session token', async () => {
    const localToken = `eyJhbGciOiJub25lIn0.${window.btoa(JSON.stringify({ sub: 'local' }))}.local`;
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'local', sessionToken: localToken }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.storeSession).mockReset();
    vi.mocked(tauriCommands.storeSession).mockResolvedValue(undefined as never);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      await ctx!.storeSessionToken(localToken, { id: 'local' });
    });

    expect(vi.mocked(tauriCommands.storeSession)).toHaveBeenCalledWith(localToken, { id: 'local' });
    expect(listTeams).not.toHaveBeenCalled();
  });

  it('ignores auth-expired events when the current session is a local token', async () => {
    const localToken = `eyJhbGciOiJub25lIn0.${window.btoa(JSON.stringify({ sub: 'local' }))}.local`;
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'local', sessionToken: localToken }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.team_get_usage', source: 'rpc' },
        })
      );
    });

    // Wait a tick to ensure any async handler had a chance to run.
    await act(async () => {});

    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
  });

  it('does not clear a local session while its refreshed snapshot is still pending', async () => {
    const localToken = `eyJhbGciOiJub25lIn0.${window.btoa(JSON.stringify({ sub: 'local' }))}.local`;
    const stored = deferred<void>();
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'cloud-user', sessionToken: 'old' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.storeSession).mockReset();
    vi.mocked(tauriCommands.storeSession).mockReturnValue(stored.promise as never);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer captureCtx={next => (ctx = next)} />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    let storing!: Promise<void>;
    await act(async () => {
      storing = ctx!.storeSessionToken(localToken, { id: 'local' });
      await Promise.resolve();
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: {
            method: 'openhuman.announcements_get_latest',
            source: 'rpc',
            reason: 'confirmed',
          },
        })
      );
      // Drain past the microtask queue: the handler may `await` before it can
      // reach `logout`, and a single `Promise.resolve()` tick would let this
      // assertion pass without that path having had a chance to run.
      await new Promise(resolve => setTimeout(resolve, 0));
    });

    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
    stored.resolve();
    await act(async () => storing);
  });

  it('keeps a stored local session when a pre-store poll settles after the store', async () => {
    const localToken = `eyJhbGciOiJub25lIn0.${window.btoa(JSON.stringify({ sub: 'local' }))}.local`;
    const prestorePoll = deferred<Snapshot>();
    // Bootstrap answers with the cloud identity, the poll started *before* the
    // store is held open, and every poll after the store sees the local session.
    fetchSnapshot
      .mockResolvedValueOnce(makeSnapshot({ userId: 'cloud-user', sessionToken: 'old' }))
      .mockReturnValueOnce(prestorePoll.promise as never)
      .mockResolvedValue(makeSnapshot({ userId: 'local', sessionToken: localToken }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.storeSession).mockReset();
    vi.mocked(tauriCommands.storeSession).mockResolvedValue(undefined as never);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer captureCtx={next => (ctx = next)} />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    let storing!: Promise<void>;
    await act(async () => {
      // A poll is already in flight when the local session is stored...
      void ctx!.refresh();
      storing = ctx!.storeSessionToken(localToken, { id: 'local' });
      await new Promise(resolve => setTimeout(resolve, 0));
      // ...and it settles with the stale cloud snapshot only after the store.
      prestorePoll.resolve(makeSnapshot({ userId: 'cloud-user', sessionToken: 'old' }));
      await storing;
    });

    expect(getCoreStateSnapshot().snapshot.sessionToken).toBe(localToken);

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.team_get_usage', source: 'rpc', reason: 'confirmed' },
        })
      );
      await new Promise(resolve => setTimeout(resolve, 0));
    });

    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
  });

  it('dispatching core-rpc-auth-expired triggers clearSession (and debounces repeated fires within 10s)', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    // First dispatch should clear the session. `reason: 'confirmed'` (a real
    // 401 / explicit expiry) skips the disk-token corroboration and clears
    // immediately.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.team_get_usage', source: 'rpc', reason: 'confirmed' },
        })
      );
    });

    await waitFor(() => expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1));

    // Repeated fires within the debounce window must NOT call logout again.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.threads_list', source: 'rpc' },
        })
      );
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.billing_get_current_plan', source: 'rpc' },
        })
      );
    });

    expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1);
  });

  it('does NOT clear the session on an unconfirmed auth-expired when the token is still on disk (restart boot-race guard)', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);
    // The cheap disk-only token read still finds the persisted token — this is
    // the transient "session jwt required" right after the identity-flip
    // restart (token on disk, just not loaded by the racing RPC), not a real
    // expiry. The destructive clearSession MUST be skipped.
    vi.mocked(tauriCommands.getSessionToken).mockReset();
    vi.mocked(tauriCommands.getSessionToken).mockResolvedValue('tok1');

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.auth_get_me', source: 'rpc', reason: 'unconfirmed' },
        })
      );
    });
    // Flush the corroboration microtasks.
    await act(async () => {});

    expect(vi.mocked(tauriCommands.getSessionToken)).toHaveBeenCalled();
    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
  });

  it('clears the session on an unconfirmed auth-expired only after corroborating the token is gone', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);
    // Disk read confirms the token is genuinely gone → a real sign-out, so the
    // destructive clearSession is allowed to proceed.
    vi.mocked(tauriCommands.getSessionToken).mockReset();
    vi.mocked(tauriCommands.getSessionToken).mockResolvedValue(null);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.auth_get_me', source: 'rpc', reason: 'unconfirmed' },
        })
      );
    });

    await waitFor(() => expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1), {
      timeout: 3000,
    });
  });

  it('lets a confirmed expiry break through a debounce slot claimed by an unconfirmed probe', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);
    // Unconfirmed probe still finds the token → bails (keeps session) but would
    // otherwise hold the 10s debounce slot.
    vi.mocked(tauriCommands.getSessionToken).mockReset();
    vi.mocked(tauriCommands.getSessionToken).mockResolvedValue('tok1');

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    // 1) Transient unconfirmed signal — must NOT clear, but claims the slot.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.auth_get_me', source: 'rpc', reason: 'unconfirmed' },
        })
      );
    });
    await act(async () => {});
    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();

    // 2) A real 401 within the debounce window MUST still sign out.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.team_get_usage', source: 'rpc', reason: 'confirmed' },
        })
      );
    });

    await waitFor(() => expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1));
  });

  it('core-state:suppress-reauth suppresses auth-expired clearSession during deep-link delivery (#2377)', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    // Arm the suppress window so core-rpc-auth-expired is silenced.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:suppress-reauth', { detail: { until: Date.now() + 30_000 } })
      );
    });

    // auth-expired during the suppress window must not call logout.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.auth_store_session', source: 'rpc' },
        })
      );
    });

    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
  });

  it('core-state:suppress-reauth with until=0 re-enables auth-expired handling after deep-link delivery (#2377)', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    // Arm then immediately disarm so clearSession is allowed again.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:suppress-reauth', { detail: { until: Date.now() + 30_000 } })
      );
    });
    await act(async () => {
      window.dispatchEvent(new CustomEvent('core-state:suppress-reauth', { detail: { until: 0 } }));
    });

    // auth-expired after suppress cleared must call logout.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-rpc-auth-expired', {
          detail: { method: 'openhuman.team_get_usage', source: 'rpc', reason: 'confirmed' },
        })
      );
    });

    await waitFor(() => expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1));
  });

  it('ignores forged session-token-updated events that do not match the core snapshot (#1937)', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('token').textContent).toBe('tok1'));

    // Keep the follow-up refresh pending so this assertion observes the
    // event handler itself. A forged event must not be able to replace the
    // in-memory auth token before refreshCore re-pulls authoritative state.
    fetchSnapshot.mockImplementation(() => new Promise(() => {}) as never);

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:session-token-updated', {
          detail: { sessionToken: 'attacker-controlled-token' },
        })
      );
    });

    expect(screen.getByTestId('token').textContent).toBe('tok1');
  });

  it('setEncryptionKey (updateLocalState) swallows refresh errors after the local-state write lands (#REACT-Z #REACT-Y)', async () => {
    // Regression for OPENHUMAN-REACT-Z/Y: a missing `.catch()` on the
    // follow-up `refresh()` inside `updateLocalState` let an
    // `app_state_snapshot` timeout bubble out as an unhandled rejection.
    fetchSnapshot.mockResolvedValueOnce(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(coreStateApi.updateCoreLocalState).mockReset();
    vi.mocked(coreStateApi.updateCoreLocalState).mockResolvedValue(undefined as never);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));
    fetchSnapshot.mockRejectedValueOnce(
      new Error('Core RPC openhuman.app_state_snapshot timed out after 30000ms')
    );

    await act(async () => {
      // setEncryptionKey is a thin sync wrapper around updateLocalState
      // (provider line 694) — exercising it covers the new .catch() arm
      // on line 579-580.
      await expect(ctx!.setEncryptionKey('new-key')).resolves.toBeUndefined();
    });

    expect(vi.mocked(coreStateApi.updateCoreLocalState)).toHaveBeenCalledWith({
      encryptionKey: 'new-key',
    });
  });

  it('storeSessionToken swallows refresh errors after the session write lands (#REACT-Z #REACT-Y)', async () => {
    // Regression for OPENHUMAN-REACT-Z/Y: a missing `.catch()` on the
    // post-login `refresh()` inside `storeSessionToken` let an
    // `app_state_snapshot` timeout bubble out as an unhandled rejection
    // immediately after sign-in.
    fetchSnapshot.mockResolvedValueOnce(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    listTeams.mockResolvedValue([]);
    vi.mocked(tauriCommands.storeSession).mockReset();
    vi.mocked(tauriCommands.storeSession).mockResolvedValue(undefined as never);

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));
    fetchSnapshot.mockRejectedValueOnce(
      new Error('Core RPC openhuman.app_state_snapshot timed out after 30000ms')
    );

    await act(async () => {
      const token = makeJwt({ sub: 'u1', exp: Math.floor(Date.now() / 1000) + 3600 });
      await expect(ctx!.storeSessionToken(token, {})).resolves.toBeUndefined();
    });

    expect(vi.mocked(tauriCommands.storeSession)).toHaveBeenCalled();
  });
});

describe('coreStatePollFailureWarningMessage', () => {
  it('warns once during bootstrap and once when warnings are suppressed', () => {
    expect(coreStatePollFailureWarningMessage(0)).toBeNull();
    expect(coreStatePollFailureWarningMessage(1)).toBe(
      '[core-state] bootstrap poll failed (attempt 1/5):'
    );
    expect(coreStatePollFailureWarningMessage(2)).toBeNull();
    expect(coreStatePollFailureWarningMessage(5)).toBeNull();
    expect(coreStatePollFailureWarningMessage(6)).toBe(
      '[core-state] bootstrap budget exhausted; continuing with backoff. Suppressing further warnings until recovery:'
    );
    expect(coreStatePollFailureWarningMessage(7)).toBeNull();
  });

  it('never produces an attempt count exceeding the max in the warning', () => {
    for (let i = 1; i <= 50; i++) {
      const msg = coreStatePollFailureWarningMessage(i);
      if (msg && msg.includes('attempt')) {
        const match = msg.match(/attempt (\d+)\/(\d+)/);
        expect(match).not.toBeNull();
        const [, attempt, max] = match!;
        expect(Number(attempt)).toBeLessThanOrEqual(Number(max));
      }
    }
  });
});

describe('CoreStateProvider — config recovery notice (#5167)', () => {
  const fetchSnapshot = vi.mocked(coreStateApi.fetchCoreAppSnapshot);
  const listTeams = vi.mocked(coreStateApi.listTeams);
  const getTeamMembers = vi.mocked(coreStateApi.getTeamMembers);
  const getTeamInvites = vi.mocked(coreStateApi.getTeamInvites);

  beforeEach(() => {
    fetchSnapshot.mockReset();
    listTeams.mockReset();
    getTeamMembers.mockReset();
    getTeamInvites.mockReset();
    listTeams.mockResolvedValue([]);
    getTeamMembers.mockResolvedValue([]);
    getTeamInvites.mockResolvedValue([]);
    resetCoreStateStore();
    setActiveUserId(null);
    // Clear the module-level one-shot guard and any prior notices so each test
    // observes a clean slate.
    resetConfigRecoveryNotice();
    store.dispatch({ type: 'notifications/clearAll' });
  });

  function recoveryItems() {
    return store.getState().notifications.items.filter(i => i.id === 'config-recovered');
  }

  it('forwards configRecovered → exactly one system recovery notice', async () => {
    fetchSnapshot.mockResolvedValue({
      ...makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }),
      configRecovered: true,
    });

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(recoveryItems()).toHaveLength(1));
    const item = recoveryItems()[0];
    expect(item.category).toBe('system');
    expect(item.deepLink).toBe('/settings');
    expect(item.read).toBe(false);
  });

  it('stays one-shot across repeated refreshes (single dispatch)', async () => {
    fetchSnapshot.mockResolvedValue({
      ...makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }),
      configRecovered: true,
    });
    const dispatchSpy = vi.spyOn(store, 'dispatch');

    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer
          captureCtx={next => {
            ctx = next;
          }}
        />
      </CoreStateProvider>
    );

    await waitFor(() => expect(recoveryItems()).toHaveLength(1));
    await act(async () => {
      await ctx!.refresh();
      await ctx!.refresh();
    });

    const recoveryDispatches = dispatchSpy.mock.calls.filter(
      ([action]) => notificationReceived.match(action) && action.payload.id === 'config-recovered'
    );
    expect(recoveryDispatches).toHaveLength(1);
    dispatchSpy.mockRestore();
  });

  it('does not dispatch when the snapshot omits configRecovered', async () => {
    fetchSnapshot.mockResolvedValue(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    await waitFor(() => expect(screen.getByTestId('user').textContent).toBe('u1'));
    expect(recoveryItems()).toHaveLength(0);
  });
});

describe('session expiry fixes (#5868)', () => {
  it('clearSession calls refresh even when tauriLogout throws', async () => {
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockResolvedValue(
      makeSnapshot({ userId: 'u1', sessionToken: 'tok1' })
    );
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockRejectedValue(new Error('already cleared'));

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockClear();

    // Trigger a confirmed session-expiry via the socket path.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('openhuman:session-expired', { detail: { source: 'test' } })
      );
    });

    // Even though logout threw, refresh must still have fired (one new snapshot
    // fetch) and the snapshot should now show signed-out state.
    await waitFor(() =>
      expect(vi.mocked(coreStateApi.fetchCoreAppSnapshot)).toHaveBeenCalledTimes(1)
    );
    await waitFor(() => expect(screen.getByTestId('token').textContent).toBe('none'));
  });

  it('refreshes the snapshot when an expiry lands during deep-link suppression', async () => {
    resetCoreStateStore();
    setActiveUserId(null);
    vi.mocked(coreStateApi.fetchCoreAppSnapshot)
      .mockReset()
      .mockResolvedValueOnce(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }))
      .mockResolvedValueOnce(
        makeSnapshot({ userId: null, sessionToken: null, isAuthenticated: false })
      );
    vi.mocked(coreStateApi.listTeams).mockReset().mockResolvedValue([]);
    vi.mocked(coreStateApi.getTeamMembers).mockReset().mockResolvedValue([]);
    vi.mocked(coreStateApi.getTeamInvites).mockReset().mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('token').textContent).toBe('tok1'));
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockClear();

    // The native session owner can clear a rejected credential while a
    // deep-link delivery is still suppressing destructive re-auth handling.
    // The expiry event must still reconcile React's cached snapshot with the
    // core's now-signed-out state.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:suppress-reauth', { detail: { until: Date.now() + 30_000 } })
      );
      window.dispatchEvent(
        new CustomEvent('openhuman:session-expired', {
          detail: { source: 'shell.auth/me', reason: 'confirmed' },
        })
      );
    });

    expect(vi.mocked(coreStateApi.fetchCoreAppSnapshot)).toHaveBeenCalledTimes(1);
    await waitFor(() => expect(screen.getByTestId('token').textContent).toBe('none'));
    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
  });

  it('keeps the current session when a stale expiry lands during deep-link suppression', async () => {
    resetCoreStateStore();
    setActiveUserId(null);
    vi.mocked(coreStateApi.fetchCoreAppSnapshot)
      .mockReset()
      .mockResolvedValueOnce(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }))
      .mockResolvedValueOnce(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    vi.mocked(coreStateApi.listTeams).mockReset().mockResolvedValue([]);
    vi.mocked(coreStateApi.getTeamMembers).mockReset().mockResolvedValue([]);
    vi.mocked(coreStateApi.getTeamInvites).mockReset().mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('token').textContent).toBe('tok1'));
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockClear();

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:suppress-reauth', { detail: { until: Date.now() + 30_000 } })
      );
      window.dispatchEvent(
        new CustomEvent('openhuman:session-expired', {
          detail: { source: 'shell.auth/me', reason: 'confirmed' },
        })
      );
    });

    expect(vi.mocked(coreStateApi.fetchCoreAppSnapshot)).toHaveBeenCalledTimes(1);
    await act(async () => {});
    expect(screen.getByTestId('token').textContent).toBe('tok1');
    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
  });

  it('confirmed session-expiry during bootstrap is replayed after the first snapshot lands (#5868)', async () => {
    // The module-level store may carry isBootstrapping:false from prior tests;
    // reset it so the component mounts with the correct initial value.
    setCoreStateSnapshot({ ...getCoreStateSnapshot(), isBootstrapping: true, isReady: false });

    // Hold the first snapshot until we control the release.
    let resolveSnapshot!: (
      v: Awaited<ReturnType<typeof coreStateApi.fetchCoreAppSnapshot>>
    ) => void;
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockImplementation(
      () =>
        new Promise(res => {
          resolveSnapshot = res;
        })
    );
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);
    // getSessionToken: return null so confirmSessionTokenGone fast-paths to true
    // (only reached for unconfirmed events — confirmed skips the check entirely).
    vi.mocked(tauriCommands.getSessionToken).mockResolvedValue(null);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );

    // Fire a confirmed session-expiry WHILE bootstrap is still pending.
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('openhuman:session-expired', { detail: { source: 'test-bootstrap' } })
      );
    });

    // logout must NOT have been called yet — bootstrap not done.
    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();

    // Now let the snapshot land, completing bootstrap.
    await act(async () => {
      resolveSnapshot(makeSnapshot({ userId: 'u1', sessionToken: 'tok1' }));
    });

    // The pending reauth must replay and call logout.
    await waitFor(() => expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1));
  });

  it('does not sign out on a chat-error expiry while the session token is still on disk (#2758)', async () => {
    // The failure mode this pins is a REGRESSION OF #2758, reached through a
    // new door. `is_session_expired_message` (core/observability.rs) classifies
    // the local guards "no backend session token" and "session jwt required"
    // under the same `session_expired` error type as a real backend expiry, and
    // those fire transiently before the on-disk auth profile has been read.
    //
    // `clearSession()` is destructive — `auth_clear_session` deletes the auth
    // profile — so a merely-suggestive signal must be corroborated first. That
    // is what `reason: 'unconfirmed'` buys: `runReauth` calls
    // `confirmSessionTokenGone()` and stops when the token is still there.
    //
    // Revert the dispatch to `confirmed` (or drop the `reason` from the
    // ChatRuntimeProvider dispatch) and this test fails: corroboration is
    // skipped and the user is signed out with a perfectly good token on disk.
    setCoreStateSnapshot({ ...getCoreStateSnapshot(), isBootstrapping: false, isReady: true });

    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockResolvedValue(
      makeSnapshot({ userId: 'u1', sessionToken: 'tok1' })
    );
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);
    // The whole point: the token is STILL PRESENT. Corroboration must find it
    // and abandon the sign-out.
    vi.mocked(tauriCommands.getSessionToken).mockResolvedValue('tok1');

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('openhuman:session-expired', {
          detail: { source: 'chat-error', reason: 'unconfirmed' },
        })
      );
    });

    // Let the async corroboration settle before asserting the negative, so this
    // cannot pass merely by checking too early.
    await waitFor(() => expect(vi.mocked(tauriCommands.getSessionToken)).toHaveBeenCalled());
    expect(vi.mocked(tauriCommands.logout)).not.toHaveBeenCalled();
  });

  it('still signs out on a chat-error expiry once the token is genuinely gone', async () => {
    // The positive control for the test above: `unconfirmed` must not become a
    // way to never sign out. Same dispatch, same path — only the corroboration
    // result differs — so a fix that simply ignored chat-error expiries would
    // pass the previous test and fail this one.
    setCoreStateSnapshot({ ...getCoreStateSnapshot(), isBootstrapping: false, isReady: true });

    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockResolvedValue(
      makeSnapshot({ userId: 'u1', sessionToken: 'tok1' })
    );
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockResolvedValue(undefined as never);
    vi.mocked(tauriCommands.getSessionToken).mockResolvedValue(null);

    render(
      <CoreStateProvider>
        <Consumer />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('ready').textContent).toBe('ready'));

    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('openhuman:session-expired', {
          detail: { source: 'chat-error', reason: 'unconfirmed' },
        })
      );
    });

    await waitFor(() => expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1));
  });
});

describe('failed logout keeps the user signed out', () => {
  const tok1 = makeJwt({ sub: 'u1', exp: Math.floor(Date.now() / 1000) + 3600 });

  async function renderSignedIn() {
    resetCoreStateStore();
    setActiveUserId(null);
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockReset();
    // The core keeps reporting tok1 because the logout never removed it.
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockResolvedValue(
      makeSnapshot({ userId: 'u1', sessionToken: tok1 })
    );
    vi.mocked(coreStateApi.listTeams).mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockRejectedValue(new Error('auth_logout timed out'));
    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer captureCtx={c => (ctx = c)} />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('token').textContent).toBe(tok1));
    await act(async () => {
      await expect(ctx!.clearSession()).rejects.toThrow('auth_logout timed out');
    });
    expect(screen.getByTestId('token').textContent).toBe('none');
    return () => ctx!;
  }

  it('reports the failure and never shows the logged-out token again', async () => {
    const ctx = await renderSignedIn();

    // Polls long after any time window: the logged-out token stays hidden.
    const realNow = Date.now;
    const spy = vi.spyOn(Date, 'now').mockImplementation(() => realNow() + 60_000);
    try {
      await act(async () => {
        await ctx().refresh();
      });
    } finally {
      spy.mockRestore();
    }
    expect(screen.getByTestId('token').textContent).toBe('none');
    // No automatic retry: an unkeyed logout could clear a newer session.
    expect(vi.mocked(tauriCommands.logout)).toHaveBeenCalledTimes(1);
  });

  it('keeps guarding the token when the clear is repeated', async () => {
    const ctx = await renderSignedIn();
    await act(async () => {
      await ctx()
        .clearSession()
        .catch(() => undefined);
    });
    await act(async () => {
      await ctx().refresh();
    });
    expect(screen.getByTestId('token').textContent).toBe('none');
  });

  it('a deep-link event carrying the logged-out token does not lift the guard', async () => {
    const ctx = await renderSignedIn();
    await act(async () => {
      window.dispatchEvent(
        new CustomEvent('core-state:session-token-updated', { detail: { sessionToken: tok1 } })
      );
    });
    await act(async () => {
      await ctx().refresh();
    });
    expect(screen.getByTestId('token').textContent).toBe('none');
  });

  it('a stale no-token poll that started before the clear does not lift the guard', async () => {
    resetCoreStateStore();
    setActiveUserId(null);
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockReset();
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockResolvedValue(
      makeSnapshot({ userId: 'u1', sessionToken: tok1 })
    );
    vi.mocked(coreStateApi.listTeams).mockResolvedValue([]);
    vi.mocked(tauriCommands.logout).mockReset();
    vi.mocked(tauriCommands.logout).mockRejectedValue(new Error('auth_logout timed out'));
    let ctx: CoreStateContextValue | undefined;
    render(
      <CoreStateProvider>
        <Consumer captureCtx={c => (ctx = c)} />
      </CoreStateProvider>
    );
    await waitFor(() => expect(screen.getByTestId('token').textContent).toBe(tok1));

    // A poll is in flight when the user logs out; it answers "no token".
    const stalePoll = deferred<Snapshot>();
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockReturnValueOnce(stalePoll.promise);
    let polling!: Promise<void>;
    act(() => {
      polling = ctx!.refresh();
    });
    let clearing!: Promise<void>;
    act(() => {
      clearing = ctx!.clearSession().catch(() => undefined);
    });
    await act(async () => {
      stalePoll.resolve(makeSnapshot({ sessionToken: null }));
      await polling;
      await clearing;
    });

    // The core still holds tok1 (the logout failed): it must stay hidden.
    await act(async () => {
      await ctx!.refresh();
    });
    expect(screen.getByTestId('token').textContent).toBe('none');
  });

  it('lets a new login with a different token through', async () => {
    const ctx = await renderSignedIn();
    vi.mocked(coreStateApi.fetchCoreAppSnapshot).mockResolvedValue(
      makeSnapshot({ userId: 'u1', sessionToken: 'tok2' })
    );
    await act(async () => {
      await ctx().refresh();
    });
    expect(screen.getByTestId('token').textContent).toBe('tok2');
  });
});

describe('coreStatePollFailureDebugMessage', () => {
  it('describes post-bootstrap poll failures without impossible retry counters', () => {
    expect(coreStatePollFailureDebugMessage(0)).toBeNull();
    expect(coreStatePollFailureDebugMessage(1)).toBe(
      'refresh failed during bootstrap retry 1/5; nextAction=retrying'
    );
    expect(coreStatePollFailureDebugMessage(5)).toBe(
      'refresh failed during bootstrap retry 5/5; nextAction=marking-ready-with-fallback'
    );

    const postBootstrapMessage = coreStatePollFailureDebugMessage(11);
    expect(postBootstrapMessage).toBe(
      'refresh failed after 11 consecutive poll failures; bootstrapRetryLimit=5; nextAction=continuing-background-polling-with-warnings-suppressed'
    );
    expect(postBootstrapMessage).not.toContain('11/5');
  });
});