diff --git a/plan/setup-tree.md b/plan/setup-tree.md
index d338004..74850bb 100644
--- a/plan/setup-tree.md
+++ b/plan/setup-tree.md
@@ -85,24 +85,6 @@ after load or the node does not exist.
 
 ## Still open
 
-- [ ] **A team control in the lobby.** Every piece under it is now in place:
-      a scenario declares teams, the API defaults them per slot, the launch
-      manifest carries them and arena applies them (`--teams`, arena #96). What
-      is missing is the control itself. Stock MegaMek has one — `ChatLounge`
-      has a team selector, and scenario factions load as ghosts precisely so a
-      human can take one and change sides — and lance.blue seats players
-      directly with no way to alter it, so today the scenario's own teams are
-      final.
-
-      The scenario stays the default. A lobby that opened with everyone
-      unassigned would make every fight a setup chore; what a control adds is
-      the ability to *differ* from the file, which is what makes Monte Diablo
-      playable as something other than the two sides it shipped with.
-
-      It is one node of the tree this epic is about, so it should arrive as
-      one: `Locked` for a daily, free for an ordinary lobby, and whatever a
-      tutorial wants in between.
-
 - [ ] **Distinguish `VisiblyLocked` from `InvisiblyLocked`.** A locked setting
       has two meanings and the tree does not yet tell them apart. Some locks
       are the point and belong on screen — a daily's rules and its AI, which is
@@ -143,4 +125,25 @@ Duel-is-only-a-filter note is the same observation from the other side.
 
 ## Done
 
-Nothing closed yet.
+- [x] **A team control in the lobby.** One `<select>` per Force card: the
+      scenario's own answer, or teams 1 to 8. The seat's holder may move
+      their own seat and the lobby's owner may move any, which is also the
+      only way a bot seat moves — it has no holder to ask. Stored on the
+      seat row (`match_players.team`) rather than in memory, because it is a
+      setup decision that outlives a socket, and resolved against the file's
+      own `team_<faction>` exactly once, in `lobby_seats_to_players`, so the
+      row stays readable as "what was overridden" rather than "what will
+      run". Clearing hands the question back to the file rather than putting
+      a seat on no team.
+
+      The lobby's columns follow it live, so moving a seat regroups the
+      screen — which is the whole point for Monte Diablo, whose description
+      reads like an alliance. Changing it drops every readiness in the
+      lobby, which falls out of going through `broadcast_seats` and is the
+      right answer anyway: who is allied with whom is exactly what somebody
+      who already pressed Ready should be asked about again.
+
+      This is the first node of the tree this epic is about, built as a node
+      rather than as a flag: free in an ordinary lobby, and fixed in a daily,
+      which renders a pill instead of a control because its sides *are* the
+      challenge.
diff --git a/web/scripts/lobby-screen.test.mjs b/web/scripts/lobby-screen.test.mjs
index 2bad545..59bf827 100644
--- a/web/scripts/lobby-screen.test.mjs
+++ b/web/scripts/lobby-screen.test.mjs
@@ -288,17 +288,67 @@ test("renderSeats groups the forces into one column per team", () => {
   assert.ok(team, "teamOf moved or was renamed");
   assert.match(
     team[0],
-    /current\?\.slots\.find\(\(slot\) => slot\.name === slotName\)\?\.team/,
-    "an ordinary scenario's own team is no longer read - the catalog carries " +
-      "it now that it is the scenario files rather than a transcription",
+    /teamNow\(slotName\)/,
+    "the grouping no longer follows the team a force will actually fight " +
+      "on - a lobby that moved a seat would still be drawn in the columns " +
+      "the scenario file asked for",
   );
   assert.match(
     team[0],
-    /team === undefined \|\| team === null\s*\?\s*`slot:\$\{slotName\}`/,
+    /team === null\s*\?\s*`slot:\$\{slotName\}`/,
     "a force whose team nothing knows no longer stands as its own team",
   );
 });
 
+test("the team a force fights on is the lobby's answer, then the scenario's", () => {
+  // The same `or` the API makes once, at launch, in lobby_seats_to_players.
+  const now = source.match(
+    /function teamNow\(slotName: string\): number \| null \{[\s\S]*?\n  \}/,
+  );
+  assert.ok(now, "teamNow moved or was renamed");
+  assert.match(
+    now[0],
+    /seat\?\.team \?\? scenarioTeam\(slotName\)/,
+    "the override no longer wins over the scenario's own team",
+  );
+
+  const fromFile = source.match(
+    /function scenarioTeam\(slotName: string\): number \| null \{[\s\S]*?\n  \}/,
+  );
+  assert.ok(fromFile, "scenarioTeam moved or was renamed");
+  assert.match(
+    fromFile[0],
+    /daily\?\.sides\.find\(\(side\) => side\.name === slotName\)\?\.team/,
+    "a daily's own index no longer supplies the team its file sets",
+  );
+});
+
+test("the team control sends the change and never guesses who may make it", () => {
+  const control = source.match(
+    /function teamControl\(slotName: string\): HTMLElement \{[\s\S]*?\n  \}/,
+  );
+  assert.ok(control, "teamControl moved or was renamed");
+  assert.match(
+    control[0],
+    /socket\?\.setTeam\(\s*slotName,\s*select\.value === "" \? null : Number\(select\.value\),?\s*\)/,
+    "the control no longer sends the change - or no longer sends null for " +
+      "the scenario's own answer, which is not the same as team 0",
+  );
+  assert.doesNotMatch(
+    control[0],
+    /disabled/,
+    "the control disables itself for somebody - only the API knows whether " +
+      "this caller holds the seat or owns the lobby, the same posture Kick " +
+      "and Deploy already take",
+  );
+  assert.match(
+    control[0],
+    /if \(daily\) \{/,
+    "a daily gets the control - its sides are the challenge, and changing " +
+      "them would make it a different fight to the same score",
+  );
+});
+
 test("a Force card offers both seat resolvers when open, and neither when claimed", () => {
   const fn = source.match(/function forceCard\([\s\S]*?\n  \}/);
   assert.ok(fn, "forceCard moved or was renamed");
@@ -350,21 +400,16 @@ test("a Force card names the slot, and its team only when a scenario says", () =
   );
   assert.match(
     card[0],
-    /teamPill\(slot\.name\)/,
+    /teamControl\(slot\.name\)/,
     "the card no longer carries a team indicator",
   );
-  const pill = source.match(/function teamPill\([\s\S]*?\n  \}/);
-  assert.ok(pill, "teamPill moved or was renamed");
+  const control = source.match(/function teamControl\([\s\S]*?\n  \}/);
+  assert.ok(control, "teamControl moved or was renamed");
   assert.match(
-    pill[0],
-    /textContent:\s*"Team: n\/a"/,
-    "the team pill no longer reads as an honest stub when nothing knows - it " +
-      "must not guess at an alliance the catalog does not carry",
-  );
-  assert.match(
-    pill[0],
-    /daily\?\.sides\.find\(\(side\) => side\.name === slotName\)\?\.team/,
-    "the pill no longer reads the real team a daily's own index carries",
+    control[0],
+    /textContent: team === null \? "Team: n\/a" : `Team \$\{team\}`/,
+    "a daily's pill no longer reads as an honest stub when nothing knows - " +
+      "it must not guess at an alliance the catalog does not carry",
   );
 });
 
@@ -911,9 +956,15 @@ test("a daily seats every one of its factions itself, in slot order", () => {
   );
   assert.match(
     branch[0],
-    /control: "bot", did: null/,
+    /control: "bot",\s*did: null/,
     "the bot no longer takes every faction after the first",
   );
+  assert.doesNotMatch(
+    branch[0],
+    /team: [1-9]/,
+    "a daily's seats carry a team override - its sides are the challenge, " +
+      "and the scenario file is what says who is allied with whom",
+  );
 });
 
 test("a daily opens no lobby and connects no socket", () => {
diff --git a/web/scripts/pilot-hover.test.mjs b/web/scripts/pilot-hover.test.mjs
index 553f305..ad03b84 100644
--- a/web/scripts/pilot-hover.test.mjs
+++ b/web/scripts/pilot-hover.test.mjs
@@ -87,6 +87,28 @@ test("Escape closes it, and the listener does not outlive the card being open",
   );
 });
 
+test("moving the page under the card closes it rather than stranding it", () => {
+  // It is placed once, from where the trigger was standing. A scroll leaves
+  // it pointing at nothing - and a scroll inside the chat panel does not
+  // bubble, hence the capture flag.
+  assert.match(
+    source,
+    /window\.addEventListener\("scroll", close, true\)/,
+    "the card no longer closes on scroll, or no longer listens in the " +
+      "capture phase, which is the only way it hears the panel's own scroll",
+  );
+  assert.match(
+    source,
+    /window\.addEventListener\("resize", close\)/,
+    "the card no longer closes on resize",
+  );
+  assert.match(
+    source,
+    /function close\(\): void \{[\s\S]*?window\.removeEventListener\("scroll", close, true\)/,
+    "closing no longer removes the scroll listener",
+  );
+});
+
 test("the lobby closes the card when the screen goes", () => {
   const teardown = lobby.match(/onTeardown\(\(\) => \{[\s\S]*?\n  \}\);/);
   assert.ok(teardown, "the lobby screen's teardown moved or was restructured");
diff --git a/web/src/api.ts b/web/src/api.ts
index e853685..5244326 100644
--- a/web/src/api.ts
+++ b/web/src/api.ts
@@ -582,6 +582,11 @@ export interface MatchPlayer {
   control: string;
   did: string | null;
   handle: string | null;
+  /**
+   * The team a lobby put this seat on, or null when nobody overrode the
+   * scenario's own answer. Null is not "no team" — see `setTeam`.
+   */
+  team: number | null;
 }
 
 export interface MatchSummary {
@@ -780,6 +785,14 @@ export interface LobbySocket {
    * the seat.
    */
   kickSeat(slot: string): void;
+  /**
+   * Puts `slot` on `team`, or hands the question back to the scenario file
+   * (`null`). The seat's holder may move their own seat; the lobby's owner
+   * may move any, which is the only way a bot seat moves at all. Refused
+   * the same silent way as the other resolvers — the next `onSeats` is the
+   * only answer.
+   */
+  setTeam(slot: string, team: number | null): void;
   /** Says `text` to everyone connected to this lobby, as the caller's own
    * session identity. Anyone connected may call this, seated or not. */
   sendChat(text: string): void;
@@ -958,6 +971,9 @@ export function connectLobby(
     sendChat(text) {
       send({ type: "chat", text });
     },
+    setTeam(slot, team) {
+      send({ type: "setTeam", slot, team });
+    },
     setReady(ready) {
       send({ type: "setReady", ready });
     },
diff --git a/web/src/screens/lobby.ts b/web/src/screens/lobby.ts
index 36800c6..b96448e 100644
--- a/web/src/screens/lobby.ts
+++ b/web/src/screens/lobby.ts
@@ -39,6 +39,16 @@ import { waitingScreen } from "./waiting";
 
 export type { ChallengeMode } from "./scenario-pool";
 
+/**
+ * The teams a lobby may put a force on, mirroring the API's own `TEAMS`.
+ *
+ * One per seat at the widest, which is what a free-for-all is, and eight is
+ * where the seat count stops. There is no team 0: "on no team" is not a
+ * thing a scenario slot can be, and handing the question back to the file
+ * is a separate choice in the picker.
+ */
+const TEAM_NUMBERS = [1, 2, 3, 4, 5, 6, 7, 8];
+
 /**
  * Who takes what, in a daily.
  *
@@ -938,7 +948,7 @@ export function lobbyScreen(session: Session, entry: LobbyEntry): Node[] {
     card.append(
       el("div", { className: "force-card-head" }, [
         el("strong", { className: "force-card-name", textContent: slot.name }),
-        teamPill(slot.name),
+        teamControl(slot.name),
       ]),
       ...zoneLine(slot.name),
       el("div", { className: "force-card-seat" }, [
@@ -951,31 +961,80 @@ export function lobbyScreen(session: Session, entry: LobbyEntry): Node[] {
     return card;
   }
 
+  /** What the scenario itself says this force's team is, before any lobby
+   * had an opinion. A daily's index carries the real number; the catalog
+   * mostly carries none, and a scenario with no `team_` line is a
+   * free-for-all rather than a scenario missing data. */
+  function scenarioTeam(slotName: string): number | null {
+    return (
+      daily?.sides.find((side) => side.name === slotName)?.team ??
+      current?.slots.find((slot) => slot.name === slotName)?.team ??
+      null
+    );
+  }
+
+  /** The team a force will actually fight on: the lobby's answer where
+   * there is one, the scenario's otherwise. Mirrors the same `or` the API
+   * makes once, at launch, in `lobby_seats_to_players`. */
+  function teamNow(slotName: string): number | null {
+    const seat = seats.find((s) => s.slot === slotName);
+    return seat?.team ?? scenarioTeam(slotName);
+  }
+
   /**
-   * Which team a force fights on, when anything knows.
+   * The team control: which side this force fights on.
+   *
+   * A scenario's teams are a starting position, not a verdict — Monte
+   * Diablo ships as a four-way free-for-all whose description reads like an
+   * alliance, and stock MegaMek has had this control in its own lounge all
+   * along. Changing one drops every readiness in the lobby, which is the
+   * API's doing and the right call: who is allied with whom is exactly what
+   * a player who already pressed Ready should be asked about again.
    *
-   * A daily's index carries the real number, because the scenario file sets it
-   * and that is what makes three pirate lances one side. The hand-written
-   * catalog carries none at all, and a scenario's factions default to a
-   * free-for-all, so those still say so rather than guessing.
+   * Always rendered and never disabled, the same "show it, let the server
+   * decide" posture Kick and Deploy take: only the seat's holder or the
+   * lobby's owner may move a seat, and this client cannot reliably know
+   * which of those it is.
+   *
+   * A daily gets a pill instead. Its sides are the challenge, and a control
+   * that changed them would make it a different fight to the same score.
    */
-  function teamPill(slotName: string): HTMLElement {
-    const team =
-      daily?.sides.find((side) => side.name === slotName)?.team ??
-      current?.slots.find((slot) => slot.name === slotName)?.team ??
-      undefined;
-    if (team === undefined || team === null) {
+  function teamControl(slotName: string): HTMLElement {
+    const team = teamNow(slotName);
+    if (daily) {
       return el("span", {
-        className: "pill force-card-team",
-        title:
-          "The scenario catalog carries no team/alliance data yet - every slot shows as its own side until it does.",
-        textContent: "Team: n/a",
+        className: "pill force-card-team force-card-team-known",
+        textContent: team === null ? "Team: n/a" : `Team ${team}`,
       });
     }
-    return el("span", {
-      className: "pill force-card-team force-card-team-known",
-      textContent: `Team ${team}`,
+
+    const select = el("select", { className: "force-card-team-pick" });
+    select.setAttribute("aria-label", `Team for ${slotName}`);
+    const fromFile = scenarioTeam(slotName);
+    select.append(
+      el("option", {
+        value: "",
+        // Naming what it falls back to, rather than "Default": a player
+        // choosing this wants to know what they are choosing.
+        textContent:
+          fromFile === null ? "Own side" : `Scenario (team ${fromFile})`,
+        selected: seats.find((s) => s.slot === slotName)?.team == null,
+      }),
+      ...TEAM_NUMBERS.map((number) =>
+        el("option", {
+          value: String(number),
+          textContent: `Team ${number}`,
+          selected: seats.find((s) => s.slot === slotName)?.team === number,
+        }),
+      ),
+    );
+    select.addEventListener("change", () => {
+      socket?.setTeam(
+        slotName,
+        select.value === "" ? null : Number(select.value),
+      );
     });
+    return select;
   }
 
   /** MegaMek's zone names, said the way a person would say them. */
@@ -1046,13 +1105,8 @@ export function lobbyScreen(session: Session, entry: LobbyEntry): Node[] {
    * out exactly as it did before.
    */
   function teamOf(slotName: string): string {
-    const team =
-      daily?.sides.find((side) => side.name === slotName)?.team ??
-      current?.slots.find((slot) => slot.name === slotName)?.team ??
-      undefined;
-    return team === undefined || team === null
-      ? `slot:${slotName}`
-      : `team:${team}`;
+    const team = teamNow(slotName);
+    return team === null ? `slot:${slotName}` : `team:${team}`;
   }
 
   function renderSeats(): void {
@@ -1503,6 +1557,8 @@ export function lobbyScreen(session: Session, entry: LobbyEntry): Node[] {
       // factions left two of them unclaimed - which showed a daily's own
       // forces offering "Take it yourself", and left Deploy disabled forever,
       // because updateDeploy wants every slot claimed.
+      // No team override on either: a daily's sides are the challenge, and
+      // the scenario file is what says who is allied with whom.
       seats = current.slots.map((slot, index) =>
         index === 0
           ? {
@@ -1510,8 +1566,15 @@ export function lobbyScreen(session: Session, entry: LobbyEntry): Node[] {
               control: "human",
               did: session.did,
               handle: session.handle,
+              team: null,
             }
-          : { slot: slot.name, control: "bot", did: null, handle: null },
+          : {
+              slot: slot.name,
+              control: "bot",
+              did: null,
+              handle: null,
+              team: null,
+            },
       );
       renderScenarioList();
       renderSeats();
diff --git a/web/src/screens/pilot-hover.ts b/web/src/screens/pilot-hover.ts
index 50f728c..469e2e4 100644
--- a/web/src/screens/pilot-hover.ts
+++ b/web/src/screens/pilot-hover.ts
@@ -184,6 +184,8 @@ export function pilotHover(): PilotHover {
     opening += 1;
     card.hidden = true;
     document.removeEventListener("keydown", onKey);
+    window.removeEventListener("scroll", close, true);
+    window.removeEventListener("resize", close);
   }
 
   /** Escape closes it, per WAI-ARIA's tooltip pattern. Bound only while the
@@ -200,6 +202,14 @@ export function pilotHover(): PilotHover {
       const show = () => {
         open(trigger, facts());
         document.addEventListener("keydown", onKey);
+        // The card is placed against the viewport once, from where the
+        // trigger was standing. Anything that moves the trigger afterwards
+        // leaves it pointing at nothing, so scrolling or resizing closes it
+        // rather than re-placing it: a card is a glance, and a glance that
+        // follows you down the page is a distraction. Capture, because a
+        // scroll inside the chat panel does not bubble.
+        window.addEventListener("scroll", close, true);
+        window.addEventListener("resize", close);
       };
       trigger.addEventListener("mouseenter", show);
       trigger.addEventListener("mouseleave", close);
diff --git a/web/src/styles.css b/web/src/styles.css
index 1be2eb0..cdb3a76 100644
--- a/web/src/styles.css
+++ b/web/src/styles.css
@@ -3388,6 +3388,19 @@ footer .debug {
   box-shadow: 0 6px 20px light-dark(rgb(15 23 34 / 18%), rgb(0 0 0 / 45%));
 }
 
+/* The team control on a Force card, where the team pill used to sit. Sized
+   to the pill it replaced so a card's head does not jump when a scenario
+   with teams loads next to one without. */
+.force-card-team-pick {
+  max-width: 10rem;
+  padding: 0.15rem 0.3rem;
+  font-size: 0.8rem;
+  color: var(--ink);
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+}
+
 /* The card that opens when you point at another player. Positioned against
    the viewport by pilot-hover.ts, above the chat panel (20) it is usually
    opened from, and never under the pointer: it is a thing to read, and a