diff --git a/frontend/src/app/core/credentials.service.spec.ts b/frontend/src/app/core/credentials.service.spec.ts
index 3b3ddae..90edebb 100644
--- a/frontend/src/app/core/credentials.service.spec.ts
+++ b/frontend/src/app/core/credentials.service.spec.ts
@@ -1,4 +1,8 @@
-import { readCookie } from './credentials.service';
+import { DOCUMENT } from '@angular/common';
+import { TestBed } from '@angular/core/testing';
+
+import { PAC_WINDOW } from './browser-window.token';
+import { CredentialsService, readCookie } from './credentials.service';
 
 describe('readCookie', () => {
   it('reads and decodes an exact cookie name', () => {
@@ -10,3 +14,50 @@ describe('readCookie', () => {
     expect(readCookie('theme=dark', 'id')).toBe('');
   });
 });
+
+describe('CredentialsService', () => {
+  let service: CredentialsService;
+  let mockDocument: { cookie: string };
+  let mockWindow: { location: { protocol: string } };
+
+  beforeEach(() => {
+    mockDocument = { cookie: '' };
+    mockWindow = { location: { protocol: 'http:' } };
+
+    TestBed.configureTestingModule({
+      providers: [
+        CredentialsService,
+        { provide: DOCUMENT, useValue: mockDocument },
+        { provide: PAC_WINDOW, useValue: mockWindow },
+      ],
+    });
+    service = TestBed.inject(CredentialsService);
+  });
+
+  it.each(['http:', 'https:'] as const)('expires the id cookie over %s', (protocol) => {
+    mockWindow.location.protocol = protocol;
+    mockDocument.cookie = 'id=ABC; theme=dark';
+
+    service.clear();
+
+    const secure = protocol === 'https:' ? '; Secure' : '';
+    expect(mockDocument.cookie).toBe(`id=; Path=/; SameSite=Lax${secure}; Max-Age=0`);
+  });
+
+  it('leaves the cookie untouched when PAC_WINDOW is null', () => {
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      providers: [
+        CredentialsService,
+        { provide: DOCUMENT, useValue: mockDocument },
+        { provide: PAC_WINDOW, useValue: null },
+      ],
+    });
+    service = TestBed.inject(CredentialsService);
+    mockDocument.cookie = 'id=ABC';
+
+    service.clear();
+
+    expect(mockDocument.cookie).toBe('id=ABC');
+  });
+});
diff --git a/frontend/src/app/core/credentials.service.ts b/frontend/src/app/core/credentials.service.ts
index 1c0b881..8c40233 100644
--- a/frontend/src/app/core/credentials.service.ts
+++ b/frontend/src/app/core/credentials.service.ts
@@ -47,4 +47,13 @@ export class CredentialsService {
     const attributes = `; Path=/; SameSite=Lax${secure}`;
     this.document.cookie = `id=${encodeURIComponent(credentials.id)}${attributes}`;
   }
+
+  clear(): void {
+    if (!this.browserWindow) {
+      return;
+    }
+
+    const secure = this.browserWindow.location.protocol === 'https:' ? '; Secure' : '';
+    this.document.cookie = `id=; Path=/; SameSite=Lax${secure}; Max-Age=0`;
+  }
 }
