feat(lobby): enhance start logic with "Start anyway" option and player count checks

app.py

@@ -1051,22 +1051,27 @@ def poll_tick(session_id, screen, team_id, player_name, is_host, poll_state):
     nav = [gr.update()] * 7
     new_screen = screen
     lobby_code = lobby_roster = play_timer = play_status = wait_status = win_score = gr.update()
-    lobby_start = lobby_hint = gr.update()
+    lobby_start = lobby_start_anyway = lobby_hint = gr.update()
+    wait_line = wait_results_btn = gr.update()
 
     if session_id:
         status = rooms.session_status(session_id)
+        # Canonical team id — never "" — so same-team members converge on one id.
+        team_id = rooms.resolve_team_id(session_id, player_name) or team_id
         if screen == "lobby":
             lobby_code = code_html(session_id)
             lobby_roster = roster_html(session_id, player_name)
-            # Keep Start enabled only once every team has a player, and keep the
-            # instruction line in sync with who's waiting on whom.
-            ready, total = _teams_ready(session_id)
-            all_ready = total > 0 and ready == total
-            lobby_start = gr.update(interactive=all_ready)
+            # Start gate (Model B): the primary Start enables only when the whole
+            # party is here (full AND min_ok). The host-only "Start anyway"
+            # override covers the short-handed-but-legal case (min_ok, not full).
+            pcs = rooms.player_count_status(session_id)
+            full, min_ok = pcs["full"], pcs["min_ok"]
+            lobby_start = gr.update(interactive=(full and min_ok))
             if is_host:
-                lobby_hint = HINT_HOST_READY if all_ready else HINT_HOST_WAIT
-            else:
-                lobby_hint = HINT_GUEST
+                lobby_start_anyway = gr.update(
+                    visible=(not full), interactive=(min_ok and not full),
+                    value=f"▶ Start anyway ({pcs['joined']}/{pcs['target']} here)")
+            lobby_hint = lobby_hint_text(session_id, is_host)
             if status == "playing":
                 new_screen = "play"
                 nav = list(vis("play"))
@@ -1076,17 +1081,22 @@ def poll_tick(session_id, screen, team_id, player_name, is_host, poll_state):
             play_timer = timer_html(session_id, team_id)
             play_status = status_strip_html(session_id, team_id)
         elif screen == "wait":
+            # The wait screen NEVER navigates on its own — for any player, under
+            # any condition. Each tick only UPDATES: the team strip, the
+            # "who's still playing" line, and the results button's enabled state.
+            # The wait->win transition happens ONLY when a player clicks the
+            # "See final results" button (see do_see_results).
             wait_status = status_strip_html(session_id, team_id)
-            if rooms.all_finished(session_id):
-                new_screen = "win"
-                nav = list(vis("win"))
-                win_score = scoreboard_md(session_id)
+            wait_line = wait_playing_md(session_id)
+            pcs = rooms.player_count_status(session_id)
+            can_results = rooms.all_finished(session_id) and pcs["min_ok"]
+            wait_results_btn = gr.update(interactive=can_results)
 
     # ── Decide next poll interval from whether anything changed ──
     def _s(x):
         return x if isinstance(x, str) else ""
     sig = "|".join([new_screen, _s(lobby_code), _s(lobby_roster), _s(play_timer),
-                    _s(play_status), _s(wait_status), _s(win_score)])
+                    _s(play_status), _s(wait_status), _s(wait_line), _s(win_score)])
     last_sig, idle, cur_iv = poll_state or ("", 0, POLL_FAST)
     if sig != last_sig:
         idle, target_iv = 0, POLL_FAST
@@ -1098,8 +1108,9 @@ def poll_tick(session_id, screen, team_id, player_name, is_host, poll_state):
     timer_update = gr.Timer(target_iv) if target_iv != cur_iv else gr.update()
     new_state = (sig, idle, target_iv)
 
-    return (*nav, new_screen, lobby_code, lobby_roster, lobby_start, lobby_hint,
-            play_timer, play_status, wait_status, win_score, timer_update, new_state)
+    return (*nav, new_screen, lobby_code, lobby_roster, lobby_start, lobby_start_anyway,
+            lobby_hint, play_timer, play_status, wait_status, wait_line,
+            wait_results_btn, win_score, timer_update, new_state)
 
 
 def play_tick(session_id, screen, team_id, taskids, cur_task):
@@ -1122,12 +1133,39 @@ def play_tick(session_id, screen, team_id, taskids, cur_task):
 
 
 # ── Screen-action handlers ────────────────────────────────────────────────
-# Lobby instruction copy — differs for the host vs. everyone else.
-HINT_HOST_WAIT = "⏳ Waiting for every team to have at least one player…"
+# Lobby instruction copy — differs for the host vs. everyone else. The host
+# copy shows progress (joined/target); HINT_HOST_WAIT/HINT_HOST_SHORT are
+# format strings filled by lobby_hint_text().
+HINT_HOST_WAIT = "⏳ Waiting for players… {joined}/{target} joined"
+HINT_HOST_SHORT = "▶ {joined}/{target} here — start now, or wait for the rest."
 HINT_HOST_READY = "✅ Everyone's in — start the adventure whenever you're ready."
 HINT_GUEST = "⏳ Waiting for the host to start the adventure…"
 
 
+def lobby_hint_text(session_id: str, is_host: bool) -> str:
+    """Lobby instruction line. Guests always wait on the host; the host sees
+    progress and which gate (full vs. structural minimum) they're at."""
+    if not is_host:
+        return HINT_GUEST
+    pcs = rooms.player_count_status(session_id)
+    if pcs["full"] and pcs["min_ok"]:
+        return HINT_HOST_READY
+    if pcs["min_ok"]:
+        return HINT_HOST_SHORT.format(joined=pcs["joined"], target=pcs["target"])
+    return HINT_HOST_WAIT.format(joined=pcs["joined"], target=pcs["target"])
+
+
+def wait_playing_md(session_id: str) -> str:
+    """Live 'who's still playing' line for the wait screen — active teams
+    (>=1 player) that haven't finished yet."""
+    active = rooms.active_team_ids(session_id)
+    still = [tid for tid in active if not rooms.team_finished(session_id, tid)]
+    if not still:
+        return "Everyone's finished — see results whenever you're ready."
+    names = ", ".join(rooms.team_meta(session_id, tid)["name"] for tid in still)
+    return f"Waiting on: {names}"
+
+
 def _team_btn_updates(session_id, selected_id):
     """Button updates for the 4 team-pick slots: label + visibility, with the
     player's current team flagged 'selected' so it reads as chosen (green)."""
@@ -1164,10 +1202,13 @@ def do_create(name, gtype, city, area, duration, teams_n, head_start,
     rooms.create_room(name, config, session_id)
     teams = rooms.list_teams(session_id)
     tb = _team_btn_updates(session_id, teams[0]["id"])
+    # Host's s_team is their real team id (teams[0] — create_room files the host
+    # under it too), NOT "", so host proof/journal/finish state and final
+    # standings all key off the same id as every other same-team member.
     return (*vis("lobby"), "lobby", session_id, name, teams[0]["id"], True,
             code_html(session_id), roster_html(session_id, name),
             gr.update(visible=True, interactive=False),
-            copy_btn_html(session_id), HINT_HOST_WAIT, *tb)
+            copy_btn_html(session_id), lobby_hint_text(session_id, True), *tb)
 
 
 def do_join(code, name):
@@ -1227,17 +1268,20 @@ def prepare_game(session_id):
         yield "<div class='cq-loading'>Couldn't pre-generate — it'll generate when you start.</div>"
 
 
-def do_start(session_id):
+def do_start(session_id, team_id=""):
     s = SESSION_STORE.get(session_id) or {}
-    first_team = (s.get("teams") or [{"id": "team-a"}])[0]["id"]
+    # Render the starter's OWN team strip/timer, not always team A — a host who
+    # picked a later team shouldn't see Team A's strip. Never empty: fall back
+    # to the first team (mirrors rooms.resolve_team_id's fallback).
+    team_id = team_id or (s.get("teams") or [{"id": "team-a"}])[0]["id"]
     if not s.get("game"):
         # Fallback: lobby pre-generation didn't finish — show a loader.
         yield (*vis("lobby"), "lobby", gr.update(), gr.update(),
                "<div class='cq-loading'>Summoning your quest…</div>")
         generate_for_session(session_id)
     rooms.begin_play(session_id, SESSION_STORE[session_id].get("game"))
-    yield (*vis("play"), "play", timer_html(session_id, first_team),
-           status_strip_html(session_id, first_team), "")
+    yield (*vis("play"), "play", timer_html(session_id, team_id),
+           status_strip_html(session_id, team_id), "")
 
 
 def do_leave():
