diff --git a/README.md b/README.md
index fac9441a5..51a70ebd2 100644
--- a/README.md
+++ b/README.md
@@ -32,7 +32,7 @@ curl -fsSL https://raw.githubusercontent.com/AgentSystemLabs/agent-office/main/i
 
 ## What it is
 
-- **A floor per project.** Ride the elevator, pick one of your GitHub repos, and the office clones it (showing how far along it is) and opens a floor for it. Every worker, board and queue on that floor works in that checkout.
+- **A floor per project.** Ride the elevator, pick one of your GitHub repos, and the office clones it (showing how far along it is) and opens a floor for it. Pick the branch too, if the floor shouldn't start on the repository's default one. Every worker, board and queue on that floor works in that checkout.
 - **Workers at desks.** Walk up to an empty desk, press **E**, and pick Claude Code, Codex, OpenCode, Grok, Muse, DeepSeek Harness, Pi or Cursor, each with its model and reasoning effort. The agent's live terminal shows on its laptop, and anyone can open it and type.
 - **Talk instead of typing.** Hold **Ctrl+Space** (or the **🎤**) in a worker's terminal or a prompt box and say what you want: it's typed in for you to send. Your browser does the listening, so there's nothing to install.
 - **You can't miss who needs you.** A worker that stops to ask you something lights a red beacon over its desk, puts a banner on your screen saying who and what for, and sounds an alarm. One that has finished jumps up and down and dings. Press **N** to go straight to whoever is waiting.
diff --git a/docs/features.md b/docs/features.md
index f320d9b99..a1d297b13 100644
--- a/docs/features.md
+++ b/docs/features.md
@@ -2,7 +2,7 @@
 
 Everything in the office, room by room. Back to the [README](../README.md).
 
-- **A floor per project.** The first time the office starts in a terminal it walks you through picking your first project (see [Run locally](../README.md#run-locally)). Otherwise you start inside the elevator, and it asks for one: pick one of the repositories your `gh` login can see (or type `owner/name`) and the office clones it into the workspace folder, `~/agent-office/<owner>/<repo>` unless you pick another (**📁 Change folder** right there, for admins). While it clones, its floor on the panel says how far along it is (*Downloading 64% · 231 MiB · 1.5 MiB/s*), and you can close the panel and carry on: everyone hears when the floor opens. Whoever added it, or an admin, can stop it with the **⏹️** beside it. A clone that hears nothing from GitHub for 3 minutes is stopped as stalled, one that would have to ask something (an ssh host key, a password) fails straight away and says what to run on the office's machine, and restarting the office doesn't stop one. To add another project, or go to one, walk into the elevator on the north wall and press **E**. Or click the project name in the top-left corner for the list of floors: pick one and you're there in a blink, standing on the same spot in the office. From outside it (the balcony, the street, the garage) it takes you in, and you step out of that floor's elevator. Each floor has its own desks, workers, issues and PR boards, task queue, services and pictures, and its own wall and floor colors, so you always know where you are. You only see and hear the people on your floor. The elevator panel shows how many workers are busy or waiting on someone on each floor, and you get a heads-up when a worker on another floor starts waiting. An admin can take a project off the building with the **🗑** beside its floor in the elevator: its workers stop, and everyone on it rides the elevator to another floor. Nothing is deleted. The checkout stays on disk with its workers, queue and pictures, and adding the same repository again moves back into it (as long as the workspace folder hasn't moved since). That goes for the project the office was started in (`agent-office <dir>`) too: it stays off after a restart, and the office keeps its own data in that folder as before.
+- **A floor per project.** The first time the office starts in a terminal it walks you through picking your first project (see [Run locally](../README.md#run-locally)). Otherwise you start inside the elevator, and it asks for one: pick one of the repositories your `gh` login can see (or type `owner/name`) and the office clones it into the workspace folder, `~/agent-office/<owner>/<repo>` unless you pick another (**📁 Change folder** right there, for admins). Under the list is the **Branch** the floor starts on: *Default branch* unless you pick another of the repository's, which the office asks GitHub for as soon as you pick the repository. The whole repository comes down either way, so the floor still has every branch to work from — only its checkout starts where you picked, and its workers branch off that. A checkout that was already there (a floor taken off the building, or cloned by hand) is moved onto the branch you picked, and says so if it can't. While it clones, its floor on the panel says how far along it is (*Downloading 64% · 231 MiB · 1.5 MiB/s*), and you can close the panel and carry on: everyone hears when the floor opens. Whoever added it, or an admin, can stop it with the **⏹️** beside it. A clone that hears nothing from GitHub for 3 minutes is stopped as stalled, one that would have to ask something (an ssh host key, a password) fails straight away and says what to run on the office's machine, and restarting the office doesn't stop one. To add another project, or go to one, walk into the elevator on the north wall and press **E**. Or click the project name in the top-left corner for the list of floors: pick one and you're there in a blink, standing on the same spot in the office. From outside it (the balcony, the street, the garage) it takes you in, and you step out of that floor's elevator. Each floor has its own desks, workers, issues and PR boards, task queue, services and pictures, and its own wall and floor colors, so you always know where you are. You only see and hear the people on your floor. The elevator panel shows how many workers are busy or waiting on someone on each floor, and you get a heads-up when a worker on another floor starts waiting. An admin can take a project off the building with the **🗑** beside its floor in the elevator: its workers stop, and everyone on it rides the elevator to another floor. Nothing is deleted. The checkout stays on disk with its workers, queue and pictures, and adding the same repository again moves back into it (as long as the workspace folder hasn't moved since). That goes for the project the office was started in (`agent-office <dir>`) too: it stays off after a restart, and the office keeps its own data in that folder as before.
 - **Walk around.** Use WASD, Space to jump, and drag the mouse to orbit the camera. Everyone in the office sees everyone else move in real time.
 - **A quiet screen.** The office stays in view: the top bar holds just the floor you're on, **🤖 Workers** and the **☰** menu (or **Tab**). The menu opens every window (issues, PRs, the queue, services, the whiteboard, search, voice, screen sharing, settings) and lists what can show on screen: the workers, who's in the office, spend, Claude limits, the chat and the floor details. Turn each one on or off there, or hide a panel with its **✕**. Pin anything you use a lot to the top bar. The choices are kept in your browser. Chat lines fade after a few seconds; hover the chat or press **T** to read back. What needs you shows up on the top bar by itself: the workers waiting on someone (click to go to them, like **N**), the mute button while you're in voice, **Sharing** while you share your screen, and **⬆️ Update** when there's a new version.
 - **Coffee.** Press **E** at the coffee machine in the kitchen for a mug and a minute of quicker walking and higher jumps. A little meter under the project name shows how much buzz is left. Drink a third cup before the last one wears off and you get the jitters for a few seconds.
diff --git a/docs/how-it-works.md b/docs/how-it-works.md
index 471783328..651d16db8 100644
--- a/docs/how-it-works.md
+++ b/docs/how-it-works.md
@@ -38,7 +38,7 @@ browser ──HTTPS/WSS──▶ agent-office (Node)
 - **The gong.** Each time the office fetches the PR list, a PR that was open last time and is merged now rings the gong. A merge from the PR window rings as soon as `gh pr merge` returns, and isn't rung again when the list catches up. Anything else shows up at the next fetch: about every 90 seconds while someone is on the floor, and right after a queue task finishes. The gong is synthesized like the other sounds, so the volume and mute under **⚙️** apply to it.
 - **Golf.** A shot is three numbers, its heading, loft and power, sent to everyone on the floor. Each browser works out the flight from those the same way, a fixed 240 steps a second: gravity and a little drag, the balcony's railing and wall, the neighbours' walls and roofs, the balconies further down, then bounces and a roll that depend on what it lands on (green, fringe, fairway, rough, sand or road), and the cup. So everyone sees the same ball land in the same place without it being streamed. The hitter's browser adds a little mishit to the numbers before sending them, so no two swings are exactly alike.
 - **Jukebox.** Each floor's `jukebox.json` says only what's on and when it started, so it keeps playing through a restart. Every browser plays it for itself: a tune is decided note by note by its bar and step, so starting from the same moment is enough for everyone to hear the same thing. To agree on that moment, each page pings the office a few times on arriving and keeps the quickest answer to line its clock up with the office's. A tune is drums, bass, an FM electric piano and a melody picked from the chord tones, with record crackle and tape wobble, in 32-bar rounds. It's scheduled a second ahead on a timer rather than each frame, which lets it carry on in a background tab. It goes through a panner at the jukebox and a filter that muffles it with distance. Most streams can't be routed through Web Audio without CORS, so a stream plays in a plain `<audio>` element, turned down by hand on the same distance curve. An audio file seeks to where everyone else is.
-- **Floors.** `floors.json` in the office's `.agent-office/` lists the floors: each one's checkout and colors. Adding one runs `gh repo view` (does this login see it, and what's its exact name), then `gh repo clone` into the projects folder; a checkout that's already there from the same repository is used as it is (one whose clone was cut off, with nothing checked out, isn't). The clone runs in a session of its own with no terminal, so nothing can stop to ask a question nobody sees, and git's progress goes to a log in `.agent-office/clones/`, which the office reads every second for the elevator panel. A log that stops growing for 3 minutes means the clone is stuck, and it's stopped. The clones under way are kept in `cloning.json`: an office restarted mid-clone (tsx watch, systemd) picks them up and carries on, while Ctrl+C stops them. Each floor runs its own workers, GitHub boards, queue and changes watcher in its checkout. A floor nobody is on, with nothing running, asks GitHub about its boards every 10 minutes instead of every 90 seconds. People get only the moves, worker updates and terminal frames of the floor they're on; the chat, voice connections and the budget are the building's.
+- **Floors.** `floors.json` in the office's `.agent-office/` lists the floors: each one's checkout and colors. Adding one runs `gh repo view` (does this login see it, and what's its exact name), then `gh repo clone` into the projects folder; a checkout that's already there from the same repository is used as it is (one whose clone was cut off, with nothing checked out, isn't). The floor starts on the repository's default branch unless another was picked, which is git's own `--branch` after the `--`: the whole repository comes down, so the floor has every branch to work from, and only the checkout starts where they picked. The picker's list is `gh api repos/<owner>/<name>/branches`, asked for once someone picks the repository. A checkout already on disk is put on the picked branch with `git checkout` (which makes it from origin if it isn't there yet, and refuses rather than losing work on a dirty one). The clone runs in a session of its own with no terminal, so nothing can stop to ask a question nobody sees, and git's progress goes to a log in `.agent-office/clones/`, which the office reads every second for the elevator panel. A log that stops growing for 3 minutes means the clone is stuck, and it's stopped. The clones under way are kept in `cloning.json`: an office restarted mid-clone (tsx watch, systemd) picks them up and carries on, while Ctrl+C stops them. Each floor runs its own workers, GitHub boards, queue and changes watcher in its checkout. A floor nobody is on, with nothing running, asks GitHub about its boards every 10 minutes instead of every 90 seconds. People get only the moves, worker updates and terminal frames of the floor they're on; the chat, voice connections and the budget are the building's.
 - **The rooftop.** Nobody works up there, so the roof isn't a floor: it's a place (`@roof`, which no floor id can be) that people are on, with none of a floor's workers, boards or queue. The DJ's set is endless and needs no state: its tracks, their keys, grooves and basslines, and where each one is follow from the office's clock, like the jukebox's tunes, so everyone up there hears the same bar, and the lights flash on the same kicks and snares even for someone with the music off. Drum and bass at 172 BPM, synthesized in the browser: a two-step break, a reese bass through a filter that opens and closes on the eighths, a sub, pads, an arpeggio, risers into each drop and an air horn when one lands. Being drunk is just your own browser's: while you are, the frame is drawn into a texture and onto the screen through a shader that doubles, smears and ripples it. With reduced motion on, nothing sways or strobes.
 - **State.** The office's `.agent-office/` (in `~/agent-office`, or in the project you started it in) holds the password, the signing secret, the accounts and open invites (`accounts.json`), each account's own Claude, GitHub and git sign-ins (`homes/<account>/`), the floors (`floors.json`) and the clones on their way (`cloning.json`), the chat, the spend and whether workers go home once their PR merges (`leave-on-merge.json`). Each floor's checkout has its own `.agent-office/` with the hook settings, the saved workers and their scrollback, the task queue, the pictures on the walls (`decor.json`), the dog's name (`dog.json`), the jukebox (`jukebox.json`), the whiteboard (`whiteboard/`) and the meetings (`meetings.json`, and each meeting's notes in `meetings/`) and, for DeepSeek Harness workers, the profile patch (`dsh-patch.yml`) with their session logs under `dsh-sessions/`. It is added to `.git/info/exclude` automatically, so it never shows up in `git status`. The one thing the office writes outside it is a Cursor worker's hooks, which the Cursor CLI only reads from `.cursor/hooks.json` in the folder it runs in: they're there while the worker runs, and excluded from git the same way (see [Choosing an agent](agents.md)).
 
diff --git a/src/client/ui/elevator.css b/src/client/ui/elevator.css
index 8aaea1d78..67aeaf839 100644
--- a/src/client/ui/elevator.css
+++ b/src/client/ui/elevator.css
@@ -34,6 +34,12 @@
 .elevator .repo .when { font-size: 11px; color: var(--muted); white-space: nowrap; }
 .elevator .note { margin: 8px 0 0; font-size: 12px; font-weight: 700; color: var(--muted); overflow-wrap: anywhere; }
 .elevator .note.busy { color: var(--ink); }
+/* The branch the new floor is cloned on, under the repository list. */
+.elevator .branch-row { display: flex; gap: 8px; align-items: center; margin-top: 8px; font-size: 13px; font-weight: 800; }
+.elevator .branch-row .lbl { color: var(--muted); }
+.elevator .branch-row select { flex: 0 1 auto; min-width: 0; padding: 4px 8px; font: inherit; font-weight: 800; color: var(--ink); background: #fff; border: 3px solid var(--ink); border-radius: 12px; }
+.elevator .branch-row select:disabled { color: var(--muted); }
+.elevator .branch-note { flex: 1; min-width: 0; font-size: 12px; font-weight: 700; color: var(--bad); overflow-wrap: anywhere; }
 /* The folder's Change button: styles/base.css, after the button rules it restyles. */
 .elevator .dir-pick { margin-top: 8px; }
 .elevator .err { margin: 8px 0 0; font-size: 13px; font-weight: 800; color: var(--bad); overflow-wrap: anywhere; }
diff --git a/src/client/ui/elevator.ts b/src/client/ui/elevator.ts
index 36f6c92a9..02987792e 100644
--- a/src/client/ui/elevator.ts
+++ b/src/client/ui/elevator.ts
@@ -32,12 +32,20 @@ const SHOWN = 60;
 const REPOS_STALE_MS = 5 * 60_000;
 /** Longer than the office takes to ask GitHub about a repository before its clone starts. */
 const START_MS = 60_000;
+/** How long typing has to stop before the panel asks GitHub about a repository's branches. */
+const BRANCH_PAUSE_MS = 350;
 
 /** Panels waiting on a clone; each says whether the answer was for it. */
 const addedWaiters = new Set<(msg: Extract<ServerMsg, { t: 'floor.added' }>) => boolean>();
+/** Panels waiting on a repository's branches. */
+const branchWaiters = new Set<(msg: Extract<ServerMsg, { t: 'floor.branches' }>) => void>();
 
 /** Main feeds server messages through here, so a panel waiting on its clone hears back. */
 export function routeElevatorMessage(msg: ServerMsg) {
+  if (msg.t === 'floor.branches') {
+    for (const fn of branchWaiters) fn(msg);
+    return;
+  }
   if (msg.t !== 'floor.added') return;
   let heard = false;
   for (const fn of addedWaiters) heard = fn(msg) || heard;
@@ -51,6 +59,11 @@ function cloneBar(p: CloneProgress | undefined): HTMLElement | null {
   return h('span.clone-bar', { role: 'progressbar', 'aria-label': p.step, 'aria-valuemin': '0', 'aria-valuemax': '100', 'aria-valuenow': String(p.percent) }, h('span', { style: `width:${p.percent}%` }));
 }
 
+/** The branch a floor's checkout is on, for its row: nothing when git couldn't say, or it's detached. */
+function branchLabel(f: FloorInfo): string {
+  return f.branch && f.branch !== 'HEAD' ? `🌿 ${f.branch}` : '';
+}
+
 let current: Modal | null = null;
 
 export function elevatorPanelOpen(): boolean {
@@ -73,6 +86,15 @@ export function openElevator(opts: ElevatorOptions): void {
   let showAdd = setup || !store.floors.length;
   /** The search box and list are in place (rebuilding them would lose the focus mid-typing). */
   let built = false;
+  /** The branch the new floor is put on; '' is the repository's default branch. */
+  let branch = '';
+  /** The repository the branch list is about (what was asked with), and what came back for it. */
+  let branchRepo: string | undefined;
+  let branchList: string[] = [];
+  let branchDefault: string | undefined;
+  let branchError = '';
+  let branchLoading = false;
+  let branchTimer: number | undefined;
 
   const floorsEl = h('div.floors');
   const addEl = h('div.add');
@@ -107,6 +129,30 @@ export function openElevator(opts: ElevatorOptions): void {
     if (e.key === 'Enter' && !e.isComposing) saveDir();
   });
 
+  // Which branch the new floor's checkout is on. The list is the repository's, asked for once someone
+  // has picked one; leaving it on the default branch clones exactly as before.
+  const branchSel = h('select', { 'aria-label': 'Branch', title: 'The branch the new floor is checked out on, and where its workers start from' }) as HTMLSelectElement;
+  const branchNote = h('span.branch-note');
+  const branchRow = h('div.branch-row.hidden', {}, h('span.lbl', {}, 'Branch'), branchSel, branchNote);
+  /** What the select holds now, so a re-render that changes nothing leaves it (and its focus) alone. */
+  let branchSig = '';
+  const fillBranch = () => {
+    const sig = `${branchLoading}|${branchDefault ?? ''}|${branchList.join('\n')}`;
+    if (sig !== branchSig) {
+      branchSig = sig;
+      branchSel.replaceChildren(
+        h('option', { value: '' }, branchLoading ? 'Loading branches…' : branchDefault ? `Default branch (${branchDefault})` : 'Default branch'),
+        ...branchList.filter((b) => b !== branchDefault).map((b) => h('option', { value: b }, b)),
+      );
+    }
+    branchSel.value = branch;
+    branchSel.disabled = branchLoading || !!adding;
+    branchNote.textContent = branchError ? `${branchError} — the floor is cloned on its default branch` : '';
+  };
+  branchSel.addEventListener('change', () => {
+    branch = branchSel.value;
+  });
+
   const needRepos = () => {
     const r = store.repos;
     if (r.loading || (r.at && Date.now() - r.at < REPOS_STALE_MS && !r.error)) return;
@@ -117,6 +163,44 @@ export function openElevator(opts: ElevatorOptions): void {
   /** What "Add floor" would add: the row picked, else what's typed if it's owner/name. */
   const choice = (): string | undefined => selected ?? normalizeRepo(filter);
 
+  /**
+   * The branches of the repository "Add floor" would clone, asked of the office once one is picked.
+   * Typing waits a moment first: half a repository name is a question gh can only fail.
+   */
+  const ensureBranches = (pick: string | undefined) => {
+    if (adding) return;
+    if (!pick) {
+      branchRepo = undefined;
+      branch = '';
+      return;
+    }
+    if (branchRepo && sameRepo(branchRepo, pick)) return;
+    branchRepo = pick;
+    branch = '';
+    branchList = [];
+    branchDefault = undefined;
+    branchError = '';
+    branchLoading = false;
+    clearTimeout(branchTimer);
+    branchTimer = window.setTimeout(() => {
+      if (!branchRepo || !sameRepo(branchRepo, pick)) return;
+      branchLoading = true;
+      renderAdd();
+      net.send({ t: 'floor.branches', repo: pick });
+    }, BRANCH_PAUSE_MS);
+  };
+
+  /** The branches came back, for this repository or one they've since picked over. */
+  const onBranches = (msg: Extract<ServerMsg, { t: 'floor.branches' }>) => {
+    if (!branchRepo || !sameRepo(msg.repo, branchRepo)) return;
+    branchList = msg.branches;
+    branchDefault = msg.default;
+    branchError = msg.error ?? '';
+    branchLoading = false;
+    renderAdd();
+  };
+  branchWaiters.add(onBranches);
+
   const floorButton = (f: FloorInfo, i: number) => {
     // Down in the garage, your floor is somewhere to go back up to.
     const mine = f.id === store.floor;
@@ -138,7 +222,7 @@ export function openElevator(opts: ElevatorOptions): void {
         'span.floor-text',
         {},
         h('span.floor-name', {}, f.name, here ? h('span.here-tag', {}, 'you are here') : mine ? h('span.here-tag', {}, 'your floor') : null),
-        h('span.floor-sub', {}, [f.repo ?? f.dir, f.cloning ? f.clone?.detail : ''].filter(Boolean).join(' · ')),
+        h('span.floor-sub', {}, [f.repo ?? f.dir, branchLabel(f), f.cloning ? f.clone?.detail : ''].filter(Boolean).join(' · ')),
         f.cloning ? cloneBar(f.clone) : null,
       ),
       h('span.floor-stats', {}, ...stats.flatMap((s, j) => (j ? [' ', s] : [s]))),
@@ -280,6 +364,10 @@ export function openElevator(opts: ElevatorOptions): void {
     if (matches.length > SHOWN) rows.push(h('p.empty', { style: 'padding:8px 10px' }, `…and ${matches.length - SHOWN} more — type to narrow it down`));
     listEl.replaceChildren(...rows);
     const pick = choice();
+    // The branch the floor is cloned on: only for a repository that isn't a floor yet.
+    ensureBranches(pick);
+    fillBranch();
+    branchRow.classList.toggle('hidden', !pick || store.floors.some((f) => sameRepo(f.repo, pick)));
     const dest = pick ? `${store.projectsDir.dir}/${pick}` : `${store.projectsDir.dir}/<owner>/<repo>`;
     const change = store.me.admin ? h('button.btn.dir-change', { type: 'button', title: 'Clone new projects into another folder on the office’s machine' }, '📁 Change folder') : null;
     change?.addEventListener('click', () => editDir(true));
@@ -303,6 +391,7 @@ export function openElevator(opts: ElevatorOptions): void {
         h('h3', {}, setup && !store.floors.length ? 'Pick your first project' : '➕ Add a project'),
         h('div.repo-search', {}, input, refreshBtn),
         listEl,
+        branchRow,
         statusEl,
         dirEl,
       );
@@ -318,7 +407,8 @@ export function openElevator(opts: ElevatorOptions): void {
     seen = false;
     error = '';
     renderAdd();
-    net.send({ t: 'floor.add', repo });
+    // The branch picked, when it's the one the picker was showing for this repository.
+    net.send({ t: 'floor.add', repo, ...(sameRepo(branchRepo, repo) && branch ? { branch } : {}) });
     // The office went away before it started (a restart): don't wait forever.
     clearTimeout(startTimer);
     startTimer = window.setTimeout(() => {
@@ -408,7 +498,9 @@ export function openElevator(opts: ElevatorOptions): void {
     onClose: () => {
       current = null;
       clearTimeout(startTimer);
+      clearTimeout(branchTimer);
       addedWaiters.delete(onAdded);
+      branchWaiters.delete(onBranches);
       for (const off of unsubs) off();
     },
   });
diff --git a/src/server/building.ts b/src/server/building.ts
index 2716aeacd..d7526938a 100644
--- a/src/server/building.ts
+++ b/src/server/building.ts
@@ -2,10 +2,12 @@ import { execFileSync, spawn } from 'node:child_process';
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { FLOOR_PALETTES, MAX_FLOORS, normalizeRepo, sameRepo } from '../shared/floors.js';
-import type { CloneProgress, ProjectsDirState, RepoChoice } from '../shared/protocol.js';
+import { FLOOR_PALETTES, MAX_FLOORS, normalizeBranch, normalizeRepo, sameRepo } from '../shared/floors.js';
+import type { BranchChoices, CloneProgress, ProjectsDirState, RepoChoice } from '../shared/protocol.js';
 import { CloneRun, dropLog, whyCloneFailed, type CloneEnd, type CloneRunOptions } from './clone.js';
 import { gh } from './github.js';
+import { listBranches, listRepos } from './repos.js';
+import { gitError } from './worktrees.js';
 
 /** A floor as floors.json keeps it. */
 export interface FloorDef {
@@ -39,6 +41,8 @@ interface Pending {
   run?: CloneRun;
   /** The account that added it. */
   owner?: string;
+  /** The branch its checkout is put on; the repository's default branch when none. */
+  branch?: string;
   /** GitHub says the repository has no commits yet, so there's nothing to check out. */
   empty: boolean;
 }
@@ -61,9 +65,16 @@ export interface BuildingOptions {
   clone?: Pick<CloneRunOptions, 'stallMs' | 'tickMs'>;
 }
 
+/** Who's adding a floor, and how (see Building.add). */
+export interface AddOptions {
+  /** Whoever's adding it: they can stop the clone, as admins can. */
+  account?: string;
+  /** The branch to check the new floor out on; the repository's default branch when none. */
+  branch?: string;
+}
+
 /** How long the list of repositories `gh` can see is reused before it's asked again. */
 const REPOS_TTL_MS = 5 * 60_000;
-const MAX_REPOS = 1000;
 
 /**
  * The floors of the building, saved in <office>/.agent-office/floors.json: which projects there are,
@@ -277,18 +288,22 @@ export class Building {
   /**
    * Clones a repository into the projects folder and adds it as a floor. `started` hears about the
    * floor as soon as the clone begins; resolves to the finished floor, or to why there's none. A
-   * checkout that's already where the clone would go is used as it is. `account` (whoever's adding it)
-   * can stop the clone, as admins can.
+   * checkout that's already where the clone would go is used as it is, put on `opts.branch` if one was
+   * picked. `opts.account` (whoever's adding it) can stop the clone, as admins can.
    */
-  async add(input: string, by: string, started: (def: FloorDef) => void, account?: string): Promise<FloorDef | string> {
+  async add(input: string, by: string, started: (def: FloorDef) => void, opts: AddOptions = {}): Promise<FloorDef | string> {
     const wanted = normalizeRepo(input);
     if (!wanted) return 'Pick a repository, or type it as owner/name';
+    const branch = opts.branch === undefined ? undefined : normalizeBranch(opts.branch);
+    if (opts.branch !== undefined && !branch) return "That isn't a branch name";
     if (this.defs.some((d) => sameRepo(d.repo, wanted))) return `${wanted} already has a floor`;
     if (this.cloning.has(wanted.toLowerCase())) return `${wanted} is already being cloned`;
     if (this.defs.length + this.cloning.size >= MAX_FLOORS) return `The building is full (${MAX_FLOORS} floors)`;
     // The office's own checkout, taken off before: it moves back in where it is, not into a second clone.
     const home = this.local;
     if (this.localOff && home && sameRepo(home.repo, wanted) && existsSync(home.dir)) {
+      const err = branch ? checkoutBranch(home.dir, branch) : undefined;
+      if (err) return err;
       const def = this.newDef(path.basename(home.dir), home.repo, home.dir, by);
       started(def);
       this.defs.push(def);
@@ -314,7 +329,7 @@ export class Building {
     const dest = path.join(this.projectsDir, owner, name);
     if (this.defs.some((d) => path.resolve(d.dir) === dest)) return `${dest} is already a floor`;
     const def = this.newDef(name, repo, dest, by);
-    const pending: Pending = { def, owner: account, empty };
+    const pending: Pending = { def, owner: opts.account, branch, empty };
     this.cloning.set(key, pending);
     started(def);
     try {
@@ -334,21 +349,21 @@ export class Building {
     const { dir: dest } = p.def;
     const repo = p.def.repo!;
     const there = checkoutAt(dest, repo, p.empty);
-    // Cloned before (a floor that was taken off the list, or by hand): move back in.
-    if (there === 'ok') return undefined;
+    // Cloned before (a floor that was taken off the list, or by hand): move back in, on the branch picked.
+    if (there === 'ok') return p.branch ? checkoutBranch(dest, p.branch) : undefined;
     if (there !== 'none') return there;
     try {
       mkdirSync(path.dirname(dest), { recursive: true });
     } catch (err) {
       return `Couldn't make ${path.dirname(dest)}: ${(err as Error).message}`;
     }
-    if (this.opts.terminal) return cloneHere(repo, dest);
+    if (this.opts.terminal) return cloneHere(repo, dest, p.branch);
     try {
       mkdirSync(this.logsDir, { recursive: true, mode: 0o700 });
     } catch (err) {
       return `Couldn't make ${this.logsDir}: ${(err as Error).message}`;
     }
-    const run = await CloneRun.start(repo, dest, path.join(this.logsDir, `${repo.replace('/', '__')}.log`), { ...this.opts.clone, changed: () => this.cloneChanged?.() });
+    const run = await CloneRun.start(repo, dest, path.join(this.logsDir, `${repo.replace('/', '__')}.log`), { ...this.opts.clone, branch: p.branch, changed: () => this.cloneChanged?.() });
     if (typeof run === 'string') return run;
     p.run = run;
     this.saveClones();
@@ -381,6 +396,11 @@ export class Building {
     return repos;
   }
 
+  /** The branches of a repository, for the elevator's "add a project" to clone a floor on one of them. */
+  branches(repo: string): Promise<BranchChoices> {
+    return listBranches(this.dataDir, repo);
+  }
+
   private newDef(name: string, repo: string | undefined, dir: string, by: string): FloorDef {
     const taken = new Set([...this.defs, ...this.pending()].map((d) => d.id));
     const base = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 32) || 'floor';
@@ -510,6 +530,26 @@ function unwritable(dir: string): string | undefined {
   return undefined;
 }
 
+/**
+ * Puts a checkout of the repository that's already on disk on `branch`, for a floor added on one
+ * that isn't the default. A branch that isn't there yet is taken from origin, as `git checkout`
+ * does; git refuses rather than losing work when the checkout is dirty, and that says why.
+ */
+function checkoutBranch(dir: string, branch: string): string | undefined {
+  const git = (args: string[]) => execFileSync('git', args, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 60_000 }).trim();
+  try {
+    if (git(['rev-parse', '--abbrev-ref', 'HEAD']) === branch) return undefined;
+  } catch (err) {
+    return `${tildify(dir)} isn't a git checkout the office can use: ${gitError(err)}`;
+  }
+  try {
+    git(['checkout', branch]);
+    return undefined;
+  } catch (err) {
+    return `${tildify(dir)} is already a checkout of this repository and couldn't be put on ${branch}: ${gitError(err)}`;
+  }
+}
+
 /** The GitHub repository a checkout's origin points at. */
 export function originRepo(dir: string): string | undefined {
   try {
@@ -543,45 +583,11 @@ function hasCommit(dir: string): boolean {
 }
 
 /** Clones `repo` to `dest` in this terminal: git shows its progress, and ssh or git can ask here. Resolves to an error, if any. */
-function cloneHere(repo: string, dest: string): Promise<string | undefined> {
+function cloneHere(repo: string, dest: string, branch?: string): Promise<string | undefined> {
   return new Promise((resolve) => {
-    const child = spawn('gh', ['repo', 'clone', repo, dest], { cwd: path.dirname(dest), stdio: 'inherit' });
+    const args = ['repo', 'clone', repo, dest, '--', ...(branch ? [`--branch=${branch}`] : [])];
+    const child = spawn('gh', args, { cwd: path.dirname(dest), stdio: 'inherit' });
     child.once('error', (err: NodeJS.ErrnoException) => resolve(err.code === 'ENOENT' ? "The GitHub CLI (gh) isn't installed on this machine" : `Couldn't run gh: ${err.message}`));
     child.once('exit', (code, signal) => resolve(code === 0 ? undefined : `Couldn't clone ${repo}: gh ${signal ? `stopped (${signal})` : `failed (exit ${code})`}`));
   });
 }
-
-async function listRepos(cwd: string): Promise<RepoChoice[]> {
-  const out = await gh(
-    [
-      'api',
-      '--paginate',
-      'user/repos?per_page=100&sort=pushed&affiliation=owner,collaborator,organization_member',
-      '--jq',
-      '.[] | {name: .full_name, description: (.description // ""), private: .private, pushedAt: .pushed_at}',
-    ],
-    cwd,
-    90_000,
-  );
-  const repos: RepoChoice[] = [];
-  const seen = new Set<string>();
-  for (const line of out.split('\n')) {
-    if (!line.trim()) continue;
-    try {
-      const r = JSON.parse(line) as { name?: unknown; description?: unknown; private?: unknown; pushedAt?: unknown };
-      const name = normalizeRepo(r.name);
-      if (!name || seen.has(name.toLowerCase())) continue;
-      seen.add(name.toLowerCase());
-      repos.push({
-        name,
-        description: typeof r.description === 'string' && r.description ? r.description.slice(0, 200) : undefined,
-        private: r.private === true,
-        pushedAt: typeof r.pushedAt === 'string' ? r.pushedAt : undefined,
-      });
-    } catch {
-      // not a line of ours
-    }
-    if (repos.length >= MAX_REPOS) break;
-  }
-  return repos.sort((a, b) => (b.pushedAt ?? '').localeCompare(a.pushedAt ?? ''));
-}
diff --git a/src/server/clone.ts b/src/server/clone.ts
index e966fe11a..2d76df6f2 100644
--- a/src/server/clone.ts
+++ b/src/server/clone.ts
@@ -51,6 +51,7 @@ export function whyCloneFailed(output: string): string {
     .map((l) => l.trim())
     .filter((l) => l && !PROGRESS.test(l) && !/^Cloning into /.test(l));
   const all = said.join('\n');
+  if (/not found in upstream/i.test(all)) return "the branch you picked isn't on the repository — add the floor again and pick another";
   if (/Host key verification failed/i.test(all)) return "ssh on the office's machine hasn't accepted github.com's host key yet. Run `ssh -T git@github.com` there once, or clone over https with `gh config set git_protocol https`";
   if (/passphrase/i.test(all)) return "the office's ssh key needs its passphrase. Add it to the ssh agent (`ssh-add`), or clone over https with `gh config set git_protocol https`";
   if (/Permission denied \(publickey/i.test(all)) return "GitHub didn't take the office's ssh key. Add it with `gh ssh-key add`, or clone over https with `gh config set git_protocol https`";
@@ -69,6 +70,8 @@ export interface CloneEnd {
 export interface CloneRunOptions {
   /** Hears about new progress, at most once a tick. */
   changed?: () => void;
+  /** The branch to check the clone out on (see CloneRun.start); the repository's default branch when none. */
+  branch?: string;
   stallMs?: number;
   tickMs?: number;
 }
@@ -107,7 +110,10 @@ export class CloneRun {
     return new Promise((resolve) => {
       let child: ChildProcess;
       try {
-        child = spawn('gh', ['repo', 'clone', repo, dest, '--', '--progress'], {
+        // `--branch` after the `--` is git's own: the whole repository comes down either way, so the
+        // floor still has every branch to work from, and only the checkout starts where you picked.
+        const args = ['repo', 'clone', repo, dest, '--', ...(opts.branch ? [`--branch=${opts.branch}`] : []), '--progress'];
+        child = spawn('gh', args, {
           cwd: path.dirname(dest),
           detached: GROUPS,
           stdio: ['ignore', fd, fd],
diff --git a/src/server/repos.ts b/src/server/repos.ts
new file mode 100644
index 000000000..5b08414d7
--- /dev/null
+++ b/src/server/repos.ts
@@ -0,0 +1,77 @@
+// What the office's `gh` login can see on GitHub: the repositories it can clone, and the branches of
+// one of them. The elevator's "add a project" is what asks, through the Building.
+import { normalizeBranch, normalizeRepo } from '../shared/floors.js';
+import type { BranchChoices, RepoChoice } from '../shared/protocol.js';
+import { gh } from './github.js';
+
+/** The most repositories the elevator lists, and the most branches of one. */
+const MAX_REPOS = 1000;
+const MAX_BRANCHES = 500;
+
+/** Repositories the office's `gh` login can clone, most recently pushed first. */
+export async function listRepos(cwd: string): Promise<RepoChoice[]> {
+  const out = await gh(
+    [
+      'api',
+      '--paginate',
+      'user/repos?per_page=100&sort=pushed&affiliation=owner,collaborator,organization_member',
+      '--jq',
+      '.[] | {name: .full_name, description: (.description // ""), private: .private, pushedAt: .pushed_at}',
+    ],
+    cwd,
+    90_000,
+  );
+  const repos: RepoChoice[] = [];
+  const seen = new Set<string>();
+  for (const line of out.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const r = JSON.parse(line) as { name?: unknown; description?: unknown; private?: unknown; pushedAt?: unknown };
+      const name = normalizeRepo(r.name);
+      if (!name || seen.has(name.toLowerCase())) continue;
+      seen.add(name.toLowerCase());
+      repos.push({
+        name,
+        description: typeof r.description === 'string' && r.description ? r.description.slice(0, 200) : undefined,
+        private: r.private === true,
+        pushedAt: typeof r.pushedAt === 'string' ? r.pushedAt : undefined,
+      });
+    } catch {
+      // not a line of ours
+    }
+    if (repos.length >= MAX_REPOS) break;
+  }
+  return repos.sort((a, b) => (b.pushedAt ?? '').localeCompare(a.pushedAt ?? ''));
+}
+
+/**
+ * The branches of a repository, for the elevator's "add a project" to clone a floor on one of them.
+ * The default branch is always among them, even when the list was cut short before it.
+ */
+export async function listBranches(cwd: string, repo: string): Promise<BranchChoices> {
+  const [names, view] = await Promise.all([
+    gh(['api', '--paginate', `repos/${repo}/branches?per_page=100`, '--jq', '.[].name'], cwd, 60_000),
+    gh(['repo', 'view', repo, '--json', 'defaultBranchRef'], cwd, 30_000).catch(() => ''),
+  ]);
+  const branches: string[] = [];
+  const seen = new Set<string>();
+  for (const line of names.split('\n')) {
+    const name = normalizeBranch(line);
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    branches.push(name);
+    if (branches.length >= MAX_BRANCHES) break;
+  }
+  const def = normalizeBranch(defaultBranchOf(view));
+  if (def && !seen.has(def)) branches.unshift(def);
+  return { branches, ...(def ? { default: def } : {}) };
+}
+
+/** The default branch's name in `gh repo view --json defaultBranchRef`'s answer, when it names one. */
+function defaultBranchOf(view: string): unknown {
+  try {
+    return (JSON.parse(view) as { defaultBranchRef?: { name?: unknown } }).defaultBranchRef?.name;
+  } catch {
+    return undefined;
+  }
+}
diff --git a/src/server/ws/handlers/floors.ts b/src/server/ws/handlers/floors.ts
index 3f0f2cdab..c7a791ecc 100644
--- a/src/server/ws/handlers/floors.ts
+++ b/src/server/ws/handlers/floors.ts
@@ -1,6 +1,7 @@
 // The building's floors: riding the elevator between them and up to the roof, and adding and taking
 // off floors.
 import type { FloorClientMsg } from '../../../shared/protocol.js';
+import { normalizeRepo } from '../../../shared/floors.js';
 import { ROOF } from '../../../shared/rooftop.js';
 import { arrivalSpot, str } from '../../office/input.js';
 import type { HandlerMap, ViewPieces } from './types.js';
@@ -24,6 +25,17 @@ export const floorHandlers = {
       (err: Error) => ctx.sendTo(c, { t: 'floor.repos', repos: [], error: `Couldn't list your repositories with gh: ${err.message}` }),
     );
   },
+  'floor.branches'(ctx, c, msg) {
+    // The panel asks as someone picks a repository; the answer says which repository it's about, in
+    // the words they asked with, so a list that arrives after they've picked another is ignored.
+    const asked = str(msg.repo, 200);
+    const repo = normalizeRepo(asked);
+    if (!repo) return ctx.sendTo(c, { t: 'floor.branches', repo: asked, branches: [], error: 'Pick a repository first' });
+    void ctx.building.branches(repo).then(
+      (choices) => ctx.sendTo(c, { t: 'floor.branches', repo: asked, ...choices }),
+      (err: Error) => ctx.sendTo(c, { t: 'floor.branches', repo: asked, branches: [], error: `Couldn't list ${repo}'s branches with gh: ${err.message}` }),
+    );
+  },
   'floor.add'(ctx, c, msg) {
     const who = c.peer.name;
     const repo = str(msg.repo, 200);
@@ -35,7 +47,7 @@ export const floorHandlers = {
           ctx.floorsChanged();
           ctx.toastAll(`🛗 ${who} is adding a floor for ${def.repo ?? def.name}…`);
         },
-        c.accountId,
+        { account: c.accountId, branch: msg.branch },
       )
       .then((r) => {
         ctx.floorsChanged();
diff --git a/src/shared/floors.ts b/src/shared/floors.ts
index 3a7792aa1..aa29eb498 100644
--- a/src/shared/floors.ts
+++ b/src/shared/floors.ts
@@ -55,6 +55,22 @@ export function normalizeRepo(value: unknown): string | undefined {
   return `${owner}/${repo}`;
 }
 
+/**
+ * A branch name from what someone picked or typed: undefined for anything git wouldn't take, so it
+ * can never become a CLI option, a path or a revision of its own. Every name GitHub hands out
+ * passes; this is what stops a hand-written message from reaching `git clone --branch` or
+ * `git checkout` with something else in it.
+ */
+export function normalizeBranch(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const s = value.trim();
+  if (!s || s.length > 200) return undefined;
+  // git's own rules (see git-check-ref-format): no leading -, no .. or //, no control characters,
+  // and none of ~ ^ : ? * [ \ or a space, which is all a branch name may not hold.
+  if (/^[.-]|\.\.|\/\/|@\{|[~^:?*\[\\\s\x00-\x1f\x7f]/.test(s) || s.endsWith('/') || s.endsWith('.') || s.endsWith('.lock')) return undefined;
+  return s;
+}
+
 export function sameRepo(a: string | undefined, b: string | undefined): boolean {
   return !!a && !!b && a.toLowerCase() === b.toLowerCase();
 }
diff --git a/src/shared/protocol/floors.ts b/src/shared/protocol/floors.ts
index ce908eaa2..57c1dc45d 100644
--- a/src/shared/protocol/floors.ts
+++ b/src/shared/protocol/floors.ts
@@ -93,6 +93,14 @@ export interface RepoChoice {
   pushedAt?: string;
 }
 
+/** The branches a repository could be cloned on, for the elevator's "add a project". */
+export interface BranchChoices {
+  /** The branch names, as GitHub lists them (alphabetical). */
+  branches: string[];
+  /** The repository's default branch: what its floor is cloned on when nobody picks another. */
+  default?: string;
+}
+
 /** Everything that belongs to the floor you're on: sent when you walk in, and when you change floors. */
 
 export interface FloorView {
@@ -136,7 +144,9 @@ export type FloorClientMsg =
   /** The repositories that could become a floor; answered with `floor.repos`. */
   | { t: 'floor.repos'; refresh?: boolean }
   /** Clone a repository and make it a new floor; answered with `floor.added` once it's there. */
-  | { t: 'floor.add'; repo: string }
+  | { t: 'floor.add'; repo: string; branch?: string }
+  /** The branches a repository could be cloned on (see floor.branches). */
+  | { t: 'floor.branches'; repo: string }
   /** Stop a floor's clone before it's there (admins, or whoever added it); the one who added it hears `floor.added` with why. */
   | { t: 'floor.cancel'; floor: string }
   /** Take a floor off the building (admins only). Its checkout stays on disk; everyone on it rides to another floor. */
@@ -157,6 +167,8 @@ export type FloorServerMsg =
   | { t: 'floors'; floors: FloorInfo[] }
   /** Sent to whoever asked. */
   | { t: 'floor.repos'; repos: RepoChoice[]; error?: string }
+  /** Sent to whoever asked, for the branch it's about (`repo` is what they asked about). */
+  | { t: 'floor.branches'; repo: string; branches: string[]; default?: string; error?: string }
   /** Sent to whoever asked for the floor, once it's cloned (or couldn't be). */
   | { t: 'floor.added'; repo: string; floor?: string; error?: string }
   /** The projects folder moved (see floor.projectsDir). */
diff --git a/tests/clone.test.ts b/tests/clone.test.ts
index 91b156f6a..0566405e2 100644
--- a/tests/clone.test.ts
+++ b/tests/clone.test.ts
@@ -7,23 +7,30 @@ import path from 'node:path';
 import { Building, type FloorDef } from '../src/server/building.js';
 import { parseProgress, whyCloneFailed } from '../src/server/clone.js';
 
-// A stand-in for gh: `repo view` and `repo clone` from bare repositories in $FAKE_GH_REPOS. It says
-// how far along it is the way git does, can wait first ($FAKE_GH_DELAY), hang ($FAKE_GH_HANG) or
-// fail the way ssh does ($FAKE_GH_FAIL).
+// A stand-in for gh: `repo view`, `repo clone` and `api` from bare repositories in $FAKE_GH_REPOS.
+// `repo clone` checks the branch out the way gh passes `--branch` to git. It says how far along it is
+// the way git does, can wait first ($FAKE_GH_DELAY), hang ($FAKE_GH_HANG) or fail the way ssh does
+// ($FAKE_GH_FAIL). `api` prints $FAKE_GH_BRANCHES, the branch names of the repository.
 const FAKE_GH = `#!/bin/sh
 case "$1 $2" in
   "repo view")
     [ -d "$FAKE_GH_REPOS/$3.git" ] || { echo "GraphQL: Could not resolve to a Repository with the name '$3'." >&2; exit 1; }
-    echo "{\\"nameWithOwner\\":\\"$3\\",\\"isEmpty\\":false}"
+    echo "{\\"nameWithOwner\\":\\"$3\\",\\"isEmpty\\":false,\\"defaultBranchRef\\":{\\"name\\":\\"main\\"}}"
+    ;;
+  "api "*)
+    printf '%s\\n' "$FAKE_GH_BRANCHES"
     ;;
   "repo clone")
     name="$3"; dest="$4"
+    branch=""
+    for a in "$@"; do case "$a" in --branch=*) branch="\${a#--branch=}";; esac; done
     printf "Cloning into '%s'...\\n" "$dest" >&2
     [ -n "$FAKE_GH_FAIL" ] && { echo "$FAKE_GH_FAIL" >&2; echo "fatal: Could not read from remote repository." >&2; exit 128; }
     [ -n "$FAKE_GH_HANG" ] && exec sleep 600
     printf "Receiving objects:  42%% (42/100), 1.00 MiB | 512.00 KiB/s\\r" >&2
     [ -n "$FAKE_GH_DELAY" ] && sleep "$FAKE_GH_DELAY"
-    git clone -q "$FAKE_GH_REPOS/$name.git" "$dest" || exit 1
+    if [ -n "$branch" ]; then git clone -q --branch "$branch" "$FAKE_GH_REPOS/$name.git" "$dest" || exit 1
+    else git clone -q "$FAKE_GH_REPOS/$name.git" "$dest" || exit 1; fi
     git -C "$dest" remote set-url origin "https://github.com/$name.git"
     ;;
 esac
@@ -53,14 +60,16 @@ function office(t: { after(fn: () => void): void }) {
   const repos = path.join(root, 'github');
   // acme/game on "GitHub", with a commit.
   const work = path.join(root, 'work');
-  execFileSync('git', ['init', '-q', work]);
+  execFileSync('git', ['init', '-q', '-b', 'main', work]);
   writeFileSync(path.join(work, 'index.html'), '<h1>game</h1>');
   execFileSync('git', ['-C', work, 'add', '.']);
   execFileSync('git', ['-C', work, '-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-qm', 'first']);
   execFileSync('git', ['clone', '-q', '--bare', work, path.join(repos, 'acme', 'game.git')]);
+  // A second branch, for a floor added on one that isn't the default.
+  execFileSync('git', ['-C', path.join(repos, 'acme', 'game.git'), 'branch', 'feature']);
   process.env.PATH = `${bin}${path.delimiter}${process.env.PATH}`;
   process.env.FAKE_GH_REPOS = repos;
-  for (const k of ['FAKE_GH_DELAY', 'FAKE_GH_HANG', 'FAKE_GH_FAIL']) delete process.env[k];
+  for (const k of ['FAKE_GH_DELAY', 'FAKE_GH_HANG', 'FAKE_GH_FAIL', 'FAKE_GH_BRANCHES']) delete process.env[k];
   const projects = path.join(root, 'projects');
   /** The clones under way, as the office keeps them for the next one. */
   const saved = () => (existsSync(path.join(dataDir, 'cloning.json')) ? (JSON.parse(readFileSync(path.join(dataDir, 'cloning.json'), 'utf8')) as (FloorDef & { pid: number })[]) : []);
@@ -142,7 +151,7 @@ test('a clone can be stopped by an admin or whoever added it', async (t) => {
   process.env.FAKE_GH_HANG = '1';
   const building = new Building(dataDir, projects, { clone: { tickMs: 50 } });
   let id = '';
-  const r = building.add('acme/game', 'Sam', (def) => (id = def.id), 'sam-account');
+  const r = building.add('acme/game', 'Sam', (def) => (id = def.id), { account: 'sam-account' });
   const pid = await running();
   assert.match(String(building.cancel(id, 'Ann stopped the clone', (owner) => owner === 'ann-account')), /Only admins/);
   assert.equal(building.cancel(id, 'Sam stopped the clone', (owner) => owner === 'sam-account'), undefined);
@@ -196,3 +205,60 @@ test("a clone that was cut off isn't taken for a checkout", async (t) => {
   assert.match(String(await building.add('acme/game', 'Sam', () => {})), /didn't finish/);
   assert.deepEqual(building.list(), []);
 });
+
+test('a floor added on a branch is cloned with its checkout there', async (t) => {
+  const { dataDir, projects } = office(t);
+  process.env.FAKE_GH_DELAY = '0.3';
+  const building = new Building(dataDir, projects, fast);
+  const r = await building.add('acme/game', 'Sam', () => {}, { branch: 'feature' });
+  assert.equal(typeof r, 'object', String(r));
+  // The whole repository comes down either way: only the checkout starts where they picked.
+  const dir = path.join(projects, 'acme', 'game');
+  const head = (d: string) => execFileSync('git', ['-C', d, 'rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8' }).trim();
+  assert.equal(head(dir), 'feature');
+  const branches = execFileSync('git', ['-C', dir, 'branch', '-a'], { encoding: 'utf8' });
+  assert.match(branches, /\borigin\/feature\b/, 'the branch picked is there');
+  assert.match(branches, /\borigin\/main\b/, 'and so is the rest of the repository');
+});
+
+test("a branch that isn't a branch name is refused before anything is cloned", async (t) => {
+  const { dataDir, projects } = office(t);
+  const building = new Building(dataDir, projects, fast);
+  // A branch name is git's own; one of these would become an option of git's, not a branch.
+  for (const branch of ['--upload-pack=touch /tmp/pwned', 'main..other', 'a b', '']) {
+    assert.equal(await building.add('acme/game', 'Sam', () => {}, { branch }), "That isn't a branch name", branch);
+  }
+  assert.deepEqual(building.list(), []);
+  assert.deepEqual(building.pending(), []);
+});
+
+test("a checkout already on disk is put on the branch picked, and says so when git won't", async (t) => {
+  const { root, dataDir, projects } = office(t);
+  const dest = path.join(projects, 'acme', 'game');
+  execFileSync('git', ['clone', '-q', path.join(root, 'github', 'acme', 'game.git'), dest]);
+  execFileSync('git', ['-C', dest, 'remote', 'set-url', 'origin', 'https://github.com/acme/game.git']);
+  const head = () => execFileSync('git', ['-C', dest, 'rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8' }).trim();
+  assert.equal(head(), 'main');
+  const building = new Building(dataDir, projects, fast);
+  // A branch the repository doesn't have: git refuses, and the checkout is left where it was.
+  assert.match(String(await building.add('acme/game', 'Sam', () => {}, { branch: 'nope' })), /couldn't be put on nope/);
+  assert.equal(head(), 'main');
+  assert.deepEqual(building.list(), []);
+  // The one it does have: the checkout moves onto it, with nothing cloned again.
+  assert.equal(typeof (await building.add('acme/game', 'Sam', () => {}, { branch: 'feature' })), 'object');
+  assert.equal(head(), 'feature');
+});
+
+test("a repository's branches come back with its default one, ready for the picker", async (t) => {
+  const { dataDir, projects } = office(t);
+  const building = new Building(dataDir, projects, fast);
+  process.env.FAKE_GH_BRANCHES = 'feature\nmain\n--evil\nnot a branch\nfeature';
+  // gh's list, without what isn't a branch name and without the repeats; the default is named apart.
+  assert.deepEqual(await building.branches('acme/game'), { branches: ['feature', 'main'], default: 'main' });
+  // A list cut short of the default branch still offers it.
+  process.env.FAKE_GH_BRANCHES = 'feature';
+  assert.deepEqual(await building.branches('acme/game'), { branches: ['main', 'feature'], default: 'main' });
+  // Nothing from gh at all: the default is all the picker has.
+  process.env.FAKE_GH_BRANCHES = '';
+  assert.deepEqual(await building.branches('acme/game'), { branches: ['main'], default: 'main' });
+});