fix(lobby): tighten canonical host round flow for issue 287

frontend/angular/src/app/api-contract-smoke.spec.ts

@@ -140,7 +140,7 @@ describe('SPA Angular API contract smoke (host/player foundation)', () => {
 
       if (url === '/lobby/sessions/ABCD12/rounds/next') {
         expect(body).toEqual({});
-        return { session: { code: 'ABCD12', status: 'lobby', current_round: 2 } } as T;
+        return { session: { code: 'ABCD12', status: 'lie', current_round: 2 } } as T;
       }
 
       if (url === '/lobby/sessions/ABCD12/finish') {

frontend/angular/src/app/features/host/host-shell.component.spec.ts

@@ -85,10 +85,10 @@ function sessionDetailPayload(
       },
       host: {
         can_start_round: status === 'lobby',
-        can_show_question: status === 'lie',
-        can_mix_answers: status === 'lie',
-        can_calculate_scores: status === 'guess',
-        can_reveal_scoreboard: status === 'reveal',
+        can_show_question: false,
+        can_mix_answers: false,
+        can_calculate_scores: false,
+        can_reveal_scoreboard: false,
         can_start_next_round: status === 'scoreboard',
         can_finish_game: status === 'scoreboard',
       },
@@ -179,80 +179,16 @@ describe('HostShellComponent gameplay wiring', () => {
     });
   });
 
-  it('captures scoreboard error for retry path', async () => {
-    const fetchMock: FetchMock = vi.fn().mockResolvedValue(jsonResponse(500, { error: 'Scoreboard unavailable' }));
-
-    vi.stubGlobal('fetch', fetchMock);
-
-    const component = new HostShellComponent();
-    component.sessionCode = 'ABCD12';
-
-    await component.loadScoreboard();
-
-    expect(fetchMock).toHaveBeenCalledWith('/lobby/sessions/ABCD12/scoreboard', expect.objectContaining({ method: 'GET' }));
-    expect(component.scoreboardError).toContain('Scoreboard failed: Scoreboard unavailable');
-    expect(component.loading).toBe(false);
-  });
-
-  it('wires showQuestion, mixAnswers and calculateScores with expected request payloads', async () => {
+  it('runs next-round transition into canonical lie phase and clears prior final leaderboard state', async () => {
     const fetchMock: FetchMock = vi
       .fn()
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          round_question: {
-            id: 77,
-            round_number: 1,
-            prompt: 'Q?',
-            shown_at: '2026-01-01T00:00:00Z',
-            lie_deadline_at: '2026-01-01T00:00:45Z',
-          },
-          config: { lie_seconds: 45 },
-        })
-      )
-      .mockResolvedValueOnce(jsonResponse(200, sessionDetailPayload('lie', { roundQuestionId: 77 })))
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          session: { code: 'ABCD12', status: 'guess', current_round: 1 },
-          round_question: { id: 77, round_number: 1 },
-          answers: [{ text: 'A' }],
-        })
-      )
-      .mockResolvedValueOnce(jsonResponse(200, sessionDetailPayload('guess', { roundQuestionId: 77 })))
-      .mockResolvedValueOnce(
-        jsonResponse(200, {
-          session: { code: 'ABCD12', status: 'reveal', current_round: 1 },
-          round_question: { id: 77, round_number: 1 },
-          events_created: 2,
-          leaderboard: [{ id: 1, nickname: 'Luna', score: 320 }],
-        })
-      )
-      .mockResolvedValueOnce(jsonResponse(200, sessionDetailPayload('reveal', { roundQuestionId: 77 })));
+      .mockResolvedValueOnce(jsonResponse(200, { session: { code: 'ABCD12', status: 'lie', current_round: 2 } }))
+      .mockResolvedValueOnce(jsonResponse(200, sessionDetailPayload('lie', { roundQuestionId: 99 })));
 
     vi.stubGlobal('fetch', fetchMock);
 
     const component = new HostShellComponent();
     component.sessionCode = ' abcd12 ';
-    component.roundQuestionId = ' 77 ';
-
-    await component.showQuestion();
-    await component.mixAnswers();
-    await component.calculateScores();
-
-    expect(component.error).toBe('');
-    expect(component.loading).toBe(false);
-  });
-
-  it('runs next-round transition without reload and clears scoreboard payload', async () => {
-    const fetchMock: FetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(jsonResponse(200, { session: { code: 'ABCD12', status: 'lobby', current_round: 2 } }))
-      .mockResolvedValueOnce(jsonResponse(200, sessionDetailPayload('lobby', { roundQuestionId: null })));
-
-    vi.stubGlobal('fetch', fetchMock);
-
-    const component = new HostShellComponent();
-    component.sessionCode = ' abcd12 ';
-    component.scoreboardPayload = '{"leaderboard":[]}';
     component.finalLeaderboardPayload = '{"leaderboard":[{"nickname":"Old","score":1}]}' ;
     component.finalLeaderboard = [{ id: 9, nickname: 'Old', score: 1 }];
 
@@ -264,8 +200,8 @@ describe('HostShellComponent gameplay wiring', () => {
       expect.objectContaining({ method: 'POST', body: JSON.stringify({}) })
     );
     expect(fetchMock).toHaveBeenNthCalledWith(2, '/lobby/sessions/ABCD12', expect.objectContaining({ method: 'GET' }));
-    expect(component.session?.session.status).toBe('lobby');
-    expect(component.scoreboardPayload).toBe('');
+    expect(component.session?.session.status).toBe('lie');
+    expect(component.roundQuestionId).toBe('99');
     expect(component.finalLeaderboardPayload).toBe('');
     expect(component.finalLeaderboard).toEqual([]);
     expect(component.nextRoundError).toBe('');
@@ -341,25 +277,24 @@ describe('HostShellComponent gameplay wiring', () => {
 
     expect(replaceState).toHaveBeenCalledWith(null, '', '#/host/guess/ABCD12');
     expect(component.canStartRound).toBe(false);
-    expect(component.canShowQuestion).toBe(false);
-    expect(component.canMixAnswers).toBe(false);
-    expect(component.canCalculateScores).toBe(true);
-  });
-
-  it('uses phase_view_model to keep host action surface phase-specific', async () => {
-    const component = new HostShellComponent();
-
-    expect(component.canStartRound).toBe(true);
-    expect(component.canShowQuestion).toBe(false);
-
-    component.session = sessionDetailPayload('lie') as any;
-    expect(component.canStartRound).toBe(false);
-    expect(component.canShowQuestion).toBe(true);
-    expect(component.canMixAnswers).toBe(true);
-
-    component.session = sessionDetailPayload('reveal') as any;
-    expect(component.canRevealScoreboard).toBe(true);
     expect(component.canStartNextRound).toBe(false);
     expect(component.canFinishGame).toBe(false);
   });
+
+  it('uses phase_view_model to keep host action surface bound to round boundaries only', async () => {
+    const component = new HostShellComponent();
+
+    expect(component.canStartRound).toBe(true);
+    expect(component.canStartNextRound).toBe(false);
+    expect(component.canFinishGame).toBe(false);
+
+    component.session = sessionDetailPayload('lie') as any;
+    expect(component.canStartRound).toBe(false);
+    expect(component.canStartNextRound).toBe(false);
+    expect(component.canFinishGame).toBe(false);
+
+    component.session = sessionDetailPayload('scoreboard') as any;
+    expect(component.canStartNextRound).toBe(true);
+    expect(component.canFinishGame).toBe(true);
+  });
 });

frontend/angular/src/app/features/host/host-shell.component.ts

@@ -3,13 +3,13 @@ import { Component, OnDestroy, OnInit } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 
 import { createApiClient } from '../../../../../src/api/client';
-import type { FinishGameResponse, ScoreboardResponse, SessionDetailResponse } from '../../../../../src/api/types';
+import type { FinishGameResponse, SessionDetailResponse } from '../../../../../src/api/types';
 import { createVerticalSliceController } from '../../../../../src/spa/vertical-slice';
 import { clientHasNoAudioOutput, resolvePreferredLocale, subscribeToLocaleChanges, t } from '../../lobby-i18n';
 
 type SessionDetail = SessionDetailResponse;
 
-type LeaderboardEntry = ScoreboardResponse['leaderboard'][number];
+type LeaderboardEntry = FinishGameResponse['leaderboard'][number];
 type LeaderboardResponse = FinishGameResponse;
 
 @Component({
@@ -24,17 +24,12 @@ type LeaderboardResponse = FinishGameResponse;
       <label *ngIf="canStartRound">{{ copy('host.category') }} <input [(ngModel)]="categorySlug" /></label>
       <button (click)="refreshSession()" [disabled]="loading">{{ copy('common.refresh') }}</button>
       <button *ngIf="canStartRound" (click)="startRound()" [disabled]="loading">{{ copy('host.start_round') }}</button>
-      <button *ngIf="canShowQuestion" (click)="showQuestion()" [disabled]="loading || !roundQuestionId">{{ copy('host.show_question') }}</button>
-      <button *ngIf="canMixAnswers" (click)="mixAnswers()" [disabled]="loading || !roundQuestionId">{{ copy('host.mix_answers') }}</button>
-      <button *ngIf="canCalculateScores" (click)="calculateScores()" [disabled]="loading || !roundQuestionId">{{ copy('host.calculate_scores') }}</button>
-      <button *ngIf="canRevealScoreboard || scoreboardError" (click)="loadScoreboard()" [disabled]="loading">{{ copy(scoreboardError ? 'host.retry_scoreboard' : 'host.load_scoreboard') }}</button>
       <button *ngIf="canStartNextRound || nextRoundError" (click)="startNextRound()" [disabled]="loading">{{ copy(nextRoundError ? 'host.retry_next_round' : 'host.start_next_round') }}</button>
       <button *ngIf="canFinishGame || finishError" (click)="finishGame()" [disabled]="loading">{{ copy(finishError ? 'host.retry_finish' : 'host.finish_game') }}</button>
     </div>
 
     <p *ngIf="session" class="hint">{{ copy('host.audio_locale_hint') }}: {{ locale }}</p>
     <p *ngIf="error" class="error">{{ error }}</p>
-    <p *ngIf="scoreboardError" class="error">{{ scoreboardError }}</p>
     <p *ngIf="nextRoundError" class="error">{{ nextRoundError }}</p>
     <p *ngIf="finishError" class="error">{{ finishError }}</p>
 
@@ -67,7 +62,6 @@ type LeaderboardResponse = FinishGameResponse;
           </ul>
         </div>
       </div>
-      <pre *ngIf="scoreboardPayload">{{ scoreboardPayload }}</pre>
       <div *ngIf="finalLeaderboard.length">
         <h3>{{ copy('host.final_leaderboard') }}</h3>
         <p *ngIf="finalWinner"><strong>{{ copy('host.winner') }}:</strong> {{ finalWinner.nickname }} ({{ finalWinner.score }} {{ copy('common.points_short') }})</p>
@@ -88,10 +82,8 @@ export class HostShellComponent implements OnInit, OnDestroy {
   roundQuestionId = '';
   loading = false;
   error = '';
-  scoreboardError = '';
   nextRoundError = '';
   finishError = '';
-  scoreboardPayload = '';
   finalLeaderboardPayload = '';
   finalLeaderboard: LeaderboardEntry[] = [];
   finalWinner: LeaderboardEntry | null = null;
@@ -133,22 +125,6 @@ export class HostShellComponent implements OnInit, OnDestroy {
     return Boolean(this.session?.phase_view_model?.host?.can_start_round ?? !this.session);
   }
 
-  get canShowQuestion(): boolean {
-    return Boolean(this.session?.phase_view_model?.host?.can_show_question);
-  }
-
-  get canMixAnswers(): boolean {
-    return Boolean(this.session?.phase_view_model?.host?.can_mix_answers);
-  }
-
-  get canCalculateScores(): boolean {
-    return Boolean(this.session?.phase_view_model?.host?.can_calculate_scores);
-  }
-
-  get canRevealScoreboard(): boolean {
-    return Boolean(this.session?.phase_view_model?.host?.can_reveal_scoreboard);
-  }
-
   get canStartNextRound(): boolean {
     return Boolean(this.session?.phase_view_model?.host?.can_start_next_round);
   }
@@ -193,7 +169,6 @@ export class HostShellComponent implements OnInit, OnDestroy {
   async refreshSession(): Promise<void> {
     this.loading = true;
     this.error = '';
-    this.scoreboardError = '';
     this.nextRoundError = '';
     this.finishError = '';
     try {
@@ -226,54 +201,11 @@ export class HostShellComponent implements OnInit, OnDestroy {
       this.sessionCode = this.session.session.code;
       this.persistSessionCode(this.sessionCode);
       this.roundQuestionId = this.session.round_question?.id ? String(this.session.round_question.id) : '';
-      this.scoreboardPayload = '';
       this.resetFinalLeaderboard();
       this.syncRouteFromSession();
     });
   }
 
-  async showQuestion(): Promise<void> {
-    await this.runAction(async () => {
-      const code = this.normalizeCode(this.sessionCode);
-      await this.request(`/lobby/sessions/${encodeURIComponent(code)}/questions/show`, 'POST', {});
-      await this.refreshSession();
-    });
-  }
-
-  async mixAnswers(): Promise<void> {
-    await this.runAction(async () => {
-      const code = this.normalizeCode(this.sessionCode);
-      const roundQuestionId = this.roundQuestionId.trim();
-      await this.request(`/lobby/sessions/${encodeURIComponent(code)}/questions/${roundQuestionId}/answers/mix`, 'POST', {});
-      await this.refreshSession();
-    });
-  }
-
-  async calculateScores(): Promise<void> {
-    await this.runAction(async () => {
-      const code = this.normalizeCode(this.sessionCode);
-      const roundQuestionId = this.roundQuestionId.trim();
-      await this.request(`/lobby/sessions/${encodeURIComponent(code)}/questions/${roundQuestionId}/scores/calculate`, 'POST', {});
-      await this.refreshSession();
-    });
-  }
-
-  async loadScoreboard(): Promise<void> {
-    this.loading = true;
-    this.scoreboardError = '';
-    this.error = '';
-    try {
-      const code = this.normalizeCode(this.sessionCode);
-      const payload = await this.request<unknown>(`/lobby/sessions/${encodeURIComponent(code)}/scoreboard`, 'GET');
-      this.scoreboardPayload = JSON.stringify(payload, null, 2);
-      await this.refreshSession();
-    } catch (error) {
-      this.scoreboardError = `${this.copy('host.scoreboard_failed')}: ${(error as Error).message}`;
-    } finally {
-      this.loading = false;
-    }
-  }
-
   async startNextRound(): Promise<void> {
     this.loading = true;
     this.nextRoundError = '';
@@ -284,7 +216,6 @@ export class HostShellComponent implements OnInit, OnDestroy {
         throw new Error(this.copy('host.session_code_required'));
       }
       await this.request(`/lobby/sessions/${encodeURIComponent(code)}/rounds/next`, 'POST', {});
-      this.scoreboardPayload = '';
       this.resetFinalLeaderboard();
       await this.refreshSession();
     } catch (error) {

frontend/tests/angular-api-client.test.ts

@@ -634,7 +634,7 @@ describe('createAngularApiClient', () => {
       }
       if (url === '/lobby/sessions/ABCD12/rounds/next') {
         expect(body).toEqual({});
-        return { session: { code: 'ABCD12', status: 'lobby', current_round: 2 } } as T;
+        return { session: { code: 'ABCD12', status: 'lie', current_round: 2 } } as T;
       }
       if (url === '/lobby/sessions/ABCD12/finish') {
         expect(body).toEqual({});