diff --git a/frontend/src/app/core/player-name.service.spec.ts b/frontend/src/app/core/player-name.service.spec.ts
new file mode 100644
index 0000000..6c70f4e
--- /dev/null
+++ b/frontend/src/app/core/player-name.service.spec.ts
@@ -0,0 +1,79 @@
+import { TestBed } from '@angular/core/testing';
+
+import { PAC_WINDOW } from './browser-window.token';
+import { PlayerNameService } from './player-name.service';
+
+describe('PlayerNameService', () => {
+  let service: PlayerNameService;
+  let mockStorage: Record<string, string>;
+
+  beforeEach(() => {
+    mockStorage = {};
+    const mockWindow = {
+      localStorage: {
+        getItem: (key: string) => mockStorage[key] ?? null,
+        setItem: (key: string, value: string) => {
+          mockStorage[key] = value;
+        },
+      },
+    };
+
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: mockWindow }],
+    });
+    service = TestBed.inject(PlayerNameService);
+  });
+
+  it('returns an empty string when no name has been saved', () => {
+    expect(service.get()).toBe('');
+  });
+
+  it('saves and retrieves a player name', () => {
+    service.save('Odin');
+    expect(service.get()).toBe('Odin');
+  });
+
+  it('returns an empty string when localStorage throws on get', () => {
+    TestBed.resetTestingModule();
+    const throwingWindow = {
+      localStorage: {
+        getItem: () => {
+          throw new Error('unavailable');
+        },
+        setItem: () => {},
+      },
+    };
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: throwingWindow }],
+    });
+    service = TestBed.inject(PlayerNameService);
+    expect(service.get()).toBe('');
+  });
+
+  it('silently ignores localStorage errors on save', () => {
+    TestBed.resetTestingModule();
+    const throwingWindow = {
+      localStorage: {
+        getItem: () => null,
+        setItem: () => {
+          throw new Error('quota exceeded');
+        },
+      },
+    };
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: throwingWindow }],
+    });
+    service = TestBed.inject(PlayerNameService);
+    expect(() => service.save('Odin')).not.toThrow();
+  });
+
+  it('returns an empty string when PAC_WINDOW is null', () => {
+    TestBed.resetTestingModule();
+    TestBed.configureTestingModule({
+      providers: [PlayerNameService, { provide: PAC_WINDOW, useValue: null }],
+    });
+    service = TestBed.inject(PlayerNameService);
+    expect(service.get()).toBe('');
+    expect(() => service.save('Odin')).not.toThrow();
+  });
+});
diff --git a/frontend/src/app/core/player-name.service.ts b/frontend/src/app/core/player-name.service.ts
new file mode 100644
index 0000000..4bde22a
--- /dev/null
+++ b/frontend/src/app/core/player-name.service.ts
@@ -0,0 +1,26 @@
+import { inject, Service, signal } from '@angular/core';
+import { PAC_WINDOW } from './browser-window.token';
+
+const PLAYER_NAME_KEY = 'playerName';
+
+@Service()
+export class PlayerNameService {
+  private readonly browserWindow = inject(PAC_WINDOW);
+  private readonly statusMessage = signal<string | null>(null);
+
+  get(): string {
+    try {
+      return this.browserWindow?.localStorage.getItem(PLAYER_NAME_KEY) ?? '';
+    } catch {
+      return '';
+    }
+  }
+
+  save(name: string): void {
+    try {
+      this.browserWindow?.localStorage.setItem(PLAYER_NAME_KEY, name);
+    } catch {
+      this.statusMessage.set('Could not save your name for auto-re-registration.');
+    }
+  }
+}
diff --git a/frontend/src/app/core/sockets/game-socket.service.spec.ts b/frontend/src/app/core/sockets/game-socket.service.spec.ts
index e0b6040..6138836 100644
--- a/frontend/src/app/core/sockets/game-socket.service.spec.ts
+++ b/frontend/src/app/core/sockets/game-socket.service.spec.ts
@@ -297,4 +297,118 @@ describe('GameSocketService', () => {
     expect(service.state()).toBe('error');
     expect(service.status()).toContain('Register as admin again in this browser');
   });
+
+  it('expires the session after three consecutive failed player connections', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const onSessionExpired = vi.fn();
+    service.start('ABCD', () => undefined, onSessionExpired);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(true);
+    expect(service.state()).toBe('error');
+    expect(service.status()).toContain('Session has expired as game server restarted.');
+    expect(MockGameWebSocket.instances).toHaveLength(3);
+    expect(onSessionExpired).toHaveBeenCalledOnce();
+  });
+
+  it('does not invoke the session-expired callback after fewer than three failures', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const onSessionExpired = vi.fn();
+    service.start('ABCD', () => undefined, onSessionExpired);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(onSessionExpired).not.toHaveBeenCalled();
+  });
+
+  it('keeps reconnecting a player socket after fewer than three failures', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.start('ABCD', () => undefined);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(service.state()).toBe('connecting');
+    expect(MockGameWebSocket.instances).toHaveLength(3);
+  });
+
+  it('resets the failure counter when a player connection succeeds', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.start('ABCD', () => undefined);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+
+    MockGameWebSocket.instances[2].open();
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.advanceTimersByTime(4000);
+    MockGameWebSocket.instances[3].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(MockGameWebSocket.instances).toHaveLength(5);
+  });
+
+  it('never expires the session for a viewer socket', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.startViewer();
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(false);
+    expect(MockGameWebSocket.instances.length).toBeGreaterThan(3);
+  });
+
+  it('start and stop clear an expired session', () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    service.start('ABCD', () => undefined);
+
+    MockGameWebSocket.instances[0].serverClose(false);
+    vi.advanceTimersByTime(1000);
+    MockGameWebSocket.instances[1].serverClose(false);
+    vi.advanceTimersByTime(2000);
+    MockGameWebSocket.instances[2].serverClose(false);
+    vi.runAllTimers();
+
+    expect(service.sessionExpired()).toBe(true);
+
+    service.stop();
+    expect(service.sessionExpired()).toBe(false);
+
+    service.start('ABCD', () => undefined);
+    expect(service.sessionExpired()).toBe(false);
+    expect(MockGameWebSocket.instances).toHaveLength(4);
+  });
 });
diff --git a/frontend/src/app/core/sockets/game-socket.service.ts b/frontend/src/app/core/sockets/game-socket.service.ts
index 15a74f8..8f835b6 100644
--- a/frontend/src/app/core/sockets/game-socket.service.ts
+++ b/frontend/src/app/core/sockets/game-socket.service.ts
@@ -29,18 +29,25 @@ export class GameSocketService extends WebSocketService<GameSocketMessage> {
   private playerId: string | null = null;
   private mode: SocketMode | null = null;
   private onConnected: (() => void) | null = null;
+  private onSessionExpired: (() => void) | null = null;
   private reconnecting = false;
   private suspendedReason = 'Paused while the browser is offline.';
+  private consecutiveFailures = 0;
   private readonly statusMessage = signal<string | null>(null);
 
   readonly players = signal<Record<string, LivePlayer>>({});
   readonly isFlagFound = signal(false);
+  readonly sessionExpired = signal(false);
+  readonly MAX_FAILED_ATTEMPTS = 3;
 
-  start(id: string, onConnected: () => void): void {
+  start(id: string, onConnected: () => void, onSessionExpired: () => void = () => undefined): void {
     this.stop();
     this.mode = 'player';
     this.playerId = id;
     this.onConnected = onConnected;
+    this.onSessionExpired = onSessionExpired;
+    this.consecutiveFailures = 0;
+    this.sessionExpired.set(false);
     this.resume();
   }
 
@@ -72,8 +79,11 @@ export class GameSocketService extends WebSocketService<GameSocketMessage> {
     this.mode = null;
     this.playerId = null;
     this.onConnected = null;
+    this.onSessionExpired = null;
     this.reconnecting = false;
     this.statusMessage.set(null);
+    this.consecutiveFailures = 0;
+    this.sessionExpired.set(false);
     this.disconnect();
   }
 
@@ -96,6 +106,7 @@ export class GameSocketService extends WebSocketService<GameSocketMessage> {
     this.players.set({});
     this.reconnecting = false;
     this.statusMessage.set(null);
+    this.consecutiveFailures = 0;
     this.onConnected?.();
   }
 
@@ -103,6 +114,25 @@ export class GameSocketService extends WebSocketService<GameSocketMessage> {
     this.reconnecting = true;
   }
 
+  protected override shouldReconnect(closeEvent: CloseEvent): boolean {
+    if (this.mode !== 'player') {
+      return true;
+    }
+
+    this.consecutiveFailures++;
+
+    if (this.consecutiveFailures >= this.MAX_FAILED_ATTEMPTS) {
+      this.sessionExpired.set(true);
+      this.statusMessage.set(
+        'Session has expired as game server restarted.',
+      );
+      this.onSessionExpired?.();
+      return false; 
+    }
+
+    return true; 
+  }
+
   protected override onSocketError(): void {
     this.statusMessage.set(
       this.mode === 'viewer'
diff --git a/frontend/src/app/pages/game-page/game-page.component.spec.ts b/frontend/src/app/pages/game-page/game-page.component.spec.ts
index 5d040de..5b7dd2e 100644
--- a/frontend/src/app/pages/game-page/game-page.component.spec.ts
+++ b/frontend/src/app/pages/game-page/game-page.component.spec.ts
@@ -1,7 +1,7 @@
 import { signal } from '@angular/core';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { Router } from '@angular/router';
-import { of } from 'rxjs';
+import { of, throwError } from 'rxjs';
 
 import { ApiService } from '../../core/api.service';
 import { CredentialsService } from '../../core/credentials.service';
@@ -10,51 +10,94 @@ import { GeolocationService } from '../../core/geolocation.service';
 import { MapInfo, PlayerStatus, PlayerType } from '../../core/game.models';
 import { WakeLockService } from '../../core/wake-lock.service';
 import { GamePageComponent } from './game-page.component';
+import { PlayerNameService } from '../../core/player-name.service';
+
+const map: MapInfo = {
+  min: { latitude: 49.27, longitude: -122.92 },
+  max: { latitude: 49.28, longitude: -122.9 },
+  width: 32,
+  height: 32,
+  isFlagFound: false,
+};
+const api = {
+  getMap: vi.fn(() => of(map)),
+  registerPlayer: vi.fn(() => of({ id: 'NEWID' })),
+};
+const credentials = {
+  get: vi.fn(() => ({ id: 'SELF' })),
+  save: vi.fn(),
+  clear: vi.fn(),
+};
+const playerName = {
+  get: vi.fn(() => ''),
+  save: vi.fn(),
+};
+const router = { navigateByUrl: vi.fn() };
+let triggerSessionExpired: (() => void) | null = null;
+const gameSocket = {
+  players: signal({
+    SELF: {
+      coordinate: { latitude: 49.275, longitude: -122.91 },
+      player: {
+        id: 'SELF',
+        name: 'Leader',
+        type: PlayerType.Ghost,
+        status: PlayerStatus.Connected,
+      },
+    },
+  }),
+  status: signal('Connected.'),
+  isFlagFound: signal(false),
+  sessionExpired: signal(false),
+  start: vi.fn((_id: string, _onConnected: () => void, onSessionExpired: () => void) => {
+    triggerSessionExpired = onSessionExpired;
+    gameSocket.sessionExpired.set(false);
+  }),
+  stop: vi.fn(() => gameSocket.sessionExpired.set(false)),
+  resume: vi.fn(),
+  suspend: vi.fn(),
+  sendCoordinate: vi.fn(),
+  setInitialState: vi.fn(),
+};
+const geolocation = {
+  status: signal('Ready.'),
+  start: vi.fn(),
+  stop: vi.fn(),
+};
+const wakeLock = {
+  supported: signal(true),
+  enabled: signal(false),
+  status: signal('Screen wake lock is off.'),
+  initialize: vi.fn(),
+  setEnabled: vi.fn(async () => undefined),
+  handleVisibilityChange: vi.fn(async () => undefined),
+  release: vi.fn(async () => undefined),
+};
+
+async function configureTestBed(): Promise<void> {
+  await TestBed.configureTestingModule({
+    imports: [GamePageComponent],
+    providers: [
+      { provide: ApiService, useValue: api },
+      { provide: CredentialsService, useValue: credentials },
+      { provide: PlayerNameService, useValue: playerName },
+      { provide: Router, useValue: router },
+    ],
+  })
+    .overrideComponent(GamePageComponent, {
+      set: {
+        providers: [
+          { provide: GameSocketService, useValue: gameSocket },
+          { provide: GeolocationService, useValue: geolocation },
+          { provide: WakeLockService, useValue: wakeLock },
+        ],
+      },
+    })
+    .compileComponents();
+}
 
 describe('GamePageComponent leader link', () => {
   let fixture: ComponentFixture<GamePageComponent>;
-  const map: MapInfo = {
-    min: { latitude: 49.27, longitude: -122.92 },
-    max: { latitude: 49.28, longitude: -122.9 },
-    width: 32,
-    height: 32,
-    isFlagFound: false,
-  };
-  const gameSocket = {
-    players: signal({
-      SELF: {
-        coordinate: { latitude: 49.275, longitude: -122.91 },
-        player: {
-          id: 'SELF',
-          name: 'Leader',
-          type: PlayerType.Ghost,
-          status: PlayerStatus.Connected,
-        },
-      },
-    }),
-    status: signal('Connected.'),
-    isFlagFound: signal(false),
-    start: vi.fn(),
-    stop: vi.fn(),
-    resume: vi.fn(),
-    suspend: vi.fn(),
-    sendCoordinate: vi.fn(),
-    setInitialState: vi.fn(),
-  };
-  const geolocation = {
-    status: signal('Ready.'),
-    start: vi.fn(),
-    stop: vi.fn(),
-  };
-  const wakeLock = {
-    supported: signal(true),
-    enabled: signal(false),
-    status: signal('Screen wake lock is off.'),
-    initialize: vi.fn(),
-    setEnabled: vi.fn(async () => undefined),
-    handleVisibilityChange: vi.fn(async () => undefined),
-    release: vi.fn(async () => undefined),
-  };
 
   beforeEach(async () => {
     gameSocket.players.update((players) => ({
@@ -65,24 +108,7 @@ describe('GamePageComponent leader link', () => {
       },
     }));
 
-    await TestBed.configureTestingModule({
-      imports: [GamePageComponent],
-      providers: [
-        { provide: ApiService, useValue: { getMap: vi.fn(() => of(map)) } },
-        { provide: CredentialsService, useValue: { get: () => ({ id: 'SELF' }) } },
-        { provide: Router, useValue: { navigateByUrl: vi.fn() } },
-      ],
-    })
-      .overrideComponent(GamePageComponent, {
-        set: {
-          providers: [
-            { provide: GameSocketService, useValue: gameSocket },
-            { provide: GeolocationService, useValue: geolocation },
-            { provide: WakeLockService, useValue: wakeLock },
-          ],
-        },
-      })
-      .compileComponents();
+    await configureTestBed();
   });
 
   async function render(playerType: PlayerType): Promise<HTMLElement> {
@@ -110,6 +136,95 @@ describe('GamePageComponent leader link', () => {
 
   it('does not show the leader link to a non-leader', async () => {
     const page = await render(PlayerType.Ghost);
-    expect(page.querySelector('.game-page__leader-link')).toBeNull();
+    const link = page.querySelector<HTMLAnchorElement>('.game-page__leader-link a');
+    expect(link?.style.visibility).toBe('hidden');
+  });
+});
+
+describe('GamePageComponent re-registration', () => {
+  let fixture: ComponentFixture<GamePageComponent>;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    gameSocket.sessionExpired.set(false);
+    triggerSessionExpired = null;
+    await configureTestBed();
+  });
+
+  async function render(): Promise<HTMLElement> {
+    fixture = TestBed.createComponent(GamePageComponent);
+    fixture.detectChanges();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    fixture.detectChanges();
+    return fixture.nativeElement as HTMLElement;
+  }
+
+  async function flushReRegistration(): Promise<void> {
+    fixture.detectChanges();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    fixture.detectChanges();
+  }
+
+  it('clears credentials and redirects to /register when no name is saved', async () => {
+    playerName.get.mockReturnValue('');
+    await render();
+
+    triggerSessionExpired?.();
+    await flushReRegistration();
+
+    expect(credentials.clear).toHaveBeenCalled();
+    expect(gameSocket.stop).toHaveBeenCalled();
+    expect(router.navigateByUrl).toHaveBeenCalledWith('/register');
+  });
+
+  it('re-registers with the saved name and reconnects', async () => {
+    playerName.get.mockReturnValue('Odin');
+    api.registerPlayer.mockReturnValue(of({ id: 'NEWID' }));
+    const page = await render();
+
+    triggerSessionExpired?.();
+    await flushReRegistration();
+
+    expect(api.registerPlayer).toHaveBeenCalledWith('Odin');
+    expect(credentials.save).toHaveBeenCalledWith({ id: 'NEWID' });
+    expect(credentials.clear).not.toHaveBeenCalled();
+    expect(page.textContent).toContain('Re-registered. Reconnecting…');
+
+    const startCalls = gameSocket.start.mock.calls;
+    const onConnected = startCalls[startCalls.length - 1][1] as () => void;
+    expect(startCalls[startCalls.length - 1][0]).toBe('NEWID');
+    onConnected();
+    fixture.detectChanges();
+
+    expect(geolocation.start).toHaveBeenCalledWith(expect.any(Function));
+    expect(page.textContent).toContain('Connected to PacMacro.');
+  });
+
+  it('clears credentials and redirects when re-registration fails', async () => {
+    playerName.get.mockReturnValue('Odin');
+    api.registerPlayer.mockReturnValue(throwError(() => new Error('API is down')));
+    const page = await render();
+
+    triggerSessionExpired?.();
+    await flushReRegistration();
+
+    expect(credentials.clear).toHaveBeenCalled();
+    expect(gameSocket.stop).toHaveBeenCalled();
+    expect(router.navigateByUrl).toHaveBeenCalledWith('/register');
+    expect(page.textContent).toContain('Could not re-register. Redirecting…');
+  });
+
+  it('treats an empty player ID from the API as a failure', async () => {
+    playerName.get.mockReturnValue('Odin');
+    api.registerPlayer.mockReturnValue(of({ id: '   ' }));
+    const page = await render();
+
+    triggerSessionExpired?.();
+    await flushReRegistration();
+
+    expect(credentials.clear).toHaveBeenCalled();
+    expect(gameSocket.stop).toHaveBeenCalled();
+    expect(router.navigateByUrl).toHaveBeenCalledWith('/register');
+    expect(page.textContent).toContain('Could not re-register. Redirecting…');
   });
 });
diff --git a/frontend/src/app/pages/game-page/game-page.component.ts b/frontend/src/app/pages/game-page/game-page.component.ts
index b435cb3..3574ae2 100644
--- a/frontend/src/app/pages/game-page/game-page.component.ts
+++ b/frontend/src/app/pages/game-page/game-page.component.ts
@@ -19,6 +19,7 @@ import { isLeaderType, MapInfo, typeLabel } from '../../core/game.models';
 import { WakeLockService } from '../../core/wake-lock.service';
 import { GameCanvasComponent } from '../../game/game-canvas/game-canvas.component';
 import { BrandHeaderComponent } from '../../shared/brand-header/brand-header.component';
+import { PlayerNameService } from '../../core/player-name.service';
 
 @Component({
   selector: 'pac-game-page',
@@ -34,6 +35,7 @@ export class GamePageComponent {
   private readonly credentials = inject(CredentialsService);
   private readonly destroyRef = inject(DestroyRef);
   private readonly router = inject(Router);
+  private readonly playerName = inject(PlayerNameService);
 
   protected readonly socket = inject(GameSocketService);
   protected readonly geolocation = inject(GeolocationService);
@@ -41,6 +43,7 @@ export class GamePageComponent {
   protected readonly map = signal<MapInfo | null>(null);
   protected readonly selfId = signal('');
   protected readonly pageStatus = signal('Loading the game map…');
+
   protected readonly selfSummary = computed(() => {
     const player = this.socket.players()[this.selfId()]?.player;
     return player ? `${player.name} (${player.id}) is ${typeLabel(player.type)}` : '';
@@ -68,6 +71,36 @@ export class GamePageComponent {
     await this.wakeLock.setEnabled((event.target as HTMLInputElement).checked);
   }
 
+  private async autoReregister(): Promise<void> {
+    const name = this.playerName.get();
+    if (!name) {
+      this.credentials.clear();
+      this.socket.stop();
+      await this.router.navigateByUrl('/register');
+      return;
+    }
+
+    this.pageStatus.set('Re-registering…');
+
+    try {
+      const response = await firstValueFrom(this.api.registerPlayer(name));
+      const id = response.id.trim();
+      if (!id) {
+        throw new Error('The API returned an empty player ID.');
+      }
+
+      this.credentials.save({ id });
+      this.selfId.set(id);
+      this.pageStatus.set('Re-registered. Reconnecting…');
+      this.connectAs(id);
+    } catch {
+      this.credentials.clear();
+      this.socket.stop();
+      this.pageStatus.set('Could not re-register. Redirecting…');
+      await this.router.navigateByUrl('/register');
+    }
+  }
+
   private async initialize(): Promise<void> {
     if (!this.browserWindow) {
       return;
@@ -96,10 +129,18 @@ export class GamePageComponent {
     this.browserWindow.document.addEventListener('visibilitychange', this.onVisibilityChange);
     this.browserWindow.addEventListener('online', this.onOnline);
     this.browserWindow.addEventListener('offline', this.onOffline);
-    this.socket.start(credentials.id, () => {
-      this.pageStatus.set('Connected to PacMacro.');
-      this.geolocation.start((coordinate) => this.socket.sendCoordinate(coordinate));
-    });
+    this.connectAs(credentials.id);
+  }
+
+  private connectAs(id: string): void {
+    this.socket.start(
+      id,
+      () => {
+        this.pageStatus.set('Connected to PacMacro.');
+        this.geolocation.start((coordinate) => this.socket.sendCoordinate(coordinate));
+      },
+      () => void this.autoReregister(),
+    );
   }
 
   private cleanup(): void {
diff --git a/frontend/src/app/pages/register-page/register-page.component.spec.ts b/frontend/src/app/pages/register-page/register-page.component.spec.ts
index e560a89..9ff5f38 100644
--- a/frontend/src/app/pages/register-page/register-page.component.spec.ts
+++ b/frontend/src/app/pages/register-page/register-page.component.spec.ts
@@ -5,6 +5,7 @@ import { of } from 'rxjs';
 
 import { ApiService } from '../../core/api.service';
 import { CredentialsService } from '../../core/credentials.service';
+import { PlayerNameService } from '../../core/player-name.service';
 import { RegisterPageComponent } from './register-page.component';
 
 describe('RegisterPageComponent', () => {
@@ -13,6 +14,7 @@ describe('RegisterPageComponent', () => {
     registerPlayer: vi.fn(() => of({ id: 'ABCD' })),
   };
   const credentials = { save: vi.fn() };
+  const playerName = { save: vi.fn() };
   const router = { navigateByUrl: vi.fn(() => Promise.resolve(true)) };
 
   beforeEach(() => {
@@ -22,6 +24,7 @@ describe('RegisterPageComponent', () => {
       providers: [
         { provide: ApiService, useValue: api },
         { provide: CredentialsService, useValue: credentials },
+        { provide: PlayerNameService, useValue: playerName },
         { provide: Router, useValue: router },
       ],
     });
@@ -39,6 +42,7 @@ describe('RegisterPageComponent', () => {
     expect(api.registerPlayer).toHaveBeenCalledWith('Test2');
     expect(api.registerAdmin).not.toHaveBeenCalled();
     expect(credentials.save).toHaveBeenCalledWith({ id: 'ABCD' });
+    expect(playerName.save).toHaveBeenCalledWith('Test2');
     expect(router.navigateByUrl).toHaveBeenCalledWith('/');
   });
 
@@ -52,6 +56,8 @@ describe('RegisterPageComponent', () => {
     await component.submit(submitEvent());
 
     expect(api.registerPlayer).not.toHaveBeenCalled();
+    expect(credentials.save).not.toHaveBeenCalled();
+    expect(playerName.save).not.toHaveBeenCalled();
   });
 });
 
diff --git a/frontend/src/app/pages/register-page/register-page.component.ts b/frontend/src/app/pages/register-page/register-page.component.ts
index c04ca41..6b251ca 100644
--- a/frontend/src/app/pages/register-page/register-page.component.ts
+++ b/frontend/src/app/pages/register-page/register-page.component.ts
@@ -12,6 +12,7 @@ import { firstValueFrom } from 'rxjs';
 import { ApiService } from '../../core/api.service';
 import { CredentialsService } from '../../core/credentials.service';
 import { BrandHeaderComponent } from '../../shared/brand-header/brand-header.component';
+import { PlayerNameService } from '../../core/player-name.service';
 
 interface RegistrationModel {
   name: string;
@@ -28,6 +29,7 @@ export class RegisterPageComponent {
   private readonly api = inject(ApiService);
   private readonly credentials = inject(CredentialsService);
   private readonly router = inject(Router);
+  private readonly playerName = inject(PlayerNameService);
 
   protected readonly registrationModel = signal<RegistrationModel>({
     name: '',
@@ -62,6 +64,7 @@ export class RegisterPageComponent {
         throw new Error('The API returned an empty player ID.');
       }
       this.credentials.save({ id });
+      this.playerName.save(trimmedName);
       await this.router.navigateByUrl('/');
     } catch (error) {
       this.status.set('Registration failed. Check your details and the API connection.');