@@ -1253,6 +1297,10 @@ def _open_task(session_id, team_id, tid):
     """Render the full task-detail view for one task. Shared by the play-screen
     entry, the horizontal task tabs, and the prev/next arrows so every entry
     point produces an identical, consistent detail screen."""
+    # NOTE: tasks are session-global (session["game"]["tasks"]) and are the SAME
+    # for everyone — never slice/filter them per player. team_id here only keys
+    # the per-team completion/proof/hint OVERLAY, so same-team members (sharing
+    # one resolved team_id) see one shared task/proof view. Do not regress this.
     can = rooms.can_complete(session_id, team_id, tid)
     return (
         tid,
@@ -1412,6 +1460,12 @@ def do_finish(session_id, team_id):
     return (*vis("wait"), "wait", status_strip_html(session_id, team_id))
 
 
+def do_see_results(session_id):
+    """Manual wait->win advance — the ONLY path to the win screen. Fired by the
+    'See final results' button (gated/enabled by poll_tick), never automatic."""
+    return (*vis("win"), "win", scoreboard_md(session_id))
+
+
 def _gather_moments(session_id, team_id):
     bits = [j.get("transcript", "") for j in rooms.team_journals(session_id, team_id)]
     bits += [p.get("caption", "") for p in rooms.team_photos(session_id, team_id)]
@@ -1719,6 +1773,12 @@ with gr.Blocks(title="CityQuest · AI") as demo:
             lobby_hint = gr.Markdown(HINT_GUEST, elem_classes=["lobby-hint"])
             with gr.Row():
                 lobby_leave = gr.Button("Leave", variant="secondary", elem_id="lobby-leave")
+                # Host-only short-handed override. Hidden until poll_tick reveals
+                # it (min_ok and not full); the normal Start covers the full case.
+                lobby_start_anyway = gr.Button("▶ Start anyway", variant="secondary",
+                                               visible=False, interactive=False,
+                                               elem_id="lobby-start-anyway",
+                                               elem_classes=["lobby-start-btn"])
                 lobby_start = gr.Button("Start the adventure →", variant="primary",
                                         visible=False, interactive=False,
                                         elem_id="lobby-start", elem_classes=["lobby-start-btn"])
@@ -1822,6 +1882,14 @@ with gr.Blocks(title="CityQuest · AI") as demo:
             gr.Markdown("## 🌿 You're done — nicely paced!")
             gr.Markdown("*Waiting for the other teams to wrap up. Meanwhile, make something silly:*")
             wait_status = gr.HTML("")
+            # Live "who's still playing" line + manual advance to results. The
+            # button stays DISABLED until the results gate passes (all active
+            # teams finished AND min_ok); poll_tick flips its enabled state. The
+            # wait screen NEVER auto-navigates — this click is the only path.
+            wait_status_line = gr.Markdown("", elem_classes=["lobby-hint"])
+            wait_see_results = gr.Button("🏆 See final results", variant="primary",
+                                         interactive=False, elem_id="wait-see-results",
+                                         elem_classes=["lobby-start-btn"])
             with gr.Row():
                 wait_funny_recap = gr.Button("😄 Funny recap", variant="secondary", elem_id="wait-funny-recap")
                 wait_funny_post = gr.Button("🎨 Funny poster", variant="secondary", elem_id="wait-funny-post")
@@ -1850,8 +1918,10 @@ with gr.Blocks(title="CityQuest · AI") as demo:
     poll = gr.Timer(1.5)
     nav_groups = [g_home, g_create, g_join, g_lobby, g_play, g_wait, g_win]
     poll.tick(poll_tick, inputs=[s_session, s_screen, s_team, s_player, s_host, s_poll_state],
-              outputs=nav_groups + [s_screen, lobby_code, lobby_roster, lobby_start, lobby_hint,
-                                    play_timer, play_status, wait_status, win_scoreboard,
+              outputs=nav_groups + [s_screen, lobby_code, lobby_roster, lobby_start,
+                                    lobby_start_anyway, lobby_hint,
+                                    play_timer, play_status, wait_status, wait_status_line,
+                                    wait_see_results, win_scoreboard,
                                     poll, s_poll_state])
 
     # ── Navigation ────────────────────────────────────────────────────────
@@ -1901,10 +1971,16 @@ with gr.Blocks(title="CityQuest · AI") as demo:
                  outputs=[s_team, lobby_roster] + team_btn)
 
     lobby_leave.click(do_leave, outputs=nav_groups + [s_screen, s_session, s_player, s_team, s_host])
+    # Both Start and Start-anyway funnel through the SAME do_start path — no
+    # duplicated start logic; only the gating (in poll_tick) differs.
     lobby_start.click(_btn_off, None, [lobby_start]).then(
-        do_start, inputs=[s_session],
+        do_start, inputs=[s_session, s_team],
         outputs=nav_groups + [s_screen, play_timer, play_status, lobby_prep]
     ).then(_btn_on, None, [lobby_start])
+    lobby_start_anyway.click(_btn_off, None, [lobby_start_anyway]).then(
+        do_start, inputs=[s_session, s_team],
+        outputs=nav_groups + [s_screen, play_timer, play_status, lobby_prep]
+    ).then(_btn_on, None, [lobby_start_anyway])
 
     # ── Task tabs → detail ────────────────────────────────────────────────
     # Order must match _open_task's return tuple (19 fixed + 12 tab buttons).
@@ -1962,6 +2038,9 @@ with gr.Blocks(title="CityQuest · AI") as demo:
                      outputs=detail_open_outputs)
 
     # ── Wait-lobby actions ────────────────────────────────────────────────
+    # Manual, click-only advance to the win screen (gate/enabled by poll_tick).
+    wait_see_results.click(do_see_results, inputs=[s_session],
+                           outputs=nav_groups + [s_screen, win_scoreboard])
     wait_funny_recap.click(_btn_off, None, [wait_funny_recap]).then(
         do_funny_recap, inputs=[s_session, s_team], outputs=[wait_recap_md]
     ).then(_btn_on, None, [wait_funny_recap])

app/services/rooms.py

@@ -175,6 +175,24 @@ def team_meta(session_id: str, team_id: str) -> dict:
     return {"id": team_id, "name": team_id, "role": ""}
 
 
+def resolve_team_id(session_id: str, player_name: str) -> str:
+    """Canonical team_id for a player.
+
+    Returns the id recorded for that player in ``session["players"]``, falling
+    back to ``teams[0]["id"]`` if missing/empty. NEVER returns "" — same-team
+    members must converge on a single id, since task/proof/completion state all
+    key off team_id (an empty id would diverge from a guest's real team id).
+    """
+    session = SESSION_STORE.get(session_id) or {}
+    teams = session.get("teams", [])
+    fallback = teams[0]["id"] if teams else ""
+    name = (player_name or "").lower()
+    for p in session.get("players", []):
+        if p["name"].lower() == name:
+            return p.get("team_id") or fallback
+    return fallback
+
+
 # ── Start / staggered timing ─────────────────────────────────────────────────
 def begin_play(session_id: str, game: dict) -> None:
     """Host starts the game: store game, stamp start, compute per-team offsets."""
@@ -336,12 +354,36 @@ def active_team_ids(session_id: str) -> list[str]:
     return ids or [t["id"] for t in session.get("teams", [])][:1]
 
 
+def player_count_status(session_id: str) -> dict:
+    """Player-count gating snapshot for the lobby/start logic.
+
+    Returns ``{joined, target, full, min_ok}`` where:
+      * ``joined``  — total bodies across all teams (``len(players)``).
+      * ``target``  — the host's ``num_players`` slider (a SOFT ceiling).
+      * ``full``    — ``joined >= target`` (the whole party is here).
+      * ``min_ok``  — structural minimum, NEVER loosened: ``joined >= 2`` AND
+        every team has at least one player (no empty team = broken match).
+    """
+    session = SESSION_STORE.get(session_id) or {}
+    players = session.get("players", [])
+    teams = session.get("teams", [])
+    joined = len(players)
+    target = int(session.get("config", {}).get("num_players", 0) or 0)
+    have = {p["team_id"] for p in players}
+    every_team_has_player = bool(teams) and all(t["id"] in have for t in teams)
+    min_ok = joined >= 2 and every_team_has_player
+    full = joined >= target
+    return {"joined": joined, "target": target, "full": full, "min_ok": min_ok}
+
+
 def finish_team(session_id: str, team_id: str) -> None:
     session = SESSION_STORE.get(session_id)
     if not session:
         return
     session.setdefault("team_finished", {})[team_id] = _now_iso()
-    if all_finished(session_id):
+    # Flip to "finished" once every ACTIVE team has finished AND the structural
+    # minimum holds — never require `full` (a no-show must not strand the rest).
+    if all_finished(session_id) and player_count_status(session_id)["min_ok"]:
         session["status"] = "finished"
     save_state()