diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0566a87..23559d7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -63,13 +63,13 @@ jobs:
           zsh -n bin/off-probe
           zsh -n bin/root-probe
           zsh -n bin/ctx-probe
-          zsh -n bin/zoom-probe
+          zsh -n bin/grid-probe
           zsh -n bin/agent-probe
           zsh -n install.sh
           sh -n bin/office-attn
           sh -n bin/office-ctx
           sh -n bin/office-cwd
-          python3 -m py_compile bin/key-probe bin/mouse-probe
+          python3 -m py_compile bin/key-probe bin/mouse-probe bin/menu-probe
 
       # tmux refuses to parse a config it cannot read, and a broken one would
       # otherwise only surface as "the keys do nothing" inside a probe.
@@ -80,6 +80,10 @@ jobs:
           tmux -L cfg source-file "$PWD/theme/office-theme.tmux.conf"
           tmux -L cfg list-keys -T prefix | grep -qE '^bind-key +-T prefix +n ' \
             || { echo "prefix n is not bound"; exit 1; }
+          # the pane toggles are gone: a pane is whatever you pick from n
+          if tmux -L cfg list-keys -T prefix | grep -qE "^bind-key +-T prefix +[scea] .*office"; then
+            echo "a pane toggle key is back"; exit 1
+          fi
           # No destructive action may sit behind one hard-coded letter again.
           # `confirm-before` takes exactly one key for yes -- y -- and on a
           # QWERTZ keyboard the key the hand reaches for sends z, so the prompt
@@ -135,8 +139,9 @@ jobs:
       - name: root-probe
         run: bin/root-probe
 
-      - name: zoom-probe
-        run: bin/zoom-probe
+      # one pane that asks, then the grid: three across, two down, six in all
+      - name: grid-probe
+        run: bin/grid-probe
 
       - name: attn-probe
         run: bin/attn-probe
@@ -157,3 +162,7 @@ jobs:
 
       - name: agent-probe
         run: bin/agent-probe
+
+      # the menu draws only on a real client, so this one attaches one
+      - name: menu-probe
+        run: bin/menu-probe
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 32bbcad..6c7bc32 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -17,7 +17,7 @@ something that turns out to be out of scope.
 
 A tmux cockpit for running several coding-agent sessions at once. Around 2,100
 
-lines of zsh and tmux config, seven probes that drive a real tmux server, and one
+lines of zsh and tmux config, nine probes that drive a real tmux server, and one
 iTerm2 profile.
 
 **In scope:** making that faster, clearer or harder to get wrong. Support for
@@ -113,13 +113,19 @@ hidden copy mode it opened. And a double-click cannot be read back for a full
 second: tmux holds it for its own 500ms triple-click window before the binding
 starts, so a check that looks sooner reports a working gesture as broken.
 
-Touched anything that reads `pane_left`, `pane_top` or a window size? Run
-`bin/zoom-probe`. It builds a throwaway office, zooms a pane, and runs every
-command that moves one. **A zoomed pane reports full-window coordinates**, so
-every "which column is this in" question in `office.zsh` is answered about a
-room that is not on screen — and `_office_layout_ok` then calls a perfectly good
-office broken and hands it to `_office_relayout`, which breaks every pane out to
-the stash. Reading the code does not show you this; the probe does.
+Touched the grid — adding, parking, unparking, moving or closing a pane, or
+anything that reads `pane_left`, `pane_top` or a window size? Run
+`bin/grid-probe`. It builds a throwaway office and drives the same calls the
+menu items and key bindings make (`office new --agent N`, `--shell`, `--edit`,
+`--back <window>` — `display-menu` cannot be made to draw headless, so the menu
+itself is out of reach), then checks the geometry after every step: at most
+three across, at most two rows, the top row filling first and taking the odd
+pane (three panes is always "2 1", five is "3 2", never "2 3"), zoom dropped before anything is
+measured, and the grid re-fitting itself after a close it did not initiate
+through `office.zsh` (the config's `after-kill-pane` hook). Reading the code
+does not tell you whether the layout string it built was actually valid; the
+probe does — tmux silently refuses one whose checksum does not match, so a bug
+here reads as "nothing happened" rather than an error.
 
 Touched `bin/office-attn`, `@office_attn_gate` or a `pane-border-format`? Run
 `bin/attn-probe`. It builds a throwaway office and puts fake agents in the desks
@@ -152,11 +158,18 @@ does not.
 
 Touched `OFFICE_AGENTS`, `_office_new` or the `Ctrl-Space n` menu? Run
 `bin/agent-probe`. It builds a throwaway office and drives `office new`
-directly — no real client, so it also proves the shape display-menu cannot be
-made to draw headless: one agent opens the desk with no menu at all, `--agent
-2` (by number) and `--agent <LABEL>` both split the right command and label
-out of the array, and 2+ agents with none named opens nothing, because the
-picker needs a client this probe deliberately does not attach.
+directly — no real client: a named worktree opens agent 1, `--agent 2` (by
+number) and `--agent <LABEL>` both split the right command and label out of the
+array, and a bare `office new` opens nothing, because the menu needs a client
+this probe deliberately does not attach.
+
+Touched `_office_open`, the first pane's wait, the menu, or parking? Run
+`bin/menu-probe`. It is the one that DOES attach a client, on a pty, and types
+at it: the office opens as one pane whose menu draws by itself, `1` turns that
+pane into the first agent, `Ctrl-Space n` then `s` adds a shell, `Ctrl-Space x`
+parks it, and the next menu brings it back under `a`. Its rc file is a
+throwaway `ZDOTDIR` pointed at this checkout, because every menu item runs
+`zsh -ic`, and your own `~/.zshrc` may source a different copy of office.
 
 **A probe must never reach your office.** `TMUX_TMPDIR` alone does not isolate
 it: inside a desk, tmux talks to the server in `$TMUX` first. A probe run from a
diff --git a/GETTING-STARTED.md b/GETTING-STARTED.md
index d489f95..c4bf413 100644
--- a/GETTING-STARTED.md
+++ b/GETTING-STARTED.md
@@ -55,35 +55,43 @@ office on
 ```
 
 ```
-┌─────────────────────────────┬──────────────┐
-│ 1 CLAUDE                    │ 2 SHELL      │
-│                             │              │
-│   your coding agent         ├──────────────┤
-│   claude / codex / any CLI  │ 3 FILE EDITOR│
-│                             │              │
-└─────────────────────────────┴──────────────┘
+  what should this pane be?  any key shows the list again.
+
+    ›  CLAUDE
+       shell
+       file editor
+```
+
+One pane, asking. Press any key and pick from the list: your agent, a plain
+shell, or the file editor. Pick your agent first, then press **Ctrl+Space,
+then `n`** twice more and pick shell, then file editor:
+
+```
+┌──────────────┬──────────────┬──────────────┐
+│ 1 CLAUDE     │ 2 SHELL      │ 3 FILE EDITOR│
+│              │              │              │
+│              │              │              │
+└──────────────┴──────────────┴──────────────┘
 ```
 
 Three panes. That is the whole tool.
 
-**1. The agent (left, big).** Your agent, running in your project. Type here the
-same way you type in the desktop app. Paste an image, drag a file in, ask it to
-change something. This is where you spend your time, which is why it gets the
-space.
+**1. The agent.** Your agent, running in your project. Type here the same way
+you type in the desktop app. Paste an image, drag a file in, ask it to change
+something. This is where you spend your time, which is why it gets equal space
+with everything else.
 
-**2. The shell (top right).** An ordinary command line, already in your project.
-For `git status`, `npm test`, `ls`. You use it to *check* the agent's work: it
-says it fixed the tests, so you run them.
+**2. The shell.** An ordinary command line, already in your project. For
+`git status`, `npm test`, `ls`. You use it to *check* the agent's work: it says
+it fixed the tests, so you run them.
 
-**3. The file editor (bottom right).** A file browser that follows the shell pane, so
-the two work together: `cd` in the shell to aim, browse and open in the editor.
-For reading what the agent did, or a quick manual fix.
+**3. The file editor.** A file browser that follows the shell pane, so the two
+work together: `cd` in the shell to aim, browse and open in the editor. For
+reading what the agent did, or a quick manual fix.
 
-There is a fourth, **AGENT CHAT**, closed until you have something to put in it.
-That one is not for a coding agent: it is for an agent *you* build. Once you
-have one, this is where you talk to it and give it work, without ever standing
-up a dashboard or wiring up Slack. Ignore it on day one, and see
-[the README](README.md#bringing-your-own-agent) when you get there.
+Running an agent of your own and want to talk to it the same way? See
+[the README](README.md#bringing-your-own-agent) when you get there — it is just
+one more line, not a different kind of pane.
 
 ---
 
@@ -125,9 +133,9 @@ operating system with nothing to set up.
 This is the part that catches everyone, including people who have used
 terminals for years.
 
-Press **Ctrl+Space, then `e`** to open the editor pane. You get a list of files with a
-search box. Type a few letters to filter, arrow up and down, **Enter** to open
-one.
+Press **Ctrl+Space, then `n`**, and pick **file editor** from the list. You get
+a list of files with a search box. Type a few letters to filter, arrow up and
+down, **Enter** to open one.
 
 **It follows the shell pane.** Whatever directory the shell is standing in is
 what the editor shows, listed the way a file tree reads. `cd src` in the shell,
@@ -144,18 +152,18 @@ Now you are inside a file, and here is the bit nobody remembers:
 | **Ctrl+Q** | close the file, back to the file list |
 | **Ctrl+Z** | undo |
 | **Ctrl+F** | find |
-| **Esc** (at the file list) | leave the file list. The pane becomes an ordinary shell, and `Ctrl+Space e` brings the list back |
+| **Esc** (at the file list) | leave the file list. The pane becomes an ordinary shell, and says so |
 
 **The editor shows these keys along its bottom edge while a file is open**, so
 you do not have to remember them. Look down.
 
 The path out is always the same: `Ctrl+Q` gets you back to the list, `Esc`
-leaves the list, `Ctrl+Space e` hides the pane.
+leaves the list. To bring the editor back, **Ctrl+Space, then `n`**, and pick
+**file editor** again — it is only offered while none is open, so it is always
+right there in the menu when you need it.
 
 **Nothing you do in here can lose the pane.** Leave the list and it says so, in
-the pane, with the key that brings it back. That key works on every pane in the
-strip: if what a pane was running has stopped, its own key starts it again
-instead of hiding it.
+the pane, and the same `Ctrl+Space n` that opens every pane brings it back.
 
 > **If your editor looks nothing like this** and shows no help at the bottom,
 > your `$EDITOR` points somewhere else: vim, or macOS's `nano`, which is really
@@ -167,9 +175,10 @@ instead of hiding it.
 
 ## 6. Running more than one agent
 
-**Ctrl+Space, then `n`** adds a second agent, below the first. Up to four. They share
-the left column evenly, and each one is a separate conversation working on a
-separate thing.
+**Ctrl+Space, then `n`** asks the same question again: pick your agent (or
+another one, if you have more than one set up) and it takes the next cell in
+the grid — up to six panes total, three across at most — and each one is a
+separate conversation working on a separate thing.
 
 Each one also gets **its own checkout** — a git worktree under
 `.claude/worktrees/`, made for it if there is not a free one already. Without
@@ -221,27 +230,26 @@ And `Ctrl+Space`, then:
 
 | | |
 |---|---|
-| `n` | new agent session |
-| `s` `e` `c` | show or hide shell / editor / chat |
-| `a` | hide every agent, bring them all back, or open one if you have none |
+| `n` | one more pane: pick from the menu — parked panes, every agent, shell, file editor |
+| `x` | park this pane: hidden, still running. `n`'s menu brings it back |
 | `q` | close this pane for good. A menu opens: click **close it**, or press `c`. Enter, Escape or `k` keeps it |
-| `x` | park this pane: hidden, still running |
 | `z` | zoom this pane full screen, and back |
 
 And the mouse, with no key at all:
 
 | | |
 |---|---|
+| drag a pane's title onto another pane | it moves there, the rest shift along |
 | drag across text | it is on the clipboard when you let go, nothing to press |
 | double-click a word | the same, for one word |
 | click in a pane that scrolled | back at the live prompt, typing again (Escape does it too) |
 
 Each pane's top border shows its number and what it is, and the bar along the
-bottom carries the keys. **Whatever is bright on that bar is closed.**
+bottom carries the keys, including how many panes are parked right now.
 
-And the thing you actually wanted from four agents at once: a desk that has
+And the thing you actually wanted from several agents at once: a desk that has
 stopped and is waiting on you says **your turn** on its own border, with how long
-it has been waiting. You never have to read all four panes to find the one that
+it has been waiting. You never have to read every pane to find the one that
 finished. Nothing to press, and nothing to set up.
 
 That number keeps counting all night, so a desk you left at midnight says
@@ -261,8 +269,8 @@ Nothing here ever needs a restart of anything.
 |---|---|
 | a pane is frozen and its keys do nothing | it is in scroll mode. Press `q` |
 | git says a branch is "already used by worktree" | `office cd <branch>` — go to it instead of checking it out |
-| the panes are in silly positions | `office layout` |
-| you closed something and cannot get it back | its key again, or `office show` |
+| the panes are in silly positions | they re-fit on the next pane you add, park, unpark or close |
+| you closed something and cannot get it back | `Ctrl+Space n`, or `office show` |
 | you have no idea what is running | `office doctor` |
 | genuinely wedged | `office off`, then `office on`. Resets everything |
 
@@ -277,8 +285,8 @@ which is the real reason to close ones you have finished with.
 1. `office on`
 2. Ask the agent in pane 1 something small about your project. "What does this
    repo do?" is a fine start.
-3. When it changes a file, look at it: `Ctrl+Space e`, find the file, read it,
-   `Ctrl+Q`, `Esc`.
+3. When it changes a file, look at it: `Ctrl+Space n`, pick **file editor**,
+   find the file, read it, `Ctrl+Q`, `Esc`.
 4. Run your tests in the shell pane.
 5. `Ctrl+Space n`, and give the second agent something unrelated.
 
diff --git a/README.md b/README.md
index f9c9346..6b29351 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Agent Office
 
-### Four agents. One window.
+### Several agents. One window.
 
 Each one in its own git worktree. The one that has stopped and is waiting on you
 says so, on its own border, without being asked.
@@ -10,10 +10,10 @@ says so, on its own border, without being asked.
 ![Platform: macOS, Linux and WSL2](https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20WSL2-6a6c77)
 ![No daemon](https://img.shields.io/badge/daemons-0-6a6c77)
 
-**Build agents with agents, and talk to what you built, in one window.**
-Several coding-agent sessions side by side, each in its own git worktree, plus a
-shell, a file editor that follows that shell, and a chat pane wired to your own
-agent. Claude Code out of the box, Codex or any other CLI with one variable.
+**Several coding agents side by side, each in its own git worktree, plus shells
+and a file editor, in one window.** "Your turn" and how full each context
+window is, right on the border. Claude Code out of the box, Codex, a local
+model, or any other CLI — one more line in `OFFICE_AGENTS`.
 
 [**The product page**](https://zyxworks.github.io/agent-office/) ·
 [Our other tools](https://zyxworks.com/) ·
@@ -24,31 +24,22 @@ office on
 ```
 
 ```
-┌─────────────────────────────┬──────────────┐
-│ 1 CLAUDE                    │ 4 AGENT CHAT │  ^Space c
-│                             │              │
-├─────────────────────────────┼──────────────┤
-│ 2 CLAUDE 2   ^Space n adds  │ 5 SHELL      │  ^Space s
-│                 one more    │              │
-├─────────────────────────────┼──────────────┤
-│ 3 CLAUDE 3                  │ 6 FILE EDITOR│  ^Space e
-│                             │              │
-└─────────────────────────────┴──────────────┘
-   the agents that build it       the agent
-   claude / codex / your own      you built
+┌──────────────┬──────────────┬──────────────┐
+│ 1 CLAUDE     │ 2 CODEX      │ 3 SHELL      │
+│              │              │              │
+│              │              │              │
+└──────────────┴──────────────┴──────────────┘
 ```
 
-**Left: the agents that build.** Claude Code, Codex, or whatever CLI you use,
-stacked and kept at equal height. One variable points them at your agent, so
-nothing here knows or cares which one you run.
-
-**Right: the agent you built.** Once your own agent has a chat command, that
-pane is it: you talk to the thing you have been building, in the same window you
-built it in, and it does the work. No dashboard to stand up, no Slack app to
-register, no browser tab. If it runs in a terminal, it belongs in that pane.
+`office on` opens ONE pane that asks what it should be: any `OFFICE_AGENTS`
+entry, a shell, or the file editor. `Ctrl-Space n` asks the same question for
+every pane after that, and the grid re-fits itself — three across at most, two
+down, six in all. Park a pane with `Ctrl-Space x` and it keeps running, listed
+at the top of that same menu as `back: <label>`; drag a pane's title onto
+another to move it there; the rest shift along.
 
 Closing the window kills nothing: `office on` puts you back exactly where you
-were, panes, layout and all.
+were, panes and all.
 
 > **New to running an agent in the terminal?**
 > Start with **[GETTING-STARTED.md](GETTING-STARTED.md)**: what each pane is,
@@ -63,27 +54,22 @@ idea which one was stuck. Every window looked equally busy, so finding the one
 waiting on you meant reading all four, then doing it again five minutes later.
 That last part is why this exists. The window is the easy half.
 
-| 4 | 20s | 0 |
+| 6 | 20s | 0 |
 |---|---|---|
-| agents in one window, each in its own git worktree | before a desk that has stopped says so on its border | daemons, config files and dashboards to stand up |
-
-Four is the cap because a fifth session in a fifty-row window gets about nine
-rows, which is a slit and not a desk. Twenty seconds is the default and it is
-one variable. Four agents you can keep track of is a different tool from four
-agents in four windows.
-
-That is the first half of what this fixes. The second half is what you do with
-those agents. People building an agent of their own hit the same wall every
-time: the thing works in a terminal, and then they lose a week standing up a
-dashboard or wiring a Slack app just to talk to it. The chat pane is that,
-already built. Point it at your agent and it is a place to give it work.
-
-So the shape is: **agents on the left writing the code, the agent you built on
-the right doing the work.** One window, one command, and no web app in the
-middle. It is one zsh file, one tmux config and three small helpers, about 2,100
-lines all in, plus seven probes that drive a real tmux server to check it. No
-daemon, no plugin manager, no config file, and one `git fetch` you can switch
-off.
+| panes in one window — agents, shells, the file editor — three across at most | before a desk that has stopped says so on its border | daemons, config files and dashboards to stand up |
+
+Six is the cap, three across and two down, because past that a pane is a slit
+and not a desk. Twenty seconds is the default wait and it is one variable.
+Several agents you can keep track of is a different tool from several agents in
+several windows.
+
+So the shape is: **several coding agents side by side, each in its own
+worktree, plus the shells and the file editor you check their work in — one
+window, one command, "your turn" and how full each one's context is on every
+border.** No web app in the middle. It is one zsh file, one tmux config and
+three small helpers, about 2,100 lines all in, plus nine probes that drive a
+real tmux server to check it. No daemon, no plugin manager, no config file, and
+one `git fetch` you can switch off.
 
 ## Setup
 
@@ -170,58 +156,48 @@ you were coming back to is worse than a full disk.
 
 ## The keys
 
-| | |
-|---|---|
-| `⇧←↑↓→` | move between panes |
-
-Everything else is **`Ctrl-Space`, then one letter**:
+Five things you can do to a pane, and nothing else:
 
 | | |
 |---|---|
-| `n` | new session, in its own git worktree |
-| `c` `s` `e` | toggle chat / shell / file editor. On a pane that quit whatever it was running, the same key restarts it |
-| `a` | park every session, bring them all back, or open one if there are none |
-| `q` | close this pane. A menu: click it, or `c` to close and `k` or Escape to keep |
-| `x` | park this pane. Still running, `office show` brings it back |
-| `z` | zoom this pane full screen, and back |
-| arrows | move, and the only way out of a file you have open |
-
-
-Two rules, and the second covers everything. Movement is a chord because it is
-what you do most and arrows carry their modifier natively; every action is the
-prefix, which is the tmux convention and needs **no terminal configuration on
-any platform**. **One action, one key** — there is no second way to close a
-pane or move between them, because a scheme with synonyms is one you have to
-read twice to learn once. The mouse works too: click a pane to focus it, drag a
-border to resize, and **drag across text to copy it** — it is on the system
-clipboard the moment you let go, in the shell and in the file editor both. It
-stays that way until `office off`.
+| `⇧←↑↓→` | move between panes |
+| `Ctrl-Space` `n` | one more pane: a menu — parked panes, every agent, shell, file editor |
+| `Ctrl-Space` `x` | park this pane. Still running; `Ctrl-Space n` lists it to bring back |
+| `Ctrl-Space` `q` | close this pane. A menu: click it, or `c` to close and `k` or Escape to keep |
+| `Ctrl-Space` `z` | zoom this pane full screen, and back |
+| drag a pane's title onto another | it moves there, the rest shift along |
+
+Movement is a chord because it is what you do most and arrows carry their
+modifier natively; every other action is the prefix, which is the tmux
+convention and needs **no terminal configuration on any platform**. **One
+action, one key** — there is no second way to close a pane or move between
+them, because a scheme with synonyms is one you have to read twice to learn
+once. The mouse works too: click a pane to focus it, and **drag across text to
+copy it** — it is on the system clipboard the moment you let go, in the shell
+and in the file editor both. Dragging a *border* no longer resizes: the grid
+puts every size back on the next change anyway, so that gesture moves a pane
+instead.
 
 ### The keys are on the status bar
 
-A pane's border carries the key that toggles it, which is no help at all once
-the pane is closed and the border went with it. So the bar carries the whole
-set:
+The bar carries the whole set, and it updates the instant a pane opens, closes,
+parks or comes back — `office` writes it into a tmux option rather than the
+status bar polling a command, which would always be one interval behind:
 
 ```
-^Space then  │  n new  sessions a · shell s · editor e · chat c
-               ^^^^^^^^ dim = open            lit = closed ^^^^
+^Space │ n new (2 parked) │ x park │ q close │ z zoom │ ⇧←↑↓→ move · drag a title to reorder
 ```
 
-It updates the instant a pane opens or closes, because `office` writes it into
-a tmux option rather than the status bar polling a command. A polled job is
-always one interval behind the thing it describes.
-
-Brightness means one thing and one thing only: **lit means that pane is
-closed**, so the thing standing out is the thing you cannot find. `new` sits
-behind a divider because it is an action rather than a state. Clicking the
-strip opens a new session.
+`^Space` lights up while you are holding the prefix, `(N parked)` only shows
+when something is, and `z zoom` becomes `z unzoom` and lights up while a pane
+*is* zoomed — every other pane is hidden then, so the way back says so itself.
+Clicking the strip opens the same menu as `Ctrl-Space n`.
 
 It ships with the optional theme, or take it on its own:
 
 ```tmux
-set -g status-left "#{@office_bar} "
-set -g status-left-length 70
+set -g status-left "#{E:@office_bar} "
+set -g status-left-length 120
 ```
 
 ### Which one is waiting on you
@@ -373,12 +349,23 @@ select-to-copy; and even where it worked it was slow, because tmux cannot fire a
 double-click until the triple-click window has passed, and that wait is not
 tunable. A key that works in every pane and answers instantly wins.
 
+### Moving a pane: drag its title
+
+Needs tmux 3.7 or newer. Older tmux sends no event for a press on a title.
+
+Press on a pane's title line, drag, and let go over another pane: it moves
+there, and the panes in between shift along to make room. The cost, on purpose,
+is that dragging a *border* no longer resizes it — tmux cannot tell the two
+gestures apart by coordinates alone, only one can win, and the grid puts every
+size back on the next change regardless. `Ctrl-Space z` gives a pane the whole
+window when you need more room than the grid gives it.
 
 ## Park versus close
 
-`Ctrl-Space x` parks a pane: it is moved to a hidden tmux session and keeps running.
-Its own toggle brings it back, in its proper place, or `office show` picks from
-everything parked.
+`Ctrl-Space x` parks a pane: it is moved to a hidden tmux session and keeps
+running. `Ctrl-Space n` lists it at the top of the menu as `back: <label>` —
+pick it and it rejoins the grid — or `office show` fuzzy-picks from everything
+parked.
 
 `Ctrl-Space q` closes a pane for good. Parking is not free, a parked agent session
 still holds its 400 to 700MB, and `office doctor` lists parked panes alongside
@@ -395,15 +382,16 @@ live ones for exactly that reason.
 | `office <name>` | open another repo by fuzzy name |
 | `office pick` | fuzzy-pick from every repo under `$CODE_ROOT` |
 | `office solo` | like `on`, but starts nothing: the panes and nothing in them |
-| `office new [wt]` | one more session in its own git worktree — `Ctrl-Space n`. A free one, or a new `desk-N`, or the worktree you name, created if it is not there yet |
+| `office new` | one more pane — `Ctrl-Space n`: a menu of parked panes, every agent, a shell and the file editor |
+| `office new [wt]` | skip the menu: agent 1, in worktree `wt` — a free one, an existing one, or a new `desk-N`, created if it is not there yet |
+| `office new --agent <a> [wt]` | skip the menu: that agent (label or number), in worktree `wt` if named |
+| `office new --shell` / `office new --edit` | skip the menu: straight to a shell pane / the file editor |
 | `office task <what>` | one more session, already working on `<what>` |
 | `office desk` | one more session in THIS checkout, when you mean it |
-| `office chat` `shell` `edit` | toggle a right-strip pane |
-| `office sessions` | park or restore the whole left column |
-| `office renumber` | renumber the panes and redraw the key bar (every office command that changes the panes already does) |
+| `office renumber` / `office grid` | rebuild the grid and redraw the key bar (every office command that changes the panes already does this on its own) |
 | `office cd [x]` | walk the shell into another worktree — yours, or the one an agent is in. Checks nothing out; the file editor follows |
-| `office layout` | rebuild the layout when a pane ends up somewhere wrong |
-| `office hide` / `office show` | park the current pane / bring one back |
+| `office hide` | park the current pane — `Ctrl-Space x` |
+| `office show` | fuzzy-pick a parked pane and bring it back |
 | `office doctor` | what is running and what it costs in RAM, read-only |
 | `office clean` | pick panes to close, heaviest first (rarely needed) |
 | `office sweep [h]` | close offices you walked away from, and everything in them |
@@ -416,40 +404,29 @@ The command is `office`. `ao` and `o` are aliases for it.
 
 ## Bringing your own agent
 
-`office` does not know what Claude Code is. A session is a command and the chat
-pane is a command. Point them at yours.
-
-**The sessions** in the left column:
+`office` does not know what Claude Code is. A session is a command, and that is
+the whole integration. Point it at yours:
 
 ```sh
 OFFICE_SESSION_CMD="my-agent"        # whatever you type to start it
 OFFICE_SESSION_LABEL="MY AGENT"      # what its panes are called
 ```
 
-That is the whole integration. `Ctrl-Space n` opens one. `office task <what>`
-opens one already working
-on a task, by running `$OFFICE_SESSION_CMD "<your task>"`, so that one needs an
-agent that takes a prompt as its first argument. If yours does not, `Ctrl-Space n` still
-works and you type the task into the pane.
+`Ctrl-Space n` offers it in the menu. `office task <what>` opens one already
+working on a task, by running `$OFFICE_SESSION_CMD "<your task>"`, so that one
+needs an agent that takes a prompt as its first argument. If yours does not,
+`Ctrl-Space n` still works and you type the task into the pane.
 
-**The chat pane** is separate, and it is for the conversational side of your
-agent rather than a coding session. Three shapes cover almost everything:
+**Want to talk to an agent you built, not just a coding one?** It is not a
+separate kind of pane any more — it is just one more entry:
 
 ```sh
-# 1. your agent has a REPL
-OFFICE_CHAT_CMD="my-agent chat"
-
-# 2. your agent writes a log and you want to watch it live
-OFFICE_CHAT_CMD="sh -c 'tail -f ~/.my-agent/stream.log'"
-
-# 3. a stream to watch AND a prompt to type at, in one pane
-OFFICE_CHAT_CMD="sh -c 'tail -f ~/.my-agent/stream.log & while read -r q; do my-agent ask \"$q\"; done'"
-OFFICE_CHAT_LABEL="MY AGENT"
+OFFICE_AGENTS+=("MYAGENT my-agent chat")
 ```
 
-Shape 3 is what a streaming chat actually is: something following the output in
-the background, and a loop reading your input. Anything that behaves like a
-terminal program works, because the pane is a terminal and nothing more.
+`Ctrl-Space n` lists it next to your coding agent, a shell and the file editor.
+Anything that behaves like a terminal program works, because the pane is a
+terminal and nothing more.
 
 Put those lines in your `.zshrc` **above** the `source .../office.zsh` line,
 then `office off` and `office on`.
@@ -464,32 +441,19 @@ Environment variables, set before sourcing `office.zsh`. All optional.
 | `CODE_ROOT` | `~/code` | where `office pick` looks for repos |
 | `OFFICE_SESSION_CMD` | `claude` | **what a session is.** Any agent CLI |
 | `OFFICE_SESSION_LABEL` | `CLAUDE` | what its panes are called |
-| `OFFICE_AGENTS` | *(built from the two above)* | an array of desks to choose between — `"LABEL command words..."` per element. One entry: no change. Two or more: `Ctrl-Space n` asks which |
+| `OFFICE_AGENTS` | *(built from the two above)* | an array of desks to offer in the `Ctrl-Space n` menu — `"LABEL command words..."` per element |
 | `OFFICE_WORKTREE_DIR` | `.claude/worktrees` | where `office new` looks for worktrees, and puts the ones it creates |
 | `OFFICE_EDITOR` | `$EDITOR`, else micro/nano/vi | what the editor pane opens files in. Set it to `micro` if `$EDITOR` is vim and you would rather it were not |
-| `OFFICE_DEFAULT_DESKS` | `1` | sessions opened at startup |
-| `OFFICE_STRIP_WIDTH` | `32` | percent of the window the right strip takes |
 | `OFFICE_REAP_HOURS` | `12` | parked panes older than this are closed on `office on` |
 | `OFFICE_ATTN_SECS` | `20` | how long a desk sits still before its border says **your turn** |
 | `OFFICE_CTX_WARN` | `400000` | context tokens at which a desk's number takes the accent colour |
 | `OFFICE_CTX_ALARM` | `600000` | ...and the alarm colour. Use `120000` / `170000` for a 200k window |
 | `OFFICE_UPDATE_CHECK` | `1` | `0` stops the background `git fetch` on `office on`. The only network call there is |
-| `OFFICE_CHAT_LABEL` | `AGENT CHAT` | name on the chat pane's border |
-| `OFFICE_CHAT_CMD` | your shell | what the chat pane runs |
-| `OFFICE_CHAT_OPEN` | on once `OFFICE_CHAT_CMD` is set | whether the chat pane opens at startup |
 | `OFFICE_ON_CMD` | *(empty)* | your own command, run when you walk in |
 | `OFFICE_OFF_CMD` | *(empty)* | your own command, run when you go home |
 | `OFFICE_RUNNING_CHECK` | `false` | exits 0 when it is already up |
 | `OFFICE_ON_ALWAYS` | `0` | `1` runs `OFFICE_ON_CMD` every walk-in, even when the check says up |
 
-The chat pane is the interesting one. Point `OFFICE_CHAT_CMD` at whatever
-talking to your agent looks like for you, and that becomes the pane:
-
-```sh
-OFFICE_CHAT_LABEL="ASK"
-OFFICE_CHAT_CMD="zsh -ic my-agent-chat"
-```
-
 The always-on trio is for anything that should come up when you sit down and go
 down when you leave, a local server, a tunnel, a sync daemon:
 
@@ -525,19 +489,18 @@ Nothing here ever needs a reboot. In rough order of how often you will want them
 | changed a setting, want it live | `Ctrl-Space r`, or `tmux source-file ~/.tmux.conf` |
 | one pane's keys do nothing, the arrows walk a cursor around, the others are fine | it scrolled into copy-mode. **Click in it, or press Escape.** Until 2026-08-15 only `q` did that and nothing on screen said so, so the pane read as dead |
 | Shift-Enter submits instead of making a line break, and does the right thing outside the office | an old `office.tmux.conf`. `office update`, then `Ctrl-Space r`. tmux drops the modifier on any key ASCII has no byte for unless it is told not to; the office tells it |
-| changed `OFFICE_CHAT_CMD`, the pane is unchanged | close it with `Ctrl-Space q`, reopen with `Ctrl-Space c` |
 | `Ctrl-Space w` does nothing | `w` is gone: it is `Ctrl-Space q` now, and it is the only close key |
-| need an image in a task | `Ctrl-Space n`, then paste into your agent's own prompt |
-| the columns look scrambled | `office layout` |
-| the file editor pane is just a shell prompt | you left the file list. `Ctrl-Space e` rebuilds it |
-| the chat pane quit and left a prompt | `Ctrl-Space c` restarts it |
+| need an image in a task | `Ctrl-Space n`, pick your agent, then paste into its own prompt |
+| a pane ended up in the wrong cell | it fixes itself on the next add, park, unpark or close — or run `office renumber` (`office grid`) now |
+| the file editor pane is just a shell prompt | you left the file list. `Ctrl-Space n`, then **file editor** brings it back |
 | a pane went red with `returned 1` | it is in a mode. Any office key now cancels it, or press `q` |
 | everything is wedged | `office off`, then `office on`. That resets the layout completely |
 
-**A parked or toggled pane keeps its old process.** After changing what a pane
-*runs*, close it with `Ctrl-Space q` and reopen it rather than toggling it off and on.
-The one exception is a pane that has *stopped* running it: its own key restarts it
-instead of hiding it, so there is no way to end up with a pane you cannot revive.
+**A parked pane keeps its old process.** Parking and bringing a pane back does
+not restart whatever is running in it — it never stopped. After changing what a
+pane *runs* (editing `OFFICE_AGENTS`, say), close it with `Ctrl-Space q` and
+open a fresh one with `Ctrl-Space n` rather than expecting a parked one to pick
+up the change.
 
 **If a key does nothing, it is not your terminal.** Nothing office binds needs
 terminal support beyond `Shift+arrow` and `Ctrl-Space`. Reload with
@@ -546,24 +509,25 @@ not re-read the config: `tmux source-file ~/.tmux.conf`.
 
 ## Details worth knowing
 
-**Desk 1 is the checkout you opened. Every extra desk gets its own worktree.**
-`Ctrl-Space n` takes a free worktree under `.claude/worktrees/` — nobody
-sitting in it, nothing uncommitted, nothing on its branch that has not landed
-in the default branch — or makes `desk-2`, `desk-3` when there is none. "Landed"
-is asked by merging the branch in memory and comparing trees, not by ancestry,
-so a **squash-merged** branch reads as finished instead of unfinished forever.
-Anything git cannot answer means "not free", and you get a new worktree rather
-than an agent dropped into somebody's branch. That is the
-whole point of running several agents at once: they edit separate checkouts, so
-two of them cannot land on one branch and commit over each other. When git
-cannot give one (not a repo, no commit to branch from) the session still opens,
-in the checkout you are in, and the status line says so. `office desk` is that
-on purpose, and says it too.
+**The first agent works in the checkout you opened. Every one after it gets its
+own worktree.** Picking an agent from `Ctrl-Space n` takes a free worktree under
+`.claude/worktrees/` — nobody sitting in it, nothing uncommitted, nothing on
+its branch that has not landed in the default branch — or makes `desk-2`,
+`desk-3` when there is none. "Landed" is asked by merging the branch in memory
+and comparing trees, not by ancestry, so a **squash-merged** branch reads as
+finished instead of unfinished forever. Anything git cannot answer means "not
+free", and you get a new worktree rather than an agent dropped into somebody's
+branch. That is the whole point of running several agents at once: they edit
+separate checkouts, so two of them cannot land on one branch and commit over
+each other. When git cannot give one (not a repo, no commit to branch from) the
+agent still opens, in the checkout you are in, and the status line says so.
+`office desk` is that on purpose, and says it too.
 
 **Pane numbers are ours, not tmux's.** tmux numbers panes by their position in
 the layout tree, which moving a pane leaves in an order your eye disagrees with
-(you get 4 = FILE EDITOR, 6 = AGENT). `office` numbers them from actual geometry, so
-they always read down the left column and then down the right strip.
+(you get 4 = FILE EDITOR, 6 = AGENT). `office` numbers them from actual
+geometry, so they always read like a page: the top row left to right, then the
+row below.
 
 **Pane borders stay quiet.** A border shows the pane's number, what it is, the
 key that acts on it, and what it is currently doing, but only when that last one
@@ -581,12 +545,13 @@ the pane looks frozen (often with a red `returned 1` line). Every office
 keybinding exits non-zero-proof now, and the movement, zoom, close and park
 keys all cancel the mode first, so there is always a way out.
 
-**A missing column rebuilds itself.** Park every session, or every glance pane,
-and tmux collapses the two-column layout: from then on the leftmost and
-rightmost pane are the same one, and everything coming back lands in a single
-tall stack. Only a window with one pane can be split into two root-level
-columns, so when the shape is wrong `office` breaks the panes out, keeps one,
-and re-joins them in order. `office layout` does it on demand.
+**The grid rebuilds itself, every time.** Add a pane, park one, bring one back,
+close one, drag one somewhere else — `office` recomputes the whole layout as
+one string (the top row first, three across at most, two down at most, six in
+all) and hands it to
+tmux in a single call, rather than nudging borders. A border you dragged snaps
+back the moment the office next changes shape. `office renumber` (`office
+grid`) runs it by hand, for the rare case nothing else triggered it.
 
 **Pane labels are derived, not trusted.** Claude Code can move a conversation
 to the background and swap which pane displays the agent list. A label pinned
@@ -688,12 +653,11 @@ OFFICE_AGENTS=(
 ```
 
 (`ollama launch claude --model <m>` runs Claude Code on a local Ollama model;
-`ollama launch codex` does the same for Codex.) One entry and nothing changes:
-`Ctrl-Space n` still opens it directly. Two or more, and it asks which with a
-menu — `office new --agent 2` or `office new --agent CODEX` skips straight to
-one. Every other door that opens a desk (`office desk`, `office task`, the
-startup desks, the `sessions` refill) always takes the first entry; the menu
-is `Ctrl-Space n` alone.
+`ollama launch codex` does the same for Codex.) `Ctrl-Space n` always shows the
+menu now — one agent, or several, plus a shell and the file editor — and
+`office new --agent 2` or `office new --agent CODEX` skips straight to one, in
+its own worktree. `office desk` and `office task` always take the first entry;
+the menu is `Ctrl-Space n` alone.
 
 There is deliberately no integration with any one agent's own session manager.
 An office pane is a terminal running your agent, and that is the whole
@@ -840,7 +804,7 @@ adds a command is worth an issue first, so you do not build something that turns
 out to be out of scope.
 
 There are no unit tests, because almost everything here is a side effect on a
-live tmux server. What there is instead is seven probes in `bin/` that drive a
+live tmux server. What there is instead is nine probes in `bin/` that drive a
 real one, attach real clients on a pty and type raw bytes at them; CI runs every
 one of them on macOS and Ubuntu, on tmux 3.7b and 3.4, on every push. For
 anything a probe does not cover, say how you verified it: build a throwaway
diff --git a/bin/agent-probe b/bin/agent-probe
index b80f036..ee0dcac 100755
--- a/bin/agent-probe
+++ b/bin/agent-probe
@@ -1,7 +1,7 @@
 #!/usr/bin/env zsh
-# agent-probe — OFFICE_AGENTS: one is invisible, several ask which.
+# agent-probe — OFFICE_AGENTS: every entry is on the list, and a pick runs that one.
 #
-# Run it after ANY change to OFFICE_AGENTS, _office_new or _office_agent_menu.
+# Run it after ANY change to OFFICE_AGENTS, _office_new or _office_menu.
 # It builds a throwaway office on its own tmux server and drives `office new`
 # directly, the same call `bind n` makes.
 #
@@ -9,14 +9,12 @@
 #
 # What it is looking for:
 #
-#   - one agent (the default, built from OFFICE_SESSION_CMD/_LABEL): Ctrl-Space
-#     n opens a desk directly, running that command under that label. No menu,
-#     ever — this is the case every existing .zshrc is in today, and it must
-#     stay indistinguishable from before this feature existed.
-#   - 2+ agents and none named: opens NOTHING. There is no attached client on
-#     this throwaway server, which is deliberate — display-menu cannot be made
-#     to draw headless, so this is also the proof that the no-agent path
-#     really does defer to the menu instead of falling back to agent 1 quietly.
+#   - one agent (the default, built from OFFICE_SESSION_CMD/_LABEL): a named
+#     worktree opens that agent, running that command under that label.
+#   - a bare `office new` opens NOTHING. There is no attached client on this
+#     throwaway server, which is deliberate — display-menu cannot be made to
+#     draw headless, so this is also the proof that the bare path really does
+#     defer to the menu instead of quietly opening agent 1.
 #   - `--agent 2` and `--agent <LABEL>` both resolve to the second entry's own
 #     command and label, whichever way it was named.
 emulate -L zsh
@@ -33,8 +31,7 @@ exec </dev/null
 export TMUX_TMPDIR=$(mktemp -d)        # its own server, never yours
 unset TMUX TMUX_PANE                     # inside a desk $TMUX outranks TMUX_TMPDIR: without this every tmux call below, cleanup included, reached YOUR office (2026-09-11)
 export OFFICE_SOLO=1
-export OFFICE_SESSION_CMD='exec zsh' OFFICE_CHAT_CMD='exec zsh' OFFICE_CHAT_OPEN=0
-export OFFICE_DEFAULT_DESKS=1
+export OFFICE_SESSION_CMD='exec zsh'
 repo=$(mktemp -d)/probe; mkdir -p "$repo"; git -C "$repo" init -q
 # `office new <name>` branches a new worktree off HEAD, which needs a real
 # commit to branch from -- an empty repo has none.
@@ -58,6 +55,9 @@ want() { [[ $2 == $3 ]] && ok "$1" || bad "$1: got '$2', wanted '$3'" }
 cd "$repo"
 _office_open "$repo" >/dev/null 2>&1
 s=$(_office_sessname "$repo")
+# the office opens as one pane that asks; answer it, so every count below is a
+# pane ADDED and not the question's cell being filled
+office new --shell >/dev/null 2>&1
 sleep 1
 
 panes()   { tmux list-panes -t "=$s" -F '#{pane_id}' 2>/dev/null | wc -l | tr -d ' ' }
@@ -81,12 +81,12 @@ p=$(newest)
   || bad "one agent: it runs OFFICE_SESSION_CMD: got '$(cmd_of "$p")'"
 want "one agent: labeled with OFFICE_SESSION_LABEL" "$(label_of "$p")" "CLAUDE · wt-1"
 
-# --- 2+ agents, none named: the menu, never a silent default -----------------
+# --- a bare `office new`: the menu, never a silent default ---------------------
 OFFICE_AGENTS=("ONE printf ONE-RAN" "TWO printf TWO-RAN")
 before=$(panes)
-office new wt-2 >/dev/null 2>&1
+office new >/dev/null 2>&1
 sleep 0.5
-want "2 agents, no --agent: opens nothing (no client to ask)" "$(panes)" $before
+want "bare office new: opens nothing (no client to ask)" "$(panes)" $before
 
 # --- --agent by index ---------------------------------------------------------
 office new --agent 2 wt-3 >/dev/null 2>&1
diff --git a/bin/attn-probe b/bin/attn-probe
index 561231f..2d2e46d 100755
--- a/bin/attn-probe
+++ b/bin/attn-probe
@@ -37,8 +37,7 @@ emulate -L zsh
 export TMUX_TMPDIR=$(mktemp -d)        # its own server, never yours
 unset TMUX TMUX_PANE                     # inside a desk $TMUX outranks TMUX_TMPDIR: without this every tmux call below, cleanup included, reached YOUR office (2026-09-11)
 export OFFICE_SOLO=1
-export OFFICE_SESSION_CMD='exec zsh' OFFICE_CHAT_CMD='exec zsh' OFFICE_CHAT_OPEN=0
-export OFFICE_DEFAULT_DESKS=2
+export OFFICE_SESSION_CMD='exec zsh'
 export OFFICE_ATTN_SECS=4              # the probe cannot wait 20s five times over
 repo=$(mktemp -d)/probe; mkdir -p "$repo"; git -C "$repo" init -q
 
@@ -54,6 +53,10 @@ fail=0
 cd "$repo"
 _office_open "$repo" >/dev/null 2>&1
 s=$(_office_sessname "$repo")
+# An office opens as ONE pane that asks. Pick what this probe needs, the way the
+# menu picks: two desks in this checkout, a shell and the file editor.
+office desk >/dev/null 2>&1; office desk >/dev/null 2>&1
+office new --shell >/dev/null 2>&1; office new --edit >/dev/null 2>&1
 # the config the office actually ships, on this server: the gate and the readout
 # are options in it, and half of what this probe checks is that expression.
 tmux source-file "$here/../office.tmux.conf" 2>/dev/null
diff --git a/bin/grid-probe b/bin/grid-probe
new file mode 100755
index 0000000..b6feb80
--- /dev/null
+++ b/bin/grid-probe
@@ -0,0 +1,154 @@
+#!/usr/bin/env zsh
+# grid-probe — one pane that asks, then a grid that fills the top row first: at most three across, two down.
+#
+# Run it after ANY change to the grid, adding, parking, moving or closing a pane.
+# It builds a throwaway office on its own tmux server and drives the same calls
+# the menu items and the key bindings make.
+#
+#     env -u TMUX bin/grid-probe
+#
+# The menu itself cannot be drawn headless (display-menu needs a client), so
+# every pick is made the way the menu makes it: `office new --agent N`,
+# `--shell`, `--edit`, `--back <window>`.
+emulate -L zsh
+# no err_return: every step is checked explicitly, and a probe that stops at the
+# first non-zero return stops inside the code it is testing.
+exec </dev/null
+
+export TMUX_TMPDIR=$(mktemp -d)        # its own server, never yours
+unset TMUX TMUX_PANE                     # inside a desk $TMUX outranks TMUX_TMPDIR: without this every tmux call below, cleanup included, reached YOUR office (2026-09-11)
+export OFFICE_SOLO=1
+export OFFICE_SESSION_CMD='exec zsh'
+repo=$(mktemp -d)/probe; mkdir -p "$repo"; git -C "$repo" init -q
+# the second agent gets a worktree, and a worktree needs a commit to branch from
+git -C "$repo" -c user.email=p@p -c user.name=probe commit -q --allow-empty -m init
+repo=${repo:A}
+
+here=${0:A:h}
+source "$here/../office.zsh"
+OFFICE_AGENTS=("ONE exec zsh" "TWO exec zsh")
+# nothing here may touch the machine it runs on: no attach, no update check,
+# no always-on stack, no ~/.tmux.conf.
+_office_attach(){ : }; _office_update_check(){ : }; _office_reap(){ : }
+_office_always_on_up(){ : }; _office_reload_conf(){ : }; _office_say(){ : }
+
+cleanup() { tmux kill-server 2>/dev/null; rm -rf "$TMUX_TMPDIR" "${repo:h}" }
+trap cleanup EXIT INT TERM
+
+fail=0
+ok()   { print "  ok   $1" }
+bad()  { print -u2 "  FAIL $1"; fail=1 }
+want() { [[ $2 == $3 ]] && ok "$1" || bad "$1: got '$2', wanted '$3'" }
+
+cd "$repo"
+_office_open "$repo" >/dev/null 2>&1
+s=$(_office_sessname "$repo")
+# the shipped config on this server: the close hook lives there
+tmux source-file "$here/../office.tmux.conf" 2>/dev/null
+tmux resize-window -t "$s:" -x 200 -y 50 2>/dev/null
+sleep 0.5
+
+panes() { tmux list-panes -t "=$s" -F '#{pane_id}' 2>/dev/null | wc -l | tr -d ' ' }
+kinds() { tmux list-panes -t "=$s" -F '#{@office_kind}' 2>/dev/null | tr '\n' ' ' }
+ids()   { tmux list-panes -t "=$s" -F '#{pane_id}' 2>/dev/null | tr '\n' ' ' }
+of()    { tmux list-panes -t "=$s" -F '#{@office_kind} #{pane_id}' | awk -v k="$1" '$1==k {p=$2} END {print p}' }
+# The whole contract, in one place: <what> <panes>. Rows are counted from real
+# geometry, and every pane in a row must be the same width give or take the one
+# cell an odd split leaves over.
+# The grid fills the TOP row first, and the top row takes the odd pane: three
+# panes are "2 1", five are "3 2", never "1 2" or "2 3". That per-row count is
+# the fingerprint a close without the re-fit gets wrong while every total adds up.
+shape() {
+  local what=$1 n=$2 geo spread fill want
+  geo=$(tmux list-panes -t "=$s" -F '#{pane_left} #{pane_top} #{pane_width}' 2>/dev/null)
+  fill=$(print -r -- "$geo" | awk '{n[$2]++} END {for (t in n) print t, n[t]}' | sort -n | awk '{printf "%s ", $2}')
+  (( n <= 2 )) && want="$n " || want="$(( (n + 1) / 2 )) $(( n / 2 )) "
+  spread=$(print -r -- "$geo" | awk '!($2 in lo) {lo[$2]=$3; hi[$2]=$3} {if ($3<lo[$2]) lo[$2]=$3; if ($3>hi[$2]) hi[$2]=$3} END {m=0; for (t in lo) if (hi[t]-lo[t]>m) m=hi[t]-lo[t]; print m}')
+  if [[ $(panes) == $n && $fill == $want ]] && (( spread <= 1 )) \
+     && [[ $(tmux list-windows -t "=$s" -F '#{window_zoomed_flag}' | head -1) == 0 ]]; then
+    ok "$what"
+  else
+    bad "$what: $(panes) panes, rows filled '$fill', widths in a row spread $spread (wanted $n, '$want')"
+    print -r -- "$geo" | sed 's/^/        /' >&2
+  fi
+}
+
+# --- walking in: ONE pane, and it is the question ----------------------------
+want "office opens as one pane" "$(panes)" 1
+want "...and that pane is the question" "$(kinds)" "NEW "
+
+# --- the first agent takes its cell, in the checkout --------------------------
+office new --agent 1 >/dev/null 2>&1; sleep 0.3
+want "a pick replaces the question, it does not add beside it" "$(kinds)" "CLAUDE "
+want "the first agent works in the checkout" \
+  "$(tmux display -p -t "$(of CLAUDE)" '#{pane_start_path}')" "$repo"
+
+# --- the second agent gets its OWN worktree, side by side ----------------------
+office new --agent TWO >/dev/null 2>&1; sleep 0.3
+p=$(of CLAUDE)
+want "the second agent is labelled with its worktree" "$(tmux show -p -t "$p" -qv @office_label)" "TWO · desk-2"
+want "...and works in it" "$(tmux display -p -t "$p" '#{pane_start_path}')" "$repo/.claude/worktrees/desk-2"
+shape "2 panes: side by side" 2
+
+office new --shell >/dev/null 2>&1; sleep 0.3
+shape "3 panes: two on top, the third underneath" 3
+office new --edit >/dev/null 2>&1; sleep 0.3
+shape "4 panes: two by two" 4
+office new --shell >/dev/null 2>&1; sleep 0.3
+shape "5 panes: three on top, two underneath" 5
+office new --shell >/dev/null 2>&1; sleep 0.3
+shape "6 panes: three by two" 6
+office new --shell >/dev/null 2>&1; sleep 0.3
+shape "a 7th is refused: six is the cap" 6
+
+# --- parking: out of the grid, still running, on the list ---------------------
+ed=$(of EDITOR)
+office hide "$ed" >/dev/null 2>&1; sleep 0.3
+shape "parking one re-fits the grid" 5
+want "the parked pane is on this office's list" "$(_office_parked "$s" | wc -l | tr -d ' ')" 1
+want "...under its own label" "$(_office_parked "$s" | cut -f2)" "FILE EDITOR"
+[[ $(tmux show -t "$s" -qv @office_bar) == *"(1 parked)"* ]] \
+  && ok "the bar counts it" || bad "the bar counts it: '$(tmux show -t "$s" -qv @office_bar)'"
+[[ -n $(tmux display -p -t "$ed" '#{pane_pid}' 2>/dev/null) ]] \
+  && ok "...and it is still running" || bad "...and it is still running"
+office new --back "$(_office_parked "$s" | cut -f1)" >/dev/null 2>&1; sleep 0.3
+shape "bringing it back re-fits the grid" 6
+want "...and it is off the list" "$(_office_parked "$s" | wc -l | tr -d ' ')" 0
+
+# --- moving: the pane goes where it was dropped, the rest shift along ---------
+local -a before; before=(${=$(ids)})
+_office_move "${before[1]}" "${before[4]}" >/dev/null 2>&1; sleep 0.3
+want "dropping pane 1 on pane 4 moves it to 4" "$(ids)" "${before[2]} ${before[3]} ${before[4]} ${before[1]} ${before[5]} ${before[6]} "
+shape "...and the grid holds" 6
+_office_move "${before[1]}" "${before[2]}" >/dev/null 2>&1; sleep 0.3
+want "dropping it back on pane 1 undoes it" "$(ids)" "${(j: :)before} "
+
+# --- closing: the config's hook re-fits the grid -------------------------------
+tmux kill-pane -t "${before[3]}"; sleep 1.5
+shape "a close re-fits the grid (the after-kill-pane hook)" 5
+
+# ...and so does a pane whose own command ends (pane-exited, not a kill)
+local -a now; now=(${=$(ids)})
+tmux respawn-pane -k -t "${now[1]}" 'exit 0'; sleep 1.5
+shape "a pane that exits on its own re-fits the grid (the pane-exited hook)" 4
+
+# --- zoom lies about geometry; an office command drops it first ---------------
+# a pane that is still here: before[1] was the one the exit above just ended
+now=(${=$(ids)}); tmux resize-pane -Z -t "${now[1]}"
+want "...zoomed first, or the next check proves nothing" \
+  "$(tmux list-windows -t "=$s" -F '#{window_zoomed_flag}' | head -1)" 1
+office renumber >/dev/null 2>&1; sleep 0.3
+shape "a zoomed office comes back as a grid" 4
+
+# --- parking the last pane never closes the office ----------------------------
+for p in ${=$(ids)}; do office hide "$p" >/dev/null 2>&1; sleep 0.2; done
+want "parking everything leaves the question, not an empty office" "$(kinds)" "NEW "
+want "...and everything parked is on the list" "$(_office_parked "$s" | wc -l | tr -d ' ')" 4
+office hide "$(of NEW)" >/dev/null 2>&1; sleep 0.2
+want "the question pane itself is never parked" "$(kinds)" "NEW "
+want "...so it never lands on the list" "$(_office_parked "$s" | wc -l | tr -d ' ')" 4
+office new --back "$(_office_parked "$s" | head -1 | cut -f1)" >/dev/null 2>&1; sleep 0.3
+want "bringing one back takes the question's cell" "$(panes)" 1
+
+(( fail )) && { print -u2 "\ngrid-probe FAILED"; exit 1 }
+print "\ngrid-probe passed"
diff --git a/bin/menu-probe b/bin/menu-probe
new file mode 100755
index 0000000..99c3b1a
--- /dev/null
+++ b/bin/menu-probe
@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Walk into an office with a real client attached. Does the first pane ask on
+its own, and do the menu's keys do what they say?
+
+Run it after ANY change to _office_open, _office_wait, _office_menu, parking,
+or the n / x bindings. It opens a throwaway office on its own tmux server, from
+a pty that attaches a real client, and types at it the way a hand does:
+
+  - the office opens as ONE pane, and its menu draws by itself
+  - 1 turns that pane into the first OFFICE_AGENTS entry (it does not add one)
+  - Ctrl-Space n, then s, adds a shell beside it
+  - Ctrl-Space x parks the shell, and the next menu lists it under a letter
+    that brings it back
+
+    env -u TMUX bin/menu-probe
+
+grid-probe drives the same code headless, but it cannot draw a menu: that needs
+a client, which is the one thing only this probe has.
+"""
+import fcntl, os, pathlib, pty, select, shutil, struct, subprocess, sys, tempfile, termios, time
+
+HOME = pathlib.Path(__file__).resolve().parent.parent
+tmp = pathlib.Path(tempfile.mkdtemp())
+(tmp / "sock").mkdir()
+(tmp / "zd").mkdir()
+repo = tmp / "repo"
+repo.mkdir()
+subprocess.run(["git", "init", "-q", str(repo)], check=True)
+subprocess.run(["git", "-C", str(repo), "-c", "user.email=p@p", "-c", "user.name=p",
+                "commit", "-q", "--allow-empty", "-m", "init"], check=True)
+# Every menu item runs `zsh -ic 'office new ...'`, so the package has to come from
+# an rc file. A throwaway ZDOTDIR is that rc, pointed at THIS checkout — never
+# the machine's own ~/.zshrc, which may source a different copy of office.
+(tmp / "zd" / ".zshrc").write_text(
+    'OFFICE_AGENTS=("ONE sleep 61" "TWO sleep 62")\n'
+    "OFFICE_UPDATE_CHECK=0\n"
+    f'source "{HOME}/office.zsh"\n')
+# Debian and Ubuntu run compinit from /etc/zsh/zshrc, and on the GitHub Ubuntu
+# runner it stops at "insecure directories ... [y] or abort compinit [n]?". The
+# pane waited on that question, the probe's "1" answered it, and the menu came
+# up a step late for every check after (measured 2026-09-17). .zshenv is read
+# before /etc/zsh/zshrc, and this is the switch that file itself documents.
+(tmp / "zd" / ".zshenv").write_text("skip_global_compinit=1\n")
+env = {k: v for k, v in os.environ.items() if k not in ("TMUX", "TMUX_PANE")}
+env.update(TMUX_TMPDIR=str(tmp / "sock"), ZDOTDIR=str(tmp / "zd"),
+           TERM="xterm-256color", OFFICE_SOLO="1")
+
+
+def tmux(*a):
+    return subprocess.run(["tmux", *a], capture_output=True, text=True, env=env).stdout.strip()
+
+
+pid, fd = pty.fork()
+if pid == 0:
+    fcntl.ioctl(0, termios.TIOCSWINSZ, struct.pack("HHHH", 40, 160, 0, 0))
+    os.environ.clear()
+    os.environ.update(env)
+    # _office_open with only the config reload pointed at this checkout: the
+    # attach at its end is the real one, onto this pty.
+    os.execvp("zsh", ["zsh", "-fc",
+                      f'source "{HOME}/office.zsh"; '
+                      f'_office_reload_conf(){{ tmux source-file "{HOME}/office.tmux.conf" }}; '
+                      f'_office_open "{repo}"'])
+
+
+LAST = [b""]
+
+
+def drain(seconds, want=None):
+    """Keep the client's output flowing, or tmux blocks writing to it. With
+    `want`, return True as soon as those bytes have been drawn."""
+    seen = b""
+    end = time.time() + seconds
+    while time.time() < end:
+        if select.select([fd], [], [], 0.1)[0]:
+            try:
+                seen = (seen + os.read(fd, 65536))[-65536:]
+            except OSError:
+                return False
+            if want and want in seen:
+                return True
+    LAST[0] = seen
+    return False
+
+
+# Every step WAITS for what a hand would wait for, never a fixed number of
+# seconds: on the Ubuntu runner a pane's `zsh -ic` takes about eight seconds to
+# start (measured 2026-09-17), so a fixed 8s wait typed "1" at a pane whose menu
+# had not drawn yet, and every step after it was off by one.
+def menu():
+    """Wait for a menu to be on screen: its title is the word open. Not " open "
+    with its spaces: tmux may skip drawing a space over a cell that is blank."""
+    return drain(60, b"open")
+
+
+def until(test, seconds=60):
+    end = time.time() + seconds
+    while time.time() < end:
+        if test():
+            return True
+        drain(0.5)
+    return False
+
+
+def office():
+    """<kind> <start command> for every pane on screen in the office."""
+    out = tmux("list-panes", "-t", "=repo", "-F", "#{@office_kind} #{pane_start_command}")
+    return [line for line in out.splitlines() if line]
+
+
+def stash():
+    return tmux("list-panes", "-s", "-t", "=_stash", "-F", "#{@office_kind}")
+
+
+fails = []
+
+
+def check(name, ok, got):
+    print(f"  {'ok  ' if ok else 'FAIL'} {name}")
+    if not ok:
+        fails.append(f"{name}: {got}")
+
+
+try:
+    drew = menu()
+    panes = office()
+    check("the office opens as one pane, and it is the question",
+          len(panes) == 1 and panes[0].startswith("NEW "), panes)
+
+    check("the menu drew by itself", drew, f"no menu on screen after 60s; last bytes {LAST[0][-600:]!r}")
+    os.write(fd, b"1")
+    until(lambda: any(p.startswith("CLAUDE ") for p in office()))
+    panes = office()
+    check("1 made that pane agent ONE",
+          len(panes) == 1 and panes[0].startswith('CLAUDE "sleep 61'), panes)
+
+    os.write(fd, b"\x00n")  # Ctrl-Space is NUL
+    menu()
+    os.write(fd, b"s")
+    until(lambda: len(office()) == 2)
+    panes = office()
+    check("Ctrl-Space n, s adds a shell beside it",
+          len(panes) == 2 and any(p.startswith("SHELL ") for p in panes), panes)
+
+    os.write(fd, b"\x00x")  # the shell was focused when it opened
+    until(lambda: "SHELL" in stash())
+    panes = office()
+    check("Ctrl-Space x parks it, still running",
+          len(panes) == 1 and "SHELL" in stash(), (panes, stash()))
+
+    os.write(fd, b"\x00n")
+    menu()
+    os.write(fd, b"a")      # the first parked pane's key
+    until(lambda: "SHELL" not in stash())
+    panes = office()
+    check("the next menu lists it under a, and a brings it back",
+          len(panes) == 2 and "SHELL" not in stash(), (panes, stash()))
+finally:
+    tmux("kill-server")
+    shutil.rmtree(tmp, ignore_errors=True)
+
+if fails:
+    print("\n" + "\n".join(fails))
+    sys.exit(1)
+print("\nmenu-probe passed")
diff --git a/bin/mouse-probe b/bin/mouse-probe
index 4816b21..969423e 100755
--- a/bin/mouse-probe
+++ b/bin/mouse-probe
@@ -20,7 +20,7 @@ like a terminal that had died.
 it writes to the pane's tty and never consults a key table. Only real mouse
 bytes at a real client test what a hand does.
 """
-import os, pathlib, pty, subprocess, sys, tempfile, time
+import os, pathlib, pty, re, subprocess, sys, tempfile, time
 
 SOCK = "office-mouse-probe"
 CONF = pathlib.Path(__file__).resolve().parent.parent / "office.tmux.conf"
@@ -133,6 +133,69 @@ def main():
     press(DRAG)
     check("CLAUDE pane: the app gets the drag", "0", False)
 
+    # Drag a pane's TITLE onto another pane and it moves there. The drop runs
+    # office.zsh's _office_move, so the server has to know where the package is.
+    # tmux before 3.7 has no event for it: measured on 3.4, 3.5a and 3.6b, a
+    # press on a title sends nothing and the drag arrives as a plain
+    # MouseDrag1Pane with no coordinates, which a fast drag out of a pane body
+    # also sends. So there it stays a copy, and this block says it skipped.
+    ver = subprocess.run(["tmux", "-V"], capture_output=True, text=True).stdout.split()[-1]
+    if tuple(int(x) for x in re.findall(r"\d+", ver)[:2]) < (3, 7):
+        print(f"a title dragged onto another pane moves it there\n  SKIP tmux {ver}: needs 3.7")
+        return finish(fails)
+    print("a title dragged onto another pane moves it there")
+    tmux("set", "-g", "@office_home", str(CONF.parent))
+    tmux("new-window", "-n", "grid", "sleep 60")
+    tmux("split-window", "-h", "-t", "grid", "sleep 60")
+    tmux("split-window", "-h", "-t", "grid", "sleep 60")
+    tmux("select-layout", "-t", "grid", "even-horizontal")
+    tmux("set", "-w", "-t", "grid", "pane-border-status", "top")
+    time.sleep(0.5)
+
+    def panes():
+        out = tmux("list-panes", "-t", "grid", "-F", "#{pane_id} #{pane_left} #{pane_top}").stdout.split("\n")
+        return [line.split() for line in out if line]
+
+    def title(p):  # the 1-based cell on a pane's title line
+        return int(p[1]) + 3, int(p[2])
+
+    def body(p):
+        return int(p[1]) + 3, int(p[2]) + 3
+
+    def order():
+        return [p[0] for p in panes()]
+
+    def moved(name, want):
+        time.sleep(1.5)  # the drop runs a zsh in the background
+        got = order()
+        ok = got == want
+        print(f"  {'ok  ' if ok else 'FAIL'} {name}")
+        if not ok:
+            fails.append(f"{name}: order {got}, wanted {want}")
+
+    a, b, c = panes()
+    press(sgr(0, *title(b)) + sgr(0, *title(b), press=False))
+    moved("a click on a title moves nothing", [a[0], b[0], c[0]])
+    tx, ty = title(a)
+    bx, by = body(c)
+    press(sgr(0, tx, ty) + sgr(32, tx + 2, ty + 1) + sgr(32, bx, by) + sgr(0, bx, by, press=False))
+    moved("title of pane 1 dropped on pane 3: it is last now", [b[0], c[0], a[0]])
+    in_mode = [tmux("display", "-p", "-t", p, "#{pane_in_mode}").stdout.strip() for p in (a[0], b[0], c[0])]
+    ok = in_mode == ["0", "0", "0"]
+    print(f"  {'ok  ' if ok else 'FAIL'} ...and no pane was left in copy mode by the drag")
+    if not ok:
+        fails.append(f"a title drag left copy mode on: {in_mode}")
+    # a drag that started in a pane body is a copy, never a move
+    first = panes()
+    press(sgr(0, *body(first[0])) + sgr(32, body(first[2])[0], body(first[2])[1])
+          + sgr(0, *body(first[2]), press=False))
+    press(b"\x1b")
+    moved("a drag across pane bodies moves nothing", [p[0] for p in first])
+
+    finish(fails)
+
+
+def finish(fails):
     tmux("kill-server")
     if fails:
         print("\n" + "\n".join(fails))
diff --git a/bin/off-probe b/bin/off-probe
index d887423..a52a4b9 100755
--- a/bin/off-probe
+++ b/bin/off-probe
@@ -30,8 +30,7 @@ emulate -L zsh
 export TMUX_TMPDIR=$(mktemp -d)        # its own server, never yours
 unset TMUX TMUX_PANE                     # inside a desk $TMUX outranks TMUX_TMPDIR: without this every tmux call below, cleanup included, reached YOUR office (2026-09-11)
 export OFFICE_SOLO=1
-export OFFICE_SESSION_CMD='exec zsh' OFFICE_CHAT_CMD='exec zsh' OFFICE_CHAT_OPEN=0
-export OFFICE_DEFAULT_DESKS=1
+export OFFICE_SESSION_CMD='exec zsh'
 export OFFICE_ON_CMD='' OFFICE_OFF_CMD=''
 
 root=$(mktemp -d)
diff --git a/bin/office-attn b/bin/office-attn
index 6f07d14..d4e2c85 100755
--- a/bin/office-attn
+++ b/bin/office-attn
@@ -8,7 +8,7 @@
 #
 # What this deliberately does NOT do is know anything about the agent. No marker
 # to grep for, no hook to install, no per-CLI special case: office points the
-# left column at claude, codex or your own thing through one variable, and this
+# desks at claude, codex or your own thing through one variable, and this
 # has to keep being true for all of them. The one behaviour every agent CLI
 # shares is that it MOVES while it works — a spinner, an elapsed timer, tokens
 # arriving. A screen that stopped moving is an agent that stopped, and an agent
diff --git a/bin/root-probe b/bin/root-probe
index cb0cc8c..0cea8c1 100755
--- a/bin/root-probe
+++ b/bin/root-probe
@@ -71,8 +71,7 @@ else print -u2 "  FAIL a dead CODE_ROOT blamed the name instead"; fail=1; fi
 # own -- never yours -- and everything that would touch the machine is stubbed.
 export TMUX_TMPDIR=$(mktemp -d)
 unset TMUX TMUX_PANE                     # inside a desk $TMUX outranks TMUX_TMPDIR: without this every tmux call below, cleanup included, reached YOUR office (2026-09-11)
-export OFFICE_SOLO=1 OFFICE_SESSION_CMD='exec zsh' OFFICE_CHAT_OPEN=0
-export OFFICE_DEFAULT_DESKS=1
+export OFFICE_SOLO=1 OFFICE_SESSION_CMD='exec zsh'
 _office_attach(){ : }; _office_update_check(){ : }; _office_reap(){ : }
 _office_always_on_up(){ : }; _office_reload_conf(){ : }; _office_watch_setup(){ : }
 said=; _office_say(){ said=$1 }
diff --git a/bin/zoom-probe b/bin/zoom-probe
deleted file mode 100755
index 7e9b03e..0000000
--- a/bin/zoom-probe
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env zsh
-# zoom-probe — zoom a pane, then run the office. Is it still a room?
-#
-# Run it after ANY change to the layout functions. It builds a throwaway office
-# on its own tmux server, zooms a pane, and runs every command that moves one.
-#
-# What it is looking for: tmux reports a ZOOMED pane at full-window coordinates,
-# so `pane_left` and `pane_top` — which is how this package decides what belongs
-# in which column — describe a room that is not on screen. Before the guard in
-# `_office_unzoom`, zooming the shell and pressing any office key was enough for
-# `_office_layout_ok` to call the office broken and `_office_relayout` to break
-# every pane out to the stash and rejoin it, from a lie. You unzoomed and one
-# pane was left.
-#
-#     bin/zoom-probe
-#
-# Exits non-zero the moment a command leaves the window zoomed, drops a pane, or
-# returns a shape `_office_layout_ok` does not recognise as an office.
-emulate -L zsh
-# no err_return: every step here is checked explicitly, and a probe that stops
-# at the first non-zero return stops inside the code it is testing.
-
-export TMUX_TMPDIR=$(mktemp -d)        # its own server, never yours
-unset TMUX TMUX_PANE                     # inside a desk $TMUX outranks TMUX_TMPDIR: without this every tmux call below, cleanup included, reached YOUR office (2026-09-11)
-export OFFICE_SOLO=1
-export OFFICE_SESSION_CMD='exec zsh' OFFICE_CHAT_CMD='exec zsh' OFFICE_CHAT_OPEN=1
-export OFFICE_DEFAULT_DESKS=2
-repo=$(mktemp -d)/probe; mkdir -p "$repo"; git -C "$repo" init -q
-
-here=${0:A:h}
-source "$here/../office.zsh"
-# nothing on this run may touch the machine it runs on, or the terminal it was
-# started from: no attach, no update check, no always-on stack, no ~/.tmux.conf.
-_office_attach(){ : }; _office_update_check(){ : }; _office_reap(){ : }
-_office_always_on_up(){ : }; _office_reload_conf(){ : }; _office_say(){ : }
-
-cleanup() { tmux kill-server 2>/dev/null; rm -rf "$TMUX_TMPDIR" "${repo:h}" }
-trap cleanup EXIT INT TERM
-
-fail=0
-cd "$repo"
-_office_open "$repo" >/dev/null 2>&1
-s=$(_office_sessname "$repo")
-sleep 1
-
-panes()  { tmux list-panes -t "=$s" -F '#{pane_id}' 2>/dev/null | wc -l | tr -d ' ' }
-zoomed() { tmux list-windows -t "=$s" -F '#{window_zoomed_flag}' 2>/dev/null | head -1 }
-pane_of() { tmux list-panes -t "=$s" -F '#{@office_kind} #{pane_id}' | awk -v k="$1" '$1==k {print $2; exit}' }
-# resize-pane -Z TOGGLES. A step that left the window zoomed would otherwise
-# unzoom it here, and every step after it would pass while testing nothing.
-zoom_on() { tmux select-pane -t "$1" 2>/dev/null; [[ $(zoomed) == 1 ]] || tmux resize-pane -Z -t "$1"; [[ $(zoomed) == 1 ]] }
-
-# <what> <expected pane count> — the whole contract, in one place.
-check() {
-  local what=$1 want=$2 got=$(panes) z=$(zoomed) ok=1
-  [[ $z == 1 ]] && { print -u2 "  FAIL $what: still zoomed"; ok=0 }
-  [[ $got == $want ]] && : || { print -u2 "  FAIL $what: $got panes, expected $want"; ok=0 }
-  _office_layout_ok "$s" || { print -u2 "  FAIL $what: not an office shape"; ok=0
-    tmux list-panes -t "=$s" -F '    #{@office_kind} l=#{pane_left} t=#{pane_top}' >&2 }
-  (( ok )) && print "  ok   $what" || fail=1
-}
-
-print "office built: $(panes) panes"
-check "baseline" 5
-
-# The one geometry read whose wrong answer is destructive: it decides whether
-# _office_relayout breaks every pane out to the stash and rejoins it. A zoomed
-# strip pane reports left 0, which used to make a perfectly good office look
-# broken to it.
-zoom_on "$(pane_of SHELL)" || { print -u2 "  FAIL: could not zoom the shell"; fail=1 }
-if _office_layout_ok "$s"; then print "  ok   _office_layout_ok (zoomed)"
-else print -u2 "  FAIL _office_layout_ok (zoomed): called a good office broken"; fail=1 fi
-
-# Every verb that moves a pane, each one run with a pane zoomed first. The
-# zoomed pane is the SHELL on purpose: it lives in the right strip, and under
-# zoom it claims the left column's coordinates, which is the exact lie.
-for verb in renumber layout edit edit chat desk; do
-  zoom_on "$(pane_of SHELL)" || { print -u2 "  FAIL: could not zoom for '$verb'"; fail=1; continue }
-  before=$(panes)
-  office $verb >/dev/null 2>&1 || true
-  case $verb in
-    edit|chat) want=$(( before == 5 ? 4 : 5 )) ;;   # a toggle: parks or restores
-    desk)      want=$(( before + 1 )) ;;
-    *)         want=$before ;;
-  esac
-  check "office $verb (zoomed)" $want
-done
-
-# ...and parking the pane you are zoomed into, which is the key most likely to
-# be pressed while zoomed.
-p=$(pane_of CLAUDE)
-zoom_on "$p" || { print -u2 "  FAIL: could not zoom the desk"; fail=1 }
-before=$(panes)
-office hide "$p" >/dev/null 2>&1 || true
-check "office hide (the zoomed pane)" $(( before - 1 ))
-
-(( fail )) && { print -u2 "\nzoom-probe FAILED"; exit 1 }
-print "\nzoom-probe passed"
diff --git a/docs/index.html b/docs/index.html
index 2f1cfcd..518d680 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -3,11 +3,11 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Agent Office: four coding agents, one window</title>
+<title>Agent Office: several coding agents, one window</title>
 <meta name="description" content="A tmux cockpit for running several coding agents at once. Each session gets its own git worktree, and the border of the one that has stopped tells you so. One command, no daemon, no config file.">
 <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 120 120' fill='none'><rect width='120' height='120' rx='18' fill='%230B0C10'/><g stroke='%23F6F5F1' stroke-width='11' stroke-linecap='round'><line x1='60' y1='60' x2='60' y2='30'/><line x1='60' y1='60' x2='30' y2='82'/><line x1='60' y1='60' x2='94' y2='74'/></g></svg>">
-<meta property="og:title" content="Agent Office: four coding agents, one window">
-<meta property="og:description" content="Four agents, one window, each in its own git worktree. The one that has stopped and needs you says so on its border.">
+<meta property="og:title" content="Agent Office: several coding agents, one window">
+<meta property="og:description" content="Several agents, one window, each in its own git worktree. The one that has stopped and needs you says so on its border.">
 <meta property="og:type" content="website">
 <meta name="twitter:card" content="summary">
 <!-- Not listed anywhere: a visitor gets here by typing the URL or from the index. "noindex" is
@@ -237,7 +237,7 @@
   </nav>
 
   <header id="top">
-    <h1>Four agents.<br>One window.</h1>
+    <h1>Several agents.<br>One window.</h1>
     <p class="lead">Each one in its own git worktree. The one that has stopped and is waiting on you
     says so, on its own border, without being asked.</p>
 
@@ -279,8 +279,8 @@ <h2>What was in the way</h2>
     is the easy half.</p>
     <div class="stats">
       <div class="stat">
-        <div class="n">4</div>
-        <div class="l">agents in one window, each in its own git worktree</div>
+        <div class="n">6</div>
+        <div class="l">panes in one window, three across at most, each agent in its own git worktree</div>
       </div>
       <div class="stat">
         <div class="n">20<small>s</small></div>
@@ -291,17 +291,17 @@ <h2>What was in the way</h2>
         <div class="l">daemons, config files, and dashboards to stand up</div>
       </div>
     </div>
-    <p class="punch">Four agents you can keep track of is a different tool from four agents in four
-    windows.</p>
-    <p class="note">Four is the cap because a fifth session in a fifty-row window gets about nine
-    rows, which is a slit and not a desk. Twenty seconds is the default and it is one variable.</p>
+    <p class="punch">Several agents you can keep track of is a different tool from several agents in
+    several windows.</p>
+    <p class="note">Six is the cap, three across and two down, because past that a pane is a slit
+    and not a desk. Twenty seconds is the default and it is one variable.</p>
   </section>
 
 
   <section>
     <h2>How it knows which one stopped</h2>
     <p>It watches the pane, not the agent. There is no marker to grep for and no hook to install,
-    because the left column is pointed at whatever CLI you use — so the only thing it can rely on is
+    because each pane is pointed at whatever CLI you use — so the only thing it can rely on is
     that <strong>an agent that is working redraws</strong>: a spinner, an elapsed timer, output
     arriving. One that has stopped does not.</p>
     <div class="scroll">
@@ -358,7 +358,7 @@ <h2>What it does not do</h2>
       <li><strong>No native Windows.</strong> tmux does not run there, so this lives in WSL2 and says so instead of half working.</li>
       <li><strong>No telemetry, and one network call you can switch off.</strong> <code>office on</code> runs <code>git fetch</code> against this repo's remote to tell you when you are behind, and never pulls on its own. <code>OFFICE_UPDATE_CHECK=0</code> removes even that. Nothing else here opens a socket.</li>
     </ul>
-    <p class="after">Five probes drive a real tmux server to check all of this, attaching real
+    <p class="after">Nine probes drive a real tmux server to check all of this, attaching real
     clients on a pty and typing raw bytes at them, and CI runs every one of them on macOS and
     Ubuntu — tmux 3.7b and 3.4 — on every push.
     <a href="https://github.com/ZyxWorks/agent-office#readme">The source is public, and so is
diff --git a/office.tmux.conf b/office.tmux.conf
index 76cc2f6..03c8e67 100644
--- a/office.tmux.conf
+++ b/office.tmux.conf
@@ -82,12 +82,13 @@ set -s extended-keys always
 set -as terminal-features ",xterm*:extkeys"
 
 # =============================================================================
-# THE KEYS. Two rules, and the second one covers everything.
+# THE KEYS. Five things you can do to a pane, and nothing else.
 #
 #   Shift-arrows           move between panes
-#   Ctrl-Space, then:      n new session, in its own worktree   c chat
-#                          s shell            e file editor
-#                          a all sessions     q close    x park      z zoom
+#   Ctrl-Space, then:      n new pane (an agent, a shell, the editor, or a
+#                            parked pane back)
+#                          x park      q close      z zoom
+#   drag a pane's title    onto another pane: it moves there, the rest shift
 #   drag across text       it is on the clipboard when you let go, and a
 #                          double-click takes the word, a triple-click the line
 #
@@ -178,11 +179,13 @@ bind -T copy-mode-vi S-Down  { send -X cancel ; select-pane -D }
 # OFFICE_CLIENT rides along too: two or more OFFICE_AGENTS makes `office new`
 # show a picker, and `display-menu` needs a client to draw on that a detached
 # run-shell binding does not have of its own.
-bind n run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" OFFICE_CLIENT=\"#{client_name}\" zsh -ic 'office new'      >/dev/null 2>&1 || true"
-bind s run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" zsh -ic 'office shell'    >/dev/null 2>&1 || true"
-bind e run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" zsh -ic 'office edit'     >/dev/null 2>&1 || true"
-bind c run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" zsh -ic 'office chat'     >/dev/null 2>&1 || true"
-bind a run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" zsh -ic 'office sessions' >/dev/null 2>&1 || true"
+bind n run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" OFFICE_CLIENT=\"#{client_name}\" OFFICE_SESSION=\"#{session_name}\" zsh -ic 'office new' >/dev/null 2>&1 || true"
+# The pane toggles are GONE: s (shell), e (editor), c (chat) and a (all
+# sessions) each opened or parked one fixed pane in one fixed place, and a pane
+# is now whatever you pick from n. Dropped by name, because `source-file` only
+# ADDS: a running server keeps what it learned until told otherwise. c and s were
+# tmux's own new-window and choose-tree; one window is the whole office.
+unbind s ; unbind e ; unbind c ; unbind a
 bind x run-shell -b "zsh -ic 'office hide #{pane_id}'                          >/dev/null 2>&1 || true"
 # q closes, and it is the ONLY key that closes. This used to answer to w as well
 # (the Cmd-W convention) with q there for vim fingers; two keys for one action is
@@ -243,13 +246,34 @@ if -F "#{>=:#{version},3.5}" {
     ""             "" "" \
     " close it"    c "kill-session"
 }
-bind | split-window -h -c "#{pane_current_path}"
-bind - split-window -v -c "#{pane_current_path}"
-bind C new-window -c "#{pane_current_path}"
+# Raw splits and extra windows are gone too: a split nobody placed breaks the
+# grid, and the next n would put it back anyway.
+unbind | ; unbind - ; unbind C
 bind S choose-tree -Zs
 bind Space last-window
 unbind '"' ; unbind %
 
+# --- the grid follows a close ------------------------------------------------
+# office.zsh rebuilds the grid after everything it does itself. A close is the
+# one change that does not pass through it, and it arrives two ways: a kill (q,
+# `office clean`) is after-kill-pane, and a pane whose own command ended (`exit`
+# in a shell) is pane-exited — measured on 3.7b, it fires with remain-on-exit
+# off. tmux keeps the space in the neighbour, so without these a closed column
+# leaves its neighbour twice as wide as the rest.
+#
+# Only inside an office (@office_root is written on every office session), so a
+# plain tmux session on the same server keeps whatever shape you gave it.
+set-hook -g after-kill-pane {
+  if -F "#{&&:#{@office_root},#{@office_home}}" {
+    run-shell -b "zsh -fc '. \"#{@office_home}/office.zsh\" && _office_grid \"#{session_name}\"' >/dev/null 2>&1 || true"
+  }
+}
+set-hook -g pane-exited {
+  if -F "#{&&:#{@office_root},#{@office_home}}" {
+    run-shell -b "zsh -fc '. \"#{@office_home}/office.zsh\" && _office_grid \"#{session_name}\"' >/dev/null 2>&1 || true"
+  }
+}
+
 # --- copy mode (vi keys, system clipboard) -----------------------------------
 # -H on every door into copy mode. Without it tmux prints [0/1234] over the top
 # right of the pane: lines you have scrolled up, out of lines of scrollback that
@@ -332,6 +356,41 @@ bind -T copy-mode-vi MouseUp1Pane if -F "#{==:#{selection_present},0}" "send -X
 bind -n DoubleClick1Pane select-pane -t= \; if -F "#{||:#{pane_in_mode},#{mouse_any_flag}}" "send -M" \
   { copy-mode -H ; send -X select-word ; run-shell -d0.3 ; send -X copy-pipe-and-cancel "#{@office_copy}" }
 
+# --- moving a pane: drag its title --------------------------------------------
+# Press on a pane's title line, drag, let go over another pane, and the pane
+# moves to that place; the ones in between shift along. Measured on 3.7b through
+# a real client: the press arrives as MouseDown1Border with #{mouse_pane} set to
+# the pane that OWNS the title, and letting go over a pane arrives as
+# MouseDragEnd1Pane with #{mouse_pane} set to the pane under the pointer.
+#
+# The cost, on purpose: dragging a BORDER no longer resizes (tmux's own
+# MouseDrag1Border). tmux reports the divider between two columns as that same
+# MouseDown1Border, with no coordinates to tell it from a title, so one gesture
+# has to win. The grid puts every size back on the next change anyway, and z
+# gives a pane the whole window.
+#
+# tmux 3.7 or newer. Measured on 3.4, 3.5a and 3.6b: a press on a title sends
+# no event at all, and the drag arrives as a plain MouseDrag1Pane without
+# coordinates, the same thing a fast drag out of a pane body sends. So on those a
+# title drag is a copy, as it always was, and the bar leaves out the hint.
+#
+# Armed on the DRAG, not the press, so a plain click on a title only focuses the
+# pane. Disarmed by every other press, so a drag that ended nowhere never moves
+# a pane on some later, unrelated drag.
+# ponytail: a drop onto a pane that is scrolled back (in copy mode) goes to the
+# copy-mode table and moves nothing; the next press disarms it. Scroll down first.
+bind -n MouseDown1Border select-pane -t =
+bind -n MouseDrag1Border set -gF @office_drag "#{mouse_pane}"
+bind -n MouseDragEnd1Border set -gu @office_drag
+bind -n MouseDown1Pane { set -gu @office_drag ; select-pane -t = ; send -M }
+bind -n MouseDragEnd1Pane if -F "#{&&:#{@office_drag},#{!=:#{@office_drag},#{mouse_pane}}}" {
+  run-shell -b "zsh -fc '. \"#{@office_home}/office.zsh\" && _office_move \"#{@office_drag}\" \"#{mouse_pane}\"' >/dev/null 2>&1 || true"
+  set -gu @office_drag
+} {
+  set -gu @office_drag
+  send -M
+}
+
 # Drag to select, let go, it is on the clipboard. No Ctrl-C, no prefix.
 # tmux already does this in a plain shell — a drag opens copy mode and the
 # binding above pipes the selection to pbcopy on release. The FILE EDITOR is the
@@ -405,8 +464,8 @@ set -g @office_ctx "#{?#{E:@office_ctx_gate},#(#{@office_home}/bin/office-ctx #{
 #   @office_num    OUR pane number. tmux's own #{pane_index} follows the layout
 #                  TREE, which join-pane leaves in an order the eye disagrees
 #                  with. office numbers panes from their geometry instead.
-#   the label      what the pane is, plus either the chord that toggles it or
-#                  what it is currently doing.
+#   the label      what the pane is, and what it is currently doing. It is
+#                  also the handle you drag to move the pane.
 #   @office_ctx    how full that desk's context window is.
 #   @office_attn   the "your turn" readout above. Both go at the END, and attn
 #                  goes last: they are the two things on a border that change on
diff --git a/office.zsh b/office.zsh
index f61e9f6..ad4ddc5 100644
--- a/office.zsh
+++ b/office.zsh
@@ -11,14 +11,11 @@
 #   office pick       fuzzy-pick from all your repos
 #   office solo       like `on`, but start nothing but the tabs
 #
-#   office new [wt]   another session, in its OWN git worktree           (^Sn)
+#   office new        one more pane: pick an agent, a shell or the editor  (^Sn)
+#   office new --agent <a> [wt]   ...straight to that agent, in its OWN worktree
 #   office task ...   another session, started on a task straight away
 #   office desk       another session in THIS checkout, when you mean it
-#   office chat       toggle the chat pane                           (^Sc)
-#   office shell      toggle the shell pane                          (^Ss)
-#   office edit       toggle the editor pane                         (^Se)
-#   office hide/show  collapse the pane you are on / bring one back  (^Sx)
-#   office layout     rebuild the two columns if they ever look wrong
+#   office hide/show  park the pane you are on / bring a parked one back (^Sx)
 #   office cd [x]     walk the shell into another worktree; the editor follows
 #
 #   office doctor     what's running and what it costs in RAM (read-only)
@@ -38,9 +35,7 @@ zmodload -F zsh/stat b:zstat 2>/dev/null
 _OFFICE_MTIME=$(zstat +mtime "$_OFFICE_HOME/office.zsh" 2>/dev/null)
 CODE_ROOT="${CODE_ROOT:-$HOME/code}"
 OFFICE_DEFAULT="${OFFICE_DEFAULT:-}"        # repo `office on` opens; empty = the one you are in
-# The chat pane: whatever talking to your agent looks like. Point it at your own
-# chat command and it becomes that. Left as a plain shell by default.
-# What a session IS. Point it at any agent CLI and the left column becomes that.
+# What a session IS. Point it at any agent CLI and every desk becomes that.
 OFFICE_SESSION_CMD="${OFFICE_SESSION_CMD:-claude}"
 # How every desk ends. Quitting the agent leaves the pane on a prompt — nothing
 # is lost and the pane is yours — but a border still labelled CLAUDE over a bare
@@ -53,8 +48,7 @@ OFFICE_SESSION_LABEL="${OFFICE_SESSION_LABEL:-CLAUDE}"
 # is "LABEL command words...", the label first and the rest the pane command —
 # see the README for the shape. Left unset, it is built from the two variables
 # above, so an existing .zshrc sees no change at all: one agent, and Ctrl-Space
-# n still opens it directly. `_office_agent_menu` is what asks when there are
-# more.
+# n still offers it. `_office_menu` lists every entry, plus a shell and the editor.
 typeset -ga OFFICE_AGENTS
 (( ${#OFFICE_AGENTS} )) || OFFICE_AGENTS=("$OFFICE_SESSION_LABEL $OFFICE_SESSION_CMD")
 # Agent 1 is also what every path older than OFFICE_AGENTS still runs — the
@@ -67,10 +61,6 @@ OFFICE_SESSION_LABEL="${${(z)OFFICE_AGENTS[1]}[1]}"
 OFFICE_SESSION_CMD="${(j: :)${(z)OFFICE_AGENTS[1]}[2,-1]}"
 # Where `office new` looks for git worktrees. Claude Code's default location.
 OFFICE_WORKTREE_DIR="${OFFICE_WORKTREE_DIR:-.claude/worktrees}"
-# How much of the window the right strip takes. Wide enough that a chat pane
-# does not wrap every sentence, narrow enough that the agents keep the room.
-OFFICE_STRIP_WIDTH="${OFFICE_STRIP_WIDTH:-32}"
-OFFICE_CHAT_LABEL="${OFFICE_CHAT_LABEL:-AGENT CHAT}"
 # How long a desk has to sit completely still before its border says "your turn".
 # Long enough that a pause between two tool calls is not an interruption, short
 # enough that you are not the last to know. Raise it if your agent goes quiet
@@ -83,13 +73,6 @@ OFFICE_ATTN_SECS="${OFFICE_ATTN_SECS:-20}"
 # the window your plan gets and nothing here can know that. See bin/office-ctx.
 OFFICE_CTX_WARN="${OFFICE_CTX_WARN:-400000}"
 OFFICE_CTX_ALARM="${OFFICE_CTX_ALARM:-600000}"
-_OFFICE_CHAT_UNSET="exec $SHELL"
-OFFICE_CHAT_CMD="${OFFICE_CHAT_CMD:-$_OFFICE_CHAT_UNSET}"
-# Open the chat pane at startup when there is actually a chat to open, which is
-# the moment you point OFFICE_CHAT_CMD at your own agent. Left at its default it
-# would just be a fourth shell, so it stays closed. OFFICE_CHAT_OPEN=1 or 0
-# decides it outright.
-[[ -n $OFFICE_CHAT_OPEN ]] || { [[ $OFFICE_CHAT_CMD == $_OFFICE_CHAT_UNSET ]] && OFFICE_CHAT_OPEN=0 || OFFICE_CHAT_OPEN=1 }
 
 # ---------------------------------------------------------------- internals --
 _office_sessname() { basename "$1" | tr ' .:' '___'; }
@@ -140,9 +123,12 @@ _office_pane_cwd() {
 # office out from under every helper — the editor stopped following the shell,
 # and `office n`/`layout`/`show` quietly targeted a session that did not exist.
 # Outside tmux there is no pane to ask, so the directory is still the answer.
+# A menu item names its office outright (OFFICE_SESSION): it runs detached, with
+# no pane of its own to ask, and "the current session" is a guess with two
+# offices open.
 _office_here() {
-  local s
-  [[ -n $TMUX ]] && s=$(tmux display -p -t "${TMUX_PANE:-}" '#{session_name}' 2>/dev/null)
+  local s=${OFFICE_SESSION:-}
+  [[ -z $s && -n $TMUX ]] && s=$(tmux display -p -t "${TMUX_PANE:-}" '#{session_name}' 2>/dev/null)
   [[ -n $s ]] && print -r -- "$s" || _office_sessfor "$(_office_root "$PWD")"
 }
 
@@ -227,13 +213,9 @@ _office_watch_setup() {
 # ZOOM LIES ABOUT GEOMETRY, and every layout answer in this file is geometry.
 # While a pane is zoomed, tmux reports THAT pane at full-window coordinates:
 # pane_left 0, pane_top 1, the whole width. The other panes keep their old
-# numbers. So `_office_desk_pane` picks the zoomed pane as the bottom desk,
-# `_office_desk_count` counts it into the left column, `_office_even_column`
-# resizes a column that is not there, `_office_number` numbers by a position
-# nothing is at — and `_office_layout_ok` sees a strip pane sitting at left 0,
-# calls the office broken, and hands it to `_office_relayout`, which breaks
-# EVERY pane out to the stash and rejoins them, all from a lie. That is how
-# zooming a session and unzooming it again left one shell on screen.
+# numbers, so `_office_number` numbers by a position nothing is at. An older
+# layout engine that trusted those numbers broke every pane out to the stash
+# and rejoined them, all from a lie: zoom, unzoom, one shell left on screen.
 #
 # tmux was never going to keep the zoom anyway: its own resize-pane unzooms the
 # window silently (check window_zoomed_flag after one). So drop it FIRST and on
@@ -242,7 +224,7 @@ _office_unzoom() {                     # <session>
   # A pane id, and nothing shorter. `resize-pane -t "=<session>"` is not a
   # target tmux accepts ("can't find pane"), and display-message -t "=session"
   # returns EMPTY for window flags — the same trap as window_height in
-  # _office_even_column. Both fail silently, which is a guard that guards
+  # _office_grid. Both fail silently, which is a guard that guards
   # nothing. Ask for the panes instead: the ACTIVE pane of every zoomed window,
   # which is the only pane a window can be zoomed on.
   local p n=0
@@ -262,23 +244,59 @@ _office_unzoom() {                     # <session>
   return 0
 }
 
-# the BOTTOM desk in the left column: a new session is split off it, so sessions
-# append downwards and their numbers stay in the order you opened them. Splitting
-# the tallest instead would drop session 3 in between 1 and 2.
-# Returns a pane id (%N), the only target type that is unambiguous. The right
-# strip is excluded structurally, by having a greater pane_left than the
-# column's, so no label matching is involved.
-_office_desk_pane() {
-  tmux list-panes -t "=$1" -F '#{pane_left} #{pane_top} #{pane_id}' 2>/dev/null \
-    | sort -k1,1n -k2,2nr | awk 'NR==1 { print $3 }'
-}
-
-# how many desks the left column is holding. Four is the cap: a fifth session in
-# a 50-row window gets ~9 rows, which is not a desk, it is a slit.
-_OFFICE_MAX_DESKS=4
-_office_desk_count() {
-  tmux list-panes -t "=$1" -F '#{pane_left}' 2>/dev/null \
-    | sort -n | awk 'NR==1 {l=$1} $1==l {n++} END {print n+0}'
+# --- the grid ----------------------------------------------------------------
+# An office starts as ONE pane that asks what it should be, and every pane after
+# that is one more cell in a grid: at most three side by side, at most two
+# stacked. Six in all. Past that a pane is a slit and not a place to work.
+#
+#   1 [A]      2 [A|B]      3 [A|B]      4 [A|B]      5 [A|B|C]      6 [A|B|C]
+#                             [ C ]        [C|D]        [ D | E ]      [D|E|F]
+#
+# It fills the way you read: the top row first, then the row below. The top row
+# holds the extra pane when the count is odd, so a third pane goes underneath
+# rather than squeezing the first two (operator, 2026-09-17).
+#
+# tmux's own `tiled` is not this: it stacks before it goes sideways, so two panes
+# come out one above the other. So the layout is written out whole, as the same
+# string `list-windows -F '#{window_layout}'` prints, and handed to select-layout.
+# The panes fill it in tmux's own pane order, which is the order they were added.
+#
+# Rebuilt on every add, park, unpark and close (the tmux config hooks the close),
+# so a border you dragged snaps back the next time the office changes shape.
+# ponytail: one fixed shape per count. A remembered custom split is the upgrade.
+_OFFICE_MAX_PANES=6
+_office_grid() {                       # <session>
+  local s=$1 W H n m r c k=1 x y=0 cw rh body i ch csum=0
+  local -a ids cells rows
+  ids=(${(f)"$(tmux list-panes -t "=$s" -F '#{pane_id}' 2>/dev/null)"})
+  n=$#ids
+  read -r W H <<< "$(tmux list-windows -t "=$s" -F '#{window_width} #{window_height}' 2>/dev/null | head -1)"
+  if (( n > 1 )) && [[ $W == <-> && $H == <-> ]]; then
+    # two panes share one row; from three on, two rows, the top one holding the
+    # odd pane out. An office left from an older version with more than six
+    # still gets two rows, just wider ones.
+    for m in $(( n <= 2 ? n : (n + 1) / 2 )) $(( n <= 2 ? 0 : n / 2 )); do
+      (( m )) || continue
+      (( rh = n <= 2 ? H : (y ? H - y : (H - 1) / 2) ))
+      cells=(); x=0
+      for (( c = 0; c < m; c++ )); do
+        (( cw = c == m - 1 ? W - x : (W - (m - 1)) / m ))
+        cells+=("${cw}x${rh},${x},${y},${ids[k]#%}"); (( ++k ))
+        (( x += cw + 1 ))
+      done
+      (( m == 1 )) && rows+=("${cells[1]}") || rows+=("${W}x${rh},0,${y}{${(j:,:)cells}}")
+      (( y += rh + 1 ))
+    done
+    (( n <= 2 )) && body="${W}x${H},0,0{${(j:,:)cells}}" || body="${W}x${H},0,0[${(j:,:)rows}]"
+    # tmux refuses a layout whose checksum does not match: its own 16-bit
+    # rotate-and-add over every character (layout_checksum in layout-custom.c).
+    for (( i = 1; i <= $#body; i++ )); do
+      printf -v ch '%d' "'${body[i]}"
+      (( csum = ((csum >> 1) + ((csum & 1) << 15) + ch) & 0xffff ))
+    done
+    tmux select-layout -t "${ids[1]}" "$(printf '%04x' $csum),$body" 2>/dev/null
+  fi
+  _office_number "$s"
 }
 
 # --- the editor pane ---------------------------------------------------------
@@ -348,20 +366,16 @@ if [[ -n $TMUX && -o interactive ]]; then
   autoload -Uz add-zsh-hook 2>/dev/null && add-zsh-hook chpwd _office_editor_sync
 fi
 
-# What the FILE EDITOR pane runs. ONE definition: it is spawned from
-# _office_open and from `office edit`, and it grew a way back.
-#
-# Leaving the list (Esc, or quitting the editor twice) used to `exec zsh` and
-# leave a bare prompt behind a border still labelled FILE EDITOR, which no key
-# could revive: `office edit` saw a pane of that kind, hid it, and gave it back
-# just as empty. The pane now says so on its way out, and marks itself dead so
-# its own key rebuilds it.
+# What the FILE EDITOR pane runs. Leaving the list (Esc, or quitting the editor
+# twice) turns the pane into a shell and SAYS so: a border still reading FILE
+# EDITOR over a bare prompt reads like a broken window. Ctrl-Space q closes it,
+# Ctrl-Space n opens a new editor.
 _office_editor_loop() {
   while _office_pick_file; do :; done
   # -t $TMUX_PANE, never a bare `set -p`: that writes to whichever pane you are
-  # LOOKING at, which is how a CLAUDE pane got marked dead instead of this one.
-  tmux set -p -t "$TMUX_PANE" @office_live 0 2>/dev/null
-  print -P "\n  %F{yellow}the file list is closed.%f  Ctrl-Space e brings it back."
+  # LOOKING at, which is how a CLAUDE pane got relabelled instead of this one.
+  _office_label "$TMUX_PANE" "$(_office_strip_title "$PWD")" SHELL
+  print -P "\n  %F{yellow}the file list is closed — this pane is a shell now.%f"
   exec zsh
 }
 # The pane sources the package itself, and does not hope the rc file did it.
@@ -430,202 +444,35 @@ _office_pick_file() {                  # [dir]
 }
 
 
-# --- the right strip: chat, shell, file editor, top to bottom ----------------
-# The order is data, so a pane that is toggled off and back on lands where it
-# belongs instead of at the bottom.
-#
-# The agent you built is at the TOP: it is the pane you actually talk to, so it
-# gets the corner your eye goes to. Then the shell, then the file list, which is
-# the pane you reach for least. With no chat wired up the strip is the shell and
-# the editor, which is the same order with the top row missing.
-typeset -gA _OFFICE_STRIP_ORDER=(CHAT 1 SHELL 2 EDITOR 3)
-_office_rank() { print -r -- ${_OFFICE_STRIP_ORDER[$1]:-9} }
-
-# where a <kind> pane belongs in the strip: "<pane-id> <split-flag>", where the
-# flag is -b when it has to go ABOVE that pane (nothing ranks below it yet).
-_office_strip_slot() {                 # <session> <kind>
-  local line col id kind below last first want
-  want=$(_office_rank "$2")
-  for line in ${(f)"$(tmux list-panes -t "=$1" -F '#{pane_left}|#{pane_top}|#{pane_id}|#{@office_kind}' 2>/dev/null | sort -t'|' -k1,1nr -k2,2n)"}; do
-    col=${col:-${line%%|*}}
-    [[ ${line%%|*} == $col ]] || break          # left column starts, strip ends
-    id=${${(s:|:)line}[3]}; kind=${${(s:|:)line}[4]}
-    first=${first:-$id}
-    (( $(_office_rank "$kind") <= want )) && last=$id
-  done
-  [[ -n $last ]] && { print -r -- "$last "; return }
-  print -r -- "${first} -b"
-}
-
-# give every pane in a column the same height. tmux has no column-scoped layout,
-# so the arithmetic is ours. `left` is the desks, `right` is the glance strip;
-# a three-row shell is as useless as a three-row agent.
-# Where a pane of <kind> belongs: a target pane plus split-window/join-pane flags.
-#
-# Both columns can vanish. Park every session and the left column is
-# gone; park the shell, editor and chat and the strip is. tmux collapses a
-# two-column layout the moment one side empties, and from then on "leftmost
-# pane" and "rightmost pane" are the same pane, so everything coming back lands
-# in one tall stack. This is what stops that: when a column is missing, the
-# first pane that needs it rebuilds it.
-# Put the two columns back, from any mess at all.
-#
-# tmux layouts are trees, and only a window with ONE pane can be split into two
-# root-level columns. Splitting a pane that already sits inside a stack nests
-# instead, which is how a rebuilt column ends up half height. So the honest
-# repair is to break every pane out, keep one, and re-join them in the order the
-# office wants: sessions down the left, glance panes down the right.
-#
-# Only runs when a column has actually gone missing, because it makes every pane
-# redraw. `office layout` is the same thing on demand.
-# Is the window actually shaped like an office? Every session sharing one left
-# edge, every glance pane sharing another, and the sessions on the left. Counting
-# distinct columns is not enough: a nested split also produces two of them, and
-# that is exactly the broken state this has to catch.
-_office_layout_ok() {                  # <session>
-  local line kind left
-  local -a dl sl
-  # again here, and not only in office(): this is the ONE geometry read whose
-  # wrong answer is destructive. It hands the room to _office_relayout, which
-  # breaks every pane out to the stash. A zoomed pane reports left 0, so a strip
-  # pane under zoom looks like it is sitting in the desk column and the office
-  # is declared broken while nothing is wrong with it. Nothing calls this from
-  # outside office() today; the guard is here so nothing has to remember.
-  _office_unzoom "$1"
-  for line in ${(f)"$(tmux list-panes -t "=$1" -F '#{pane_left}|#{@office_kind}' 2>/dev/null)"}; do
-    left=${${(s:|:)line}[1]}; kind=${${(s:|:)line}[2]}
-    if [[ $(_office_rank "$kind") == 9 ]]; then dl+=($left); else sl+=($left); fi
-  done
-  (( $#dl && $#sl )) || return 0       # one-sided is a legitimate shape
-  dl=(${(u)dl}); sl=(${(u)sl})
-  (( $#dl == 1 && $#sl == 1 )) && (( dl[1] < sl[1] ))
-}
-
-_office_relayout() {                   # <session>
-  local s=$1 line kind id keep w prev
-  local -a desks strip all
-  for line in ${(f)"$(tmux list-panes -t "=$s" -F '#{pane_top}|#{pane_id}|#{@office_kind}' 2>/dev/null | sort -t'|' -k1,1n)"}; do
-    id=${${(s:|:)line}[2]}; kind=${${(s:|:)line}[3]}
-    if [[ $(_office_rank "$kind") == 9 ]]; then desks+=($id); else strip+=("$(_office_rank "$kind")|$id"); fi
-  done
-  strip=(${(f)"$(printf '%s\n' $strip | sort -t'|' -k1,1n | cut -d'|' -f2)"})
-  (( $#desks && $#strip )) || return 0          # one-sided is not a two-column layout
-  _office_stash_ensure
-  keep=${desks[1]}
-  all=(${desks[2,-1]} $strip)
-  for id in $all; do tmux break-pane -d -s "$id" -t "=$_OFFICE_STASH:" -n "relayout-${id#\%}" 2>/dev/null; done
-  # one pane left, so this split is the ROOT one: it is what makes two columns
-  w=$(tmux list-windows -t "=$s" -F '#{window_width}' 2>/dev/null | head -1)
-  tmux join-pane -h -l $(( w * OFFICE_STRIP_WIDTH / 100 )) -s "${strip[1]}" -t "$keep" 2>/dev/null
-  prev=$keep
-  for id in ${desks[2,-1]}; do tmux join-pane -v -s "$id" -t "$prev" 2>/dev/null && prev=$id; done
-  prev=${strip[1]}
-  for id in ${strip[2,-1]}; do tmux join-pane -v -s "$id" -t "$prev" 2>/dev/null && prev=$id; done
-  _office_even_column "$s" left; _office_even_column "$s" right; _office_number "$s"
-}
-
-_office_place() {                      # <session> <kind> -> "<pane> <flags...>"
-  local s=$1 kind=$2 cols l has_strip=0
-  local -a sl
-  cols=$(tmux list-panes -t "=$s" -F '#{pane_left}' 2>/dev/null | sort -un | wc -l | tr -d ' ')
-  if (( cols >= 2 )); then                        # both columns exist: place normally
-    if [[ $(_office_rank "$kind") == 9 ]]; then
-      print -r -- "$(_office_desk_pane "$s") -v"
-    else
-      sl=($(_office_strip_slot "$s" "$kind")); print -r -- "${sl[1]} -v ${sl[2]}"
-    fi
-    return
-  fi
-  for l in ${(f)"$(tmux list-panes -t "=$s" -F '#{@office_kind}' 2>/dev/null)"}; do
-    [[ $(_office_rank "$l") == 9 ]] || has_strip=1
-  done
-  if (( has_strip )) && [[ $(_office_rank "$kind") != 9 ]]; then
-    sl=($(_office_strip_slot "$s" "$kind")); print -r -- "${sl[1]} -v ${sl[2]}"
-  elif (( has_strip )) || [[ $(_office_rank "$kind") == 9 ]]; then
-    # the column this pane belongs in does not exist. Land it anywhere: the
-    # caller checks the shape afterwards and rebuilds, which is the only way to
-    # get a root-level split back.
-    print -r -- "$(_office_desk_pane "$s") -v"
-  else
-    print -r -- "$(_office_desk_pane "$s") -h -l ${OFFICE_STRIP_WIDTH}%"
-  fi
-}
-
-_office_even_column() {                # <session> [left|right]
-  local s=$1 side=${2:-left} h n target p sortflag
-  local -a panes
-  [[ $side == right ]] && sortflag=-k1,1nr || sortflag=-k1,1n
-  panes=(${(f)"$(tmux list-panes -t "=$s" -F '#{pane_left} #{pane_top} #{pane_id}' 2>/dev/null \
-        | sort $sortflag -k2,2n | awk 'NR==1 {l=$1} $1==l {print $3}')"})
-  n=$#panes
-  (( n > 1 )) || return 0
-  # NB: display-message -t "=session" returns EMPTY for window_height; ask the
-  # window list instead, or the target becomes 0 and every pane collapses to 1.
-  h=$(tmux list-windows -t "=$s" -F '#{window_height}' 2>/dev/null | head -1)
-  [[ $h == <-> ]] || return 0
-  target=$(( (h - (n - 1)) / n ))
-  (( target >= 6 )) || return 0        # below this it is a sliver, not a pane
-  for p in ${panes[1,-2]}; do tmux resize-pane -t "$p" -y $target 2>/dev/null; done
-}
-_office_even_desks() { _office_even_column "$1" left }
-
 # tmux numbers panes by their position in the LAYOUT TREE, and join-pane leaves
 # that tree in an order the eye does not agree with: you get 4=EDITOR, 6=SHELL.
 # Swapping cannot fix it (a swap moves the geometry too), and rebuilding the tree
 # means breaking every pane out and back. So the border shows OUR number, taken
-# straight from the geometry: down the left column, then down the right strip.
+# straight from the geometry: along the top row, then along the row below.
 # The key strip, written into a tmux option rather than polled by the status bar
-# with #(). A polled job is always one interval behind the thing it describes:
-# you close a pane and the bar keeps saying it is open until the next tick. This
-# is pushed, from the one function that already runs after every change.
+# with #(). A polled job is always one interval behind the thing it describes.
+# This is pushed, from the one function that already runs after every change.
 #
-# Three tones, and the ladder is one question: what is the key FOR right now?
-#
-#   white  the way BACK out of a state you are stuck in. Nothing else is white,
-#          so white always means "press this to undo what you are looking at".
-#          Only zoom has such a state: while a window is zoomed, every other
-#          pane is invisible while still being open, so the open/closed reading
-#          below cannot help you and the exit key has to say so itself.
-#   lit    a pane that is CLOSED - the key brings it back. Worth your eye.
-#   dim    a pane that is already open, and the actions, which have no
-#          open-or-closed state to report at all.
-#
-# The prefix reads like every other key: dim while it is not doing anything, lit
-# only while it is HELD - a pressed prefix is exactly the "there is something to
-# do here" the ladder means. tmux answers client_prefix itself on every redraw,
-# same reason zoom is a format and not a pushed tone.
+# Five keys and nothing else: n adds a pane (or brings a parked one back — they
+# are on the same list), x parks, q closes, z zooms, Shift-arrows move. Dim,
+# except two things that want your eye: the prefix while it is HELD, and zoom
+# while the window IS zoomed (every other pane is hidden then, so the way back
+# has to say so itself). The parked count is there because a parked pane is the
+# only kind you can lose: it is running, and nothing on screen shows it.
 _OFFICE_BAR_OPEN='#[fg=#4e505a]'
 _OFFICE_BAR_SHUT='#[fg=#9a9ca6]'
 _OFFICE_BAR_BACK='#[fg=#f6f5f1]'
 _OFFICE_BAR_SEP='#[fg=#3a3c44]'
 _office_bar() {                        # <session>
-  local open out sep="" pair kind name key tone
-  open=" $(tmux list-panes -t "=$1" -F '#{@office_kind}' 2>/dev/null | tr '\n' ' ')"
-  out="#{?client_prefix,${_OFFICE_BAR_SHUT},${_OFFICE_BAR_OPEN}}^Space#[default] ${_OFFICE_BAR_SEP}│#[default] ${_OFFICE_BAR_OPEN}n new${_OFFICE_BAR_SEP} · #[default]"
-  for pair in "CLAUDE:sessions:a" "CHAT:chat:c" "SHELL:shell:s" "EDITOR:editor:e"; do
-    kind=${pair%%:*}; name=${${pair#*:}%%:*}; key=${pair##*:}
-    [[ $open == *" $kind "* ]] && tone=$_OFFICE_BAR_OPEN || tone=$_OFFICE_BAR_SHUT
-    out+="${sep}${tone}${name} ${key}#[default]"
-    sep="${_OFFICE_BAR_SEP} · #[default]"
-  done
-  # One list, one separator. There used to be a second divider here marking
-  # "toggles" from "actions", which is a distinction nothing else on the bar
-  # shows: brightness means closed, and that is all it means.
-  # Zoom is the one segment this function cannot answer, and the only one that
-  # is a FORMAT rather than a tone: ^Space z is plain tmux, so it fires without
-  # office running at all and a pushed tone would sit there stale, calling a
-  # zoomed window flat until the next thing you happen to open. tmux resolves
-  # this conditional itself, every redraw. It needs the theme's `#{E:` to be
-  # expanded - a `#{...}` reached through `#{@office_bar}` comes out LITERAL
-  # (checked on tmux 3.7b), which is why the E is not decoration.
-  out+="${_OFFICE_BAR_SEP} · #[default]${_OFFICE_BAR_OPEN}q close${_OFFICE_BAR_SEP} · #[default]${_OFFICE_BAR_OPEN}x park${_OFFICE_BAR_SEP} · #[default]#{?window_zoomed_flag,${_OFFICE_BAR_BACK}z unzoom,${_OFFICE_BAR_OPEN}z zoom}#[default]"
-  # Moving between panes, behind its own divider because it is the one chord on
-  # this bar that does NOT want the prefix - the divider is the chord changing,
-  # which is the same job the first one does after ^Space. It is the first thing
-  # a new pair of eyes needs and the only key here nothing on screen hints at:
-  # a pane border shows which pane you are in, never how to reach the next one.
-  # Dim, like the other actions, because moving has no open-or-closed state.
-  out+="${_OFFICE_BAR_SEP} │ #[default]${_OFFICE_BAR_OPEN}⇧ ← ↑ ↓ →  move#[default]"
+  local out parked d="${_OFFICE_BAR_SEP} · #[default]${_OFFICE_BAR_OPEN}"
+  parked=$(_office_parked "$1" | wc -l | tr -d ' ')
+  out="#{?client_prefix,${_OFFICE_BAR_SHUT},${_OFFICE_BAR_OPEN}}^Space#[default] ${_OFFICE_BAR_SEP}│#[default] ${_OFFICE_BAR_OPEN}n new"
+  (( parked )) && out+=" ${_OFFICE_BAR_SHUT}($parked parked)#[default]${_OFFICE_BAR_OPEN}"
+  out+="${d}x park${d}q close${_OFFICE_BAR_SEP} · #[default]#{?window_zoomed_flag,${_OFFICE_BAR_BACK}z unzoom,${_OFFICE_BAR_OPEN}z zoom}#[default]"
+  # Zoom is a FORMAT and not a pushed tone: ^Space z is plain tmux and fires
+  # without office, so only tmux can answer it on every redraw. It needs the
+  # theme's `#{E:` — through `#{@office_bar}` it comes out LITERAL (tmux 3.7b).
+  out+="${_OFFICE_BAR_SEP} │ #[default]${_OFFICE_BAR_OPEN}⇧ ← ↑ ↓ →  move#{?#{>=:#{version},3.7}, · drag a title to reorder,}#[default]"
   # NB: no "=" prefix here. set-option takes a plain session name and rejects
   # the exact-match form that every other tmux command accepts.
   tmux set -t "$1" @office_bar "$out" 2>/dev/null
@@ -634,7 +481,7 @@ _office_bar() {                        # <session>
 _office_number() {                     # <session>
   local r n=0
   for r in ${(f)"$(tmux list-panes -t "=$1" -F '#{pane_left}|#{pane_top}|#{pane_id}' 2>/dev/null \
-        | sort -t'|' -k1,1n -k2,2n)"}; do
+        | sort -t'|' -k2,2n -k1,1n)"}; do
     tmux set -p -t "${${(s:|:)r}[3]}" @office_num $(( ++n )) 2>/dev/null
   done
   _office_bar "$1"                     # the strip is only ever as fresh as this
@@ -806,11 +653,11 @@ _office_stale() {                      # [hours] -> "<session> <idle-min> <MB>"
 # so the ROLE lives in a user option the app cannot touch, and the border shows
 # both: "CLAUDE . rename the auth module".
 #
-# @office_kind is the STABLE identity (CHAT, SHELL, EDITOR, CLAUDE) that
-# the toggles match on — the visible label carries a repo and a branch and moves.
+# @office_kind is the STABLE identity (NEW, SHELL, EDITOR, CLAUDE) that
+# everything matches on — the visible label carries a repo and a branch and moves.
 # CLAUDE means "an agent desk" now, whichever OFFICE_AGENTS entry is actually
-# running there — office-attn and the toggles only ever needed "is this a
-# session", never which one, so nothing downstream had to change.
+# running there — office-attn only ever needed "is this a session", never
+# which one. NEW is the pane still asking what it should be.
 _office_label() {                      # <pane> <label> [kind]
   # '#' is stripped: the label is rendered through tmux's format engine, where
   # #(...) runs a shell command. A branch name or an `office task` description
@@ -866,114 +713,106 @@ _office_hide() {                       # <pane-id>
   local kind sess
   kind=$(tmux display -p -t "$1" '#{@office_kind}' 2>/dev/null)
   sess=$(tmux display -p -t "$1" '#{session_name}' 2>/dev/null)
-  [[ -n $kind ]] || kind=pane
-  # again here, and not only in office(): the Ctrl-Space x binding is the one
-  # that does NOT cd to the pane's path first, so _office_here up there can name
-  # a different office (or none). The pane knows its own session; use that.
+  [[ -n $kind && -n $sess ]] || return 1
+  # the question pane has nothing running to keep: parking it would only put a
+  # "back: NEW" on the list
+  [[ $kind == NEW ]] && { _office_say "nothing to park here — pick what this pane is first"; return 0 }
+  # again here, and not only in office(): the Ctrl-Space x binding hands a pane
+  # id and no path, so _office_here can name a different office (or none). The
+  # pane knows its own session; use that.
   _office_unzoom "$sess"
   _office_stash_ensure
-  # two parked CLAUDE desks would otherwise both be a window called "claude", and
-  # only ever one of them could be found again. The pane id makes it unique, and
-  # _office_unhide matches on the "<kind>-<office>-" prefix.
-  #
-  # The office is in the name because the stash is ONE session for the whole
-  # server: keyed by kind alone, parking the file editor in one office and
-  # pressing Ctrl-Space e in another handed you the first office's pane, panel
-  # and all.
-  local name="${(L)kind}-${(L)sess}-${1#\%}"
-  tmux break-pane -d -s "$1" -t "=$_OFFICE_STASH:" -n "$name" 2>/dev/null || return 1
+  # Parking the LAST pane would take the window with it, and the session with the
+  # window: the office would simply be gone. So the office gets a fresh "what
+  # next?" pane first, and the parked one is on its list.
+  (( $(tmux list-panes -t "=$sess" 2>/dev/null | wc -l) > 1 )) \
+    || _office_label "$(tmux split-window -d -t "$1" -P -F '#{pane_id}' "$_OFFICE_WAIT_CMD")" NEW NEW
+  # WHOSE it is travels on the pane, because the stash is ONE session for the
+  # whole server: keyed by kind alone, parking the file editor in one office and
+  # bringing one back in another handed you the first office's pane.
+  tmux set -p -t "$1" @office_parked_from "$sess" 2>/dev/null
+  tmux break-pane -d -s "$1" -t "=$_OFFICE_STASH:" -n "${(L)kind}-${(L)sess}-${1#\%}" 2>/dev/null || return 1
   # the placeholder only exists because a session needs one window; once a real
   # pane is parked it is just noise in `office doctor`.
   (( $(tmux list-windows -t "=$_OFFICE_STASH" 2>/dev/null | wc -l) > 1 )) \
     && tmux kill-window -t "=$_OFFICE_STASH:idle" 2>/dev/null
-  _office_number "${${(s.:.)$(tmux display -p '#{session_name}')}[1]}" 2>/dev/null
+  _office_grid "$sess"
   return 0
 }
 
-# bring a stashed pane back to where its kind belongs. Fails (1) if none is stashed.
-_office_unhide() {                     # <session> <kind>
-  local w p
-  local -a slot
-  # THIS office's stash entry for that kind, or the exact window name when
-  # `office show` passed one through.
-  w=$(tmux list-windows -t "=$_OFFICE_STASH" -F '#{window_id} #{window_name}' 2>/dev/null \
-      | awk -v n="${(L)2}" -v pfx="${(L)2}-${(L)1}-" '$2==n || index($2, pfx)==1 {print $1; exit}')
-  [[ -n $w ]] || return 1
-  p=$(tmux list-panes -t "$w" -F '#{pane_id}' 2>/dev/null | head -1)
-  slot=($(_office_place "$1" "$2"))
-  tmux join-pane ${slot[2,-1]} -s "$p" -t "${slot[1]}" || return 1
-  # a column that was just rebuilt holds one pane; evening both is cheap and
-  # always right, and the numbers follow the geometry afterwards.
-  _office_layout_ok "$1" || _office_relayout "$1"
-  _office_even_column "$1" left; _office_even_column "$1" right
-  _office_number "$1"
+# This office's parked panes: "<stash-window-id><TAB><label>", oldest first.
+# A pane parked by an older office.zsh has no @office_parked_from, so its window
+# NAME (<kind>-<office>-<n>) still answers for it — without that, a pane parked
+# the day before an update would be running and unreachable.
+_office_parked() {                     # <session>
+  tmux list-panes -s -t "=$_OFFICE_STASH" -F $'#{window_id}\t#{@office_parked_from}\t#{window_name}\t#{@office_label}' 2>/dev/null \
+    | awk -F'\t' -v s="$1" -v ls="${(L)1}" '$2==s || ($2=="" && $3 ~ "-" ls "-[0-9]+$") {print $1 "\t" ($4=="" ? $3 : $4)}'
+}
+
+# Bring a parked pane back into the grid. It takes the "what next?" pane's cell
+# when there is one, and a new cell otherwise.
+_office_unhide() {                     # <session> <stash-window-id>
+  local s=$1 p ph
+  p=$(tmux list-panes -t "$2" -F '#{pane_id}' 2>/dev/null | head -1)
+  [[ -n $p ]] || return 1
+  ph=$(_office_pane_of_kind "$s" NEW)
+  if [[ -z $ph ]] && (( $(tmux list-panes -t "=$s" 2>/dev/null | wc -l) >= _OFFICE_MAX_PANES )); then
+    _office_say "the office is full ($_OFFICE_MAX_PANES panes) — close one with Ctrl-Space q or park one with x"
+    return 0
+  fi
+  tmux join-pane -d -s "$p" -t "$(_office_last_pane "$s")" 2>/dev/null || return 1
+  tmux set -p -t "$p" -u @office_parked_from 2>/dev/null
+  [[ -n $ph ]] && tmux kill-pane -t "$ph" 2>/dev/null
+  _office_grid "$s"
+  tmux select-pane -t "$p" 2>/dev/null
+  return 0
 }
 
+# the pane tmux lists LAST, which is the one a new pane is split from: the new
+# one lands after it in tmux's order, so the grid adds it at the end.
+_office_last_pane() { tmux list-panes -t "=$1" -F '#{pane_id}' 2>/dev/null | tail -1 }
+
 # a short label for the bottom strip: repo name + current branch
 _office_strip_title() {
   local b; b=$(git -C "$1" branch --show-current 2>/dev/null)
   print -r -- "SHELL · $(basename "$1")${b:+ · $b}"
 }
 
-# The cockpit. ONE window. LEFT: the agents that write code (claude, codex,
-# whatever OFFICE_SESSION_CMD points at) —
-# three of them, open and ready. The RIGHT strip holds everything you glance at,
-# and every one of those four is a toggle:
-#
-#   +-------------------------------+-----------+
-#   |  CLAUDE                       | CHAT      |  ^Sc  (opens on demand)
-#   +-------------------------------+-----------+
-#   |  CLAUDE 2                     | SHELL     |  ^Ss
-#   |                               +-----------+
-#   |                               | FILE ED.  |  ^Se
-#   +-------------------------------+-----------+
-#
-# CHAT (^Sc) is the one pane that starts closed: point OFFICE_CHAT_CMD at your
-# own agent's chat command first, or it is just another shell.
+# The office. ONE window, and it starts as ONE pane that asks what it should be:
+# an agent (every OFFICE_AGENTS entry), a shell, or the file editor. Ctrl-Space n
+# asks the same question for every pane after it, up to the grid's six.
 #
-# ^Sn adds a session to the left column, ^Sq closes whatever pane you are on.
-_OFFICE_DEFAULT_DESKS=${OFFICE_DEFAULT_DESKS:-1}
+# The question is tmux's own menu, and a menu needs a CLIENT to draw on. The
+# office is built before you are attached to it, and `office on` can spend
+# seconds on OFFICE_ON_CMD in between, so the first pane waits for a client
+# rather than asking into nothing.
+_OFFICE_WAIT_CMD="zsh -ic 'source \"$_OFFICE_HOME/office.zsh\"; _office_wait'"
+_office_wait() {
+  local i
+  for (( i = 0; i < 600; i++ )); do     # a minute, at most, for you to walk in
+    [[ $(tmux display -p -t "$TMUX_PANE" '#{session_attached}' 2>/dev/null) == 0 ]] || break
+    sleep 0.1
+  done
+  while :; do
+    clear
+    print -P "\n  %F{240}what should this pane be?  any key shows the list again.%f"
+    [[ $(tmux display -p -t "$TMUX_PANE" '#{session_attached}' 2>/dev/null) == 0 ]] || office new
+    read -rsk 1 || break
+  done
+}
+
 _office_open() {                       # <repo-path>
   local dir=$1 s
   s=$(_office_sessfor "$dir")
   if ! tmux has-session -t "=$s" 2>/dev/null; then
-    local main editor strip n prev chat
-    main=$(tmux new-session -d -s "$s" -c "$dir" -n office -P -F '#{pane_id}' "$OFFICE_SESSION_CMD$_OFFICE_DESK_END")
+    local main
+    main=$(tmux new-session -d -s "$s" -c "$dir" -n office -P -F '#{pane_id}' "$_OFFICE_WAIT_CMD")
     # what makes the name above answerable later: which checkout this office is
     # rooted in, on the session itself.
     tmux set -t "$s" @office_root "${dir:A}" 2>/dev/null
     [[ $s == $(_office_sessname "$dir") ]] \
       || _office_say "another repo already holds that name -- this office is \"$s\"."
-    _office_label "$main" "$OFFICE_SESSION_LABEL" CLAUDE
-    # the right strip first, at OFFICE_STRIP_WIDTH: these are glance surfaces, and
-    # width once here is what leaves the sessions a full-width column.
-    strip=$(tmux split-window -h -l ${OFFICE_STRIP_WIDTH}% -t "$main" -c "$dir" -P -F '#{pane_id}')
-    _office_label "$strip" "$(_office_strip_title "$dir")" SHELL
-    # then the chat, once you have given it something to run. -b: ABOVE the
-    # shell, at the top of the strip, because it is the pane you talk to.
-    if (( OFFICE_CHAT_OPEN )); then
-      chat=$(tmux split-window -v -b -t "$strip" -c "$dir" -P -F '#{pane_id}' "$OFFICE_CHAT_CMD")
-      _office_label "$chat" "$OFFICE_CHAT_LABEL" CHAT
-    fi
-    # the file editor comes up too, at the bottom: everyone needs a file open
-    # sooner or later, and it is the pane you reach for least.
-    editor=$(tmux split-window -v -t "$strip" -c "$dir" -P -F '#{pane_id}' "$_OFFICE_EDITOR_CMD")
-    _office_label "$editor" "FILE EDITOR" EDITOR
-    # three panes from three splits are 50/25/25. Even them, the same way every
-    # toggle does, so the default office looks deliberate.
-    _office_even_column "$s" right
-    # the rest of the sessions, stacked down the left. Split the one just made,
-    # not the tallest — otherwise desk 3 lands between 1 and 2 and the labels lie.
-    local prev=$main
-    # C-style, not {2..$N}: zsh counts a brace range DOWNWARDS when the start
-    # is past the end, so a single-desk default would silently open three.
-    for (( n = 2; n <= _OFFICE_DEFAULT_DESKS; n++ )); do
-      prev=$(tmux split-window -v -t "$prev" -c "$dir" -P -F '#{pane_id}' "$OFFICE_SESSION_CMD$_OFFICE_DESK_END")
-      _office_label "$prev" "$OFFICE_SESSION_LABEL $n" CLAUDE
-    done
-    _office_even_desks "$s"
-    _office_number "$s"
-    tmux select-pane -t "$main"
+    _office_label "$main" NEW NEW
   fi
   cd "$dir"
   _office_number "$s"                  # also writes the key strip
@@ -1062,88 +901,87 @@ _office_agent_index() {                # <label-or-index> -> index, or fail
   return 1
 }
 
-# 2+ agents and none named: ask, natively, instead of guessing. Every item
-# re-enters `office new --agent <n>` — the exact call the binding makes once
-# you pick one — so the menu is not a second way to open a desk, it is the
-# same one called a second time.
+# Is there room for one more pane? A "what next?" pane always has room: the
+# answer takes its cell.
+_office_room() {                       # <session>
+  [[ -n $(_office_pane_of_kind "$1" NEW) ]] && return 0
+  (( $(tmux list-panes -t "=$1" 2>/dev/null | wc -l) < _OFFICE_MAX_PANES )) && return 0
+  _office_say "the office is full ($_OFFICE_MAX_PANES panes) — Ctrl-Space q closes one, x parks one"
+  return 1
+}
+
+# The one question: what the next pane is. Parked panes first, because they are
+# already running and a parked pane nobody can find is why they are on this list
+# at all; then every OFFICE_AGENTS entry; then a shell and the file editor. Every
+# item re-enters `office new` with the answer, which is also the typed door.
+#
+# One file editor at a time: it follows the SHELL pane's directory, and two lists
+# following the same shell are one list twice.
 #
 # Needs a CLIENT to draw on: a run-shell binding has none of its own (it is
-# detached), which is why `bind n` hands one down as OFFICE_CLIENT. Typed in a
-# shell inside tmux there already is one attached, tmux finds it unaided, and
-# -c is left off.
-_office_agent_menu() {                 # [worktree-name] -> ()
-  local dir=$PWD i n=${#OFFICE_AGENTS} extra="" lbl
+# detached), which is why `bind n` hands one down as OFFICE_CLIENT. From inside
+# a pane there already is one, and -c is left off.
+_office_menu() {                       # <session>
+  local s=$1 dir=$PWD i n=${#OFFICE_AGENTS} line
   local client=$OFFICE_CLIENT; unset OFFICE_CLIENT
-  (( n > 9 )) && n=9                    # menu keys are the digits 1-9, no more
-  [[ -n $1 ]] && extra=" ${(q)1}"
-  # ponytail: $dir goes into a tmux FORMAT unescaped below (name/command both
-  # are one) — fine for an ordinary path, and a literal '#' in one would need
-  # the same stripping _office_label already does, if that ever bites.
-  local -a items menu_c
+  # ponytail: $dir goes into a tmux command unescaped — fine for an ordinary
+  # path; a quote or a '#' in one would need escaping, if that ever bites.
+  local run="run-shell -b \"OFFICE_SESSION='$s' OFFICE_PANE_PATH='$dir' zsh -ic 'office new"
+  local -a items menu_c keys=(a b c d f g h i j k)   # s and e are taken below
+  for line in ${(f)"$(_office_parked "$s")"}; do
+    (( $#items / 3 < $#keys )) || break
+    items+=("back: ${${line#*$'\t'}//\#/}" "${keys[$#items / 3 + 1]}" "$run --back ${line%%$'\t'*}'\"")
+  done
+  (( $#items )) && items+=("")          # one empty name is a separator
+  (( n > 9 )) && n=9                    # the keys are the digits 1-9, no more
   for (( i = 1; i <= n; i++ )); do
-    lbl=$(_office_agent_label "$i")
-    items+=(
-      "${lbl//\#/}" "$i"
-      "run-shell -b \"OFFICE_PANE_PATH='$dir' zsh -ic 'office new --agent $i$extra'\""
-    )
+    items+=("$(_office_agent_label $i | tr -d '#')" "$i" "$run --agent $i'\"")
   done
+  items+=("" "shell" s "$run --shell'\"")
+  [[ -n $(_office_pane_of_kind "$s" EDITOR) ]] || items+=("file editor" e "$run --edit'\"")
   [[ -n $client ]] && menu_c=(-c "$client")
-  tmux display-menu $menu_c -T "#[align=centre] new desk " -x P -y P $items 2>/dev/null
+  # -M so a click picks an item: without it tmux lets only a menu opened FROM a
+  # mouse binding take the mouse. -M is tmux 3.5+, and 3.4 refuses the whole
+  # command, so it gets the menu without the click rather than no menu at all.
+  tmux display-menu -M $menu_c -T "#[align=centre] open " -x P -y P $items 2>/dev/null \
+    || tmux display-menu $menu_c -T "#[align=centre] open " -x P -y P $items 2>/dev/null
 }
 
-_office_new() {                        # [--agent <label|index>] [worktree-name] -> extra session
-  local root wt dir label s agent=""
-  if [[ $1 == --agent ]]; then
-    agent=$(_office_agent_index "$2") || { print -u2 "office: no such agent '$2'"; return 1 }
-    shift 2
-  fi
-  root=$(_office_root "$PWD"); wt="$root/$OFFICE_WORKTREE_DIR"
-
+_office_new() {                        # [--agent <a> [wt] | --shell | --edit | --back <window>]
+  local s root wt dir label agent=1
   s=$(_office_here)
   tmux has-session -t "=$s" 2>/dev/null \
     || { _office_say "no office open — run 'office on' first"; return 0 }
-  # The cap belongs here too. Only _office_add_pane counted, so this command
-  # walked past it and split a fifth desk into a column sized for four — and it
-  # is the door Ctrl-Space n uses now. Asked before anything is created, so a
-  # full column never leaves a worktree behind for a pane that never opened.
-  if (( $(_office_desk_count "$s") >= _OFFICE_MAX_DESKS )); then
-    _office_say "left column is full ($_OFFICE_MAX_DESKS sessions) — close one with Ctrl-Space q"
-    return 0
-  fi
-
-  # More than one agent and none named: Ctrl-Space n always asks, rather than
-  # guessing which one you meant.
-  if [[ -z $agent ]]; then
-    (( ${#OFFICE_AGENTS} > 1 )) && { _office_agent_menu "$@"; return }
-    agent=1
-  fi
+  # Asked before anything is created, so a full office never leaves a worktree
+  # behind for a pane that never opened.
+  _office_room "$s" || return 0
+  case $1 in
+    '')      _office_menu "$s"; return 0 ;;
+    --back)  _office_unhide "$s" "$2" || _office_say "that pane is not parked any more"; return 0 ;;
+    --shell) _office_add_pane "$(_office_strip_title "$PWD")" 'exec zsh' "$PWD" SHELL; return ;;
+    --edit)  _office_add_pane "FILE EDITOR" "$_OFFICE_EDITOR_CMD" "$PWD" EDITOR; return ;;
+    --agent) agent=$(_office_agent_index "$2") || { print -u2 "office: no such agent '$2'"; return 1 }
+             shift 2 ;;
+  esac
+  # The office's own checkout, never the directory this was pressed in: pressed
+  # from an agent that sits in desk-3, the repo root of $PWD is desk-3 itself, and
+  # a worktree made from there nests inside it.
+  root=$(tmux show -t "$s" -qv @office_root 2>/dev/null)
+  [[ -d $root ]] || root=$(_office_root "$PWD")
+  wt="$root/$OFFICE_WORKTREE_DIR"
 
   if [[ -z $1 ]]; then
-    # Typed in a shell, the picker asks. From a keybinding there is no terminal
-    # to ask on and a prompt on the status bar is the thing this project already
-    # threw out, so it takes a free worktree or makes one.
-    if [[ -t 1 ]]; then
-      dir=$( { print -r -- "$root"; [[ -d $wt ]] && fd --type d --max-depth 1 . "$wt" 2>/dev/null; } \
-             | sed 's|/$||' | fzf --prompt='session in> ' --height=40% --reverse) || return
-    else
-      dir=$(_office_free_wt "$root" "$s")
-      # Nothing git could give: not a repo, no commit to branch from, a worktree
-      # that would not add. The key still has to open a session — a key that
-      # does nothing reads as broken — so it opens one here, and the line at the
-      # bottom says what sharing a checkout means.
-      [[ -n $dir ]] || dir=$root
-    fi
+    # The first agent works in the checkout itself. Every one after it gets its
+    # OWN worktree — a free one, or a new desk-N — so two agents never commit
+    # over each other on one branch. Nothing git could give (not a repo, no
+    # commit yet) still opens the agent: a pick that does nothing reads as broken.
+    _office_desk_in "$s" "$root" && dir=$(_office_free_wt "$root" "$s")
+    [[ -n $dir ]] || dir=$root
   elif [[ -d $wt/$1 ]]; then dir="$wt/$1"
   elif [[ -d $1 ]];    then dir=$(cd "$1" && pwd)
   else
-    # No worktree by that name yet, so make one. This used to be an error, and
-    # the error was the whole problem: the one command that promises a session
-    # which cannot collide with the others worked only if some OTHER tool had
-    # already created the checkout. So you went back to the shell, and the
-    # cheaper thing to type is another session in the repo you are already in —
-    # which is exactly the collision, two agents committing over each other on
-    # one branch. Creating is additive: a branch and a directory, nothing
-    # touched in the checkout you are standing in.
+    # No worktree by that name yet, so make one. Creating is additive: a branch
+    # and a directory, nothing touched in the checkout you are standing in.
     git -C "$root" rev-parse --git-dir >/dev/null 2>&1 \
       || { print -u2 "office: no directory '$1', and $root is not a git repo"; return 1 }
     dir="$wt/$1"
@@ -1154,87 +992,55 @@ _office_new() {                        # [--agent <label|index>] [worktree-name]
       || { print -u2 "office: could not create worktree '$1'"; return 1 }
     print -r -- "office: new worktree $dir"
   fi
-  local acmd alabel; acmd=$(_office_agent_cmd "$agent"); alabel=$(_office_agent_label "$agent")
-  label=$(basename "$dir")
-  [[ $dir == "$root" ]] && label="$alabel" || label="$alabel · $label"
-
-  # Picking the repo root out of the picker lands in the checkout a session is
-  # usually already in, which is the collision this command exists to avoid.
-  local shared=0
-  _office_desk_in "$s" "$dir" && shared=1
-
-  # split the tallest desk in the left column, so agents stack down the left and
-  # the right strip keeps its width
-  local newp
-  newp=$(tmux split-window -v -t "$(_office_desk_pane "$s")" -c "$dir" -P -F '#{pane_id}' "$acmd$_OFFICE_DESK_END")
-  _office_label "$newp" "$label" CLAUDE
-  _office_even_desks "$s"
-  # `_office_add_pane` has always ended this way and this one did not, so a desk
-  # opened by `office new` sat there with a blank number on its border and a key
-  # bar still describing the pane set from before it existed — until some other
-  # office command happened to renumber. Nothing calls renumber on a timer.
-  _office_number "$s"
-  (( shared )) && _office_say "$_OFFICE_SHARED_MSG"
-  # not inside tmux and not on a terminal (a run-shell keybinding) — nothing to attach to
-  [[ -n $TMUX || ! -t 1 ]] || _office_attach "$s"
+  label=$(_office_agent_label "$agent")
+  [[ $dir == "$root" ]] || label+=" · ${dir:t}"
+  _office_add_pane "$label" "$(_office_agent_cmd "$agent")$_OFFICE_DESK_END" "$dir" CLAUDE
 }
 
-# add a pane running <command>. A ranked kind (CHAT/SHELL/EDITOR) lands in the
-# right strip, in its place; anything else is a desk in the left column, which
-# is capped and re-evened.
+# Add a pane running <command>: into the "what next?" pane's cell when there is
+# one, else a new cell at the end of the grid.
 _office_add_pane() {                   # <label> <command> [dir] [kind]
-  local s newp dir=${3:-$PWD} kind=${4:-${1}}
-  local -a slot
+  local s newp dir=${3:-$PWD} kind=${4:-$1} shared=0
   s=$(_office_here)
   tmux has-session -t "=$s" 2>/dev/null \
     || { _office_say "no office open — run 'office on' first"; return 0 }
-  if [[ $(_office_rank "$kind") == 9 ]] && (( $(_office_desk_count "$s") >= _OFFICE_MAX_DESKS )); then
-    _office_say "left column is full ($_OFFICE_MAX_DESKS sessions) — close one with Ctrl-Space q"
-    return 0
+  _office_room "$s" || return 0
+  # Two agents in one checkout is the single way this bites: same branch, same
+  # files, and both borders right. Legitimate (one reads while one writes), so it
+  # is said, never blocked. Asked BEFORE the pane exists, or it counts itself.
+  [[ $kind == CLAUDE ]] && _office_desk_in "$s" "$dir" && shared=1
+  newp=$(_office_pane_of_kind "$s" NEW)
+  if [[ -n $newp ]]; then
+    tmux respawn-pane -k -t "$newp" -c "$dir" "$2" 2>/dev/null || return 1
+  else
+    newp=$(tmux split-window -t "$(_office_last_pane "$s")" -c "$dir" -P -F '#{pane_id}' "$2") || return 1
   fi
-  # Asked BEFORE the split and said after, so it is the last thing on the status
-  # line rather than something the relayout overwrites.
-  local shared=0
-  [[ $(_office_rank "$kind") == 9 ]] && _office_desk_in "$s" "$dir" && shared=1
-  slot=($(_office_place "$s" "$kind"))
-  newp=$(tmux split-window ${slot[2,-1]} -t "${slot[1]}" -c "$dir" -P -F '#{pane_id}' "$2") || return 1
   _office_label "$newp" "$1" "$kind"
-  _office_layout_ok "$s" || _office_relayout "$s"
-  _office_even_column "$s" left; _office_even_column "$s" right
-  _office_number "$s"
+  _office_grid "$s"
+  tmux select-pane -t "$newp" 2>/dev/null
   (( shared )) && _office_say "$_OFFICE_SHARED_MSG"
   # not inside tmux and not on a terminal (a run-shell keybinding) — nothing to attach to
   [[ -n $TMUX || ! -t 1 ]] || _office_attach "$s"
 }
 
-# ONE verb for the three panes that come and go: on screen -> stash it;
-# stashed -> put it back; never existed -> make it.
-_office_toggle() {                     # <kind> <label> <command>
-  local s p root; root=$(_office_root "$PWD"); s=$(_office_here)
-  tmux has-session -t "=$s" 2>/dev/null \
-    || { _office_say "no office open — run 'office on' first"; return 0 }
-  p=$(_office_pane_of_kind "$s" "$1")
-  # A pane that quit its job and left a bare prompt behind is not a pane to
-  # hide. Pressing its key means "give it back", so give it back.
-  if [[ -n $p ]]; then
-    _office_revive "$p" "$3" && return
-    _office_hide "$p"; return
-  fi
-  if _office_unhide "$s" "$1"; then
-    _office_revive "$(_office_pane_of_kind "$s" "$1")" "$3"   # parked while dead
-    return
+# Drag a pane's title onto another pane and it moves there; the panes in between
+# shift one place to make room. tmux has no "move to cell", so it is a row of
+# neighbour swaps, and the grid is rebuilt around the new order. The mouse half
+# lives in office.tmux.conf.
+_office_move() {                       # <pane> <onto-pane>
+  local s from to i
+  local -a ids
+  s=$(tmux display -p -t "$1" '#{session_name}' 2>/dev/null)
+  [[ -n $s && $s == $(tmux display -p -t "$2" '#{session_name}' 2>/dev/null) ]] || return 1
+  ids=(${(f)"$(tmux list-panes -t "=$s" -F '#{pane_id}' 2>/dev/null)"})
+  from=${ids[(ie)$1]}; to=${ids[(ie)$2]}
+  (( from <= $#ids && to <= $#ids && from != to )) || return 0
+  if (( from < to )); then
+    for (( i = from; i < to; i++ )); do tmux swap-pane -d -s "$1" -t "${ids[i+1]}" 2>/dev/null; done
+  else
+    for (( i = from; i > to; i-- )); do tmux swap-pane -d -s "$1" -t "${ids[i-1]}" 2>/dev/null; done
   fi
-  _office_add_pane "$2" "$3" "$root" "$1"
-}
-
-# Put a pane that gave up back to work. The job marks itself dead on the way out
-# (@office_live 0), so this never guesses from process names and can never kill
-# a pane that is still running something.
-_office_revive() {                     # <pane> <command> -> 0 if it was revived
-  [[ -n $1 ]] || return 1
-  [[ $(tmux display -p -t "$1" '#{@office_live}' 2>/dev/null) == 0 ]] || return 1
-  tmux set -p -t "$1" @office_live '' 2>/dev/null
-  tmux respawn-pane -k -t "$1" "$2" 2>/dev/null || return 1
+  _office_grid "$s"
   tmux select-pane -t "$1" 2>/dev/null
   return 0
 }
@@ -1336,65 +1142,40 @@ _office_help() {
   print -P "                 ${d}agent in it. Other offices keep running.${r}"
   print -P "  ${g}office off --all${r} ${d}...and every other office too${OFFICE_OFF_CMD:+, and runs '$OFFICE_OFF_CMD'}. Both ask first.${r}\n"
 
-  print -P "${g}WHAT YOU GET${r} ${d}— ONE window. Everything visible at once.${r}"
-  print -P "    ${d}┌─────────────────────────────┬──────────────┐${r}"
-  print -P "    ${d}│${r} ${g}$OFFICE_SESSION_LABEL${r}                      ${d}│${r} ${g}$OFFICE_CHAT_LABEL${r}   ${d}│${r} ${g}^Space c${r}"
-  print -P "    ${d}├─────────────────────────────┼──────────────┤${r}"
-  print -P "    ${d}│${r} ${g}$OFFICE_SESSION_LABEL 2${r}   ${d}^Space n adds${r}  ${d}│${r} ${g}SHELL${r}        ${d}│${r} ${g}^Space s${r}"
-  print -P "    ${d}│${r}              ${d}one more${r}       ${d}├──────────────┤${r}"
-  print -P "    ${d}│${r}                             ${d}│${r} ${g}FILE EDITOR${r}  ${d}│${r} ${g}^Space e${r}"
-  print -P "    ${d}└─────────────────────────────┴──────────────┘${r}"
-  print -P "    ${d}  the agents that build it        the agent${r}"
-  print -P "    ${d}  claude / codex / your own       you built${r}"
-  print -P "  ${d}LEFT is whatever OFFICE_SESSION_CMD points at, up to four, kept even.${r}"
-  print -P "  ${d}RIGHT is a shell, an editor, and a chat wired to the agent YOU built:${r}"
-  print -P "  ${d}give OFFICE_CHAT_CMD a command and that pane is your control surface,${r}"
-  print -P "  ${d}with no dashboard to stand up and no Slack app to register.\n${r}"
-
-  print -P "${g}THE KEYS${r} ${d}— two rules, and the second one covers everything${r}"
-  print -P "  ${g}Shift-←↑↓→${r}         move between panes"
-  print -P "  ${d}...and Ctrl-Space, then one letter:${r}"
-  print -P "  ${g}n${r}    a new session            ${d}its own worktree, left column, max 4${r}"
-  print -P "  ${g}c${r}    toggle the CHAT          ${g}s${r}  toggle the SHELL"
-  print -P "  ${g}e${r}    toggle the FILE EDITOR   ${g}a${r}  park/restore ALL sessions"
-  print -P "  ${g}q${r}    CLOSE this pane          ${g}x${r}  park it, still running"
-  print -P "  ${g}z${r}    zoom this pane           ${g}m${r}  mouse reporting on/off"
-  print -P "  ${g}←↑↓→${r} move too                  ${d}the one way out of an open file${r}"
-  print -P "  ${g}|${r} ${g}-${r}  split raw               ${g}X${r}  close the whole office"
-  print -P "  ${g}Enter${r}  scrollback / copy mode  ${g}r${r}  reload the tmux config"
-  print -P "  ${d}Only the arrows are a chord, because they carry their modifier natively.${r}"
-  print -P "  ${d}Everything else is the prefix: no terminal setup, same on every OS.${r}"
-  print -P "  ${d}A border shows what that pane is, and 'your turn' when it is waiting on${r}"
-  print -P "  ${d}you. The keys are all on the bar. Or just click a pane with the mouse:${r}"
-  print -P "  ${d}drag across text to copy it, or double-click a word — either way it${r}"
-  print -P "  ${d}is on the clipboard when you let go.
-${r}"
+  print -P "${g}WHAT YOU GET${r} ${d}— ONE window, and it starts as one pane that asks what it is${r}"
+  print -P "    ${d}┌──────────────┬──────────────┬──────────────┐${r}"
+  print -P "    ${d}│${r} ${g}1 CLAUDE${r}     ${d}│${r} ${g}3 CODEX${r}      ${d}│${r} ${g}5 SHELL${r}      ${d}│${r}"
+  print -P "    ${d}├──────────────┼──────────────┤              │${r}"
+  print -P "    ${d}│${r} ${g}2 CLAUDE${r}     ${d}│${r} ${g}4 FILE EDITOR${r}${d}│${r}              ${d}│${r}"
+  print -P "    ${d}└──────────────┴──────────────┴──────────────┘${r}"
+  print -P "  ${d}Every pane is what you picked: any OFFICE_AGENTS entry, a shell, or the${r}"
+  print -P "  ${d}file editor. Three across and two down at most, six in all, kept even.${r}\n"
+
+  print -P "${g}THE KEYS${r} ${d}— that is all of them${r}"
+  print -P "  ${g}Ctrl-Space n${r}   one more pane. A list: parked panes, your agents, shell, editor"
+  print -P "  ${g}Ctrl-Space x${r}   park this pane. It keeps running; ^Space n brings it back"
+  print -P "  ${g}Ctrl-Space q${r}   close this pane"
+  print -P "  ${g}Ctrl-Space z${r}   zoom this pane, and back"
+  print -P "  ${g}Shift-←↑↓→${r}     move between panes"
+  print -P "  ${g}drag a title${r}   onto another pane to move it there; the rest shift along"
+  print -P "  ${d}Drag across text to copy it, or double-click a word — it is on the${r}"
+  print -P "  ${d}clipboard when you let go. A border shows what that pane is, and 'your${r}"
+  print -P "  ${d}turn' when an agent is waiting on you.\n${r}"
 
   print -P "${g}RUNNING SEVERAL AGENTS${r} ${d}— the whole point of this setup${r}"
-  print -P "  ${g}Ctrl-Space n${r}   One more session, in its OWN git worktree — a free one, or a"
-  print -P "                 ${d}new desk-N. Press it 2-4x: the left column splits evenly and${r}"
-  print -P "                 ${d}each agent edits a separate checkout, so they never collide.${r}"
+  print -P "  ${g}agents${r}         The first one works in the checkout. Every one after it gets"
+  print -P "                 ${d}its OWN git worktree — a free one, or a new desk-N — so they${r}"
+  print -P "                 ${d}never commit over each other. OFFICE_AGENTS lists what is offered.${r}"
   print -P "  ${g}your turn${r}      Which one is waiting on you: a desk that has not moved for"
   print -P "                 ${d}${OFFICE_ATTN_SECS}s says so on its own border, and how long it has been${r}"
   print -P "                 ${d}waiting. Nothing to press. OFFICE_ATTN_SECS changes the wait.${r}"
   print -P "  ${g}412k${r}           How full that desk's context window is, on its border. Quiet"
-  print -P "                 ${d}below $(( OFFICE_CTX_WARN / 1000 ))k, then the accent, then the alarm at $(( OFFICE_CTX_ALARM / 1000 ))k — so you${r}"
-  print -P "                 ${d}see which one to compact without walking into it to ask.${r}"
+  print -P "                 ${d}below $(( OFFICE_CTX_WARN / 1000 ))k, then the accent, then the alarm at $(( OFFICE_CTX_ALARM / 1000 ))k.${r}"
   print -P "                 ${d}OFFICE_CTX_WARN / _ALARM move the marks. Claude Code only.${r}"
-  print -P "  ${g}office new X${r}   Straight into worktree X — created if it is not there yet."
-  print -P "  ${g}--agent A${r}      With OFFICE_AGENTS set to 2+, name one by label or number;"
-  print -P "                 ${d}Ctrl-Space n asks with a menu instead. One agent, no menu.${r}"
+  print -P "  ${g}office new --agent A [X]${r}  Agent A (label or number), in worktree X if named."
   print -P "  ${g}office task X${r}  A new session already working on X."
-  print -P "  ${g}office desk${r}    One more session in THIS checkout, when you mean it: two"
-  print -P "                 ${d}agents on one branch, which the status line says out loud.${r}"
-  print -P "                 ${d}Four desks is the cap, whichever door you use.${r}"
-  print -P "  ${g}office edit${r}    Toggle the FILE EDITOR pane — fuzzy-pick a file, edit it in place."
-  print -P "                 ${d}Ctrl-S saves · Ctrl-Z undo · mouse works.${r}"
-  print -P "                 ${d}Ctrl-Q closes the FILE and returns you to the list;${r}"
-  print -P "                 ${d}Esc at the list leaves the editor. Ctrl-Space e hides the pane.${r}"
-  print -P "  ${g}office chat${r}    Toggle the $OFFICE_CHAT_LABEL pane. ${d}Ctrl-Space c inline.${r}"
-  print -P "  ${g}office shell${r}   Toggle the SHELL pane. ${d}Ctrl-Space s inline.${r}"
-  print -P "                 ${d}Toggled-off panes keep running — nothing is killed.${r}\n"
+  print -P "  ${g}office desk${r}    One more session in THIS checkout, when you mean it."
+  print -P "  ${g}office show${r}    Pick a parked pane and bring it back.\n"
 
   print -P "${g}KEEPING IT LEAN${r} ${d}— nothing ever dies on its own, so check now and then${r}"
   print -P "  ${g}office doctor${r}  What is running and what it costs in RAM. Read-only,"
@@ -1425,12 +1206,9 @@ ${r}"
   print -P "                 ${d}Use when you want the panes without the rest.${r}\n"
 
   print -P "${g}EDITING FILES${r} ${d}— no vim knowledge required${r}"
-  print -P "  ${g}edit${r} / ${g}e${r}       Fuzzy-pick a file and edit it. Files you have changed"
-  print -P "                 ${d}are listed first. Ctrl-S save · Ctrl-Q quit · Ctrl-Z undo${r}"
-  print -P "                 ${d}Ctrl-F find · mouse and normal copy-paste all work.${r}"
-  print -P "  ${g}edit <file>${r}    Open (or create) that file directly."
-  print -P "  ${g}office edit${r}    A dedicated FILE EDITOR pane. ${d}Ctrl-Space e does it inline.${r}"
-  print -P "  ${g}n${r}              Neovim instead, when you want the full IDE.\n"
+  print -P "  ${g}file editor${r}    ^Space n, then e. Fuzzy-pick a file and edit it in place;"
+  print -P "                 ${d}the list follows the shell pane. Ctrl-S save · Ctrl-Q back to${r}"
+  print -P "                 ${d}the list · Ctrl-Z undo · Ctrl-F find · the mouse works.\n${r}"
 
   print -P "${g}IF YOU FORGET ONE THING, REMEMBER THIS${r}"
   print -P "  Closing the window never kills anything. ${g}office on${r} always brings"
@@ -1481,41 +1259,6 @@ office() {
       shift
       (( $# )) || { print -u2 "usage: office task <what you want done>"; return 1 }
       _office_add_pane "$OFFICE_SESSION_LABEL · $*" "$OFFICE_SESSION_CMD ${(q)*}$_OFFICE_DESK_END" "$(_office_root "$PWD")" CLAUDE ;;
-    # the three right-strip panes are TOGGLES: same word closes what it opened.
-    chat|talk)
-      _office_toggle CHAT   "$OFFICE_CHAT_LABEL" "$OFFICE_CHAT_CMD" ;;
-    shell|sh|term)
-      _office_toggle SHELL  "$(_office_strip_title "$(_office_root "$PWD")")" 'exec zsh' ;;
-    edit|editor|files)
-      # loop the picker: quitting a file (Ctrl-Q) drops you back at the file
-      # list, not at a shell. Esc at the list is how you actually leave.
-      _office_toggle EDITOR "FILE EDITOR" "$_OFFICE_EDITOR_CMD" ;;
-    sessions|desks)
-      # the whole left column, in one key. Park them all, or bring them all back.
-      local s p n=0
-      s=$(_office_here)
-      for p in ${(f)"$(tmux list-panes -t "=$s" -F '#{pane_id}|#{@office_kind}' 2>/dev/null | awk -F'|' '$2=="CLAUDE"{print $1}')"}; do
-        [[ -n $p ]] || continue
-        _office_hide "$p"; (( ++n ))
-      done
-      (( n )) && { _office_number "$s"; return }
-      # Restoring is bounded by the cap, not by what happens to be in the stash:
-      # sessions parked one at a time weeks ago should not all come flooding
-      # back because you pressed the group toggle.
-      local back=0
-      while (( $(_office_desk_count "$s") < _OFFICE_MAX_DESKS )); do
-        _office_unhide "$s" CLAUDE || break
-        # ++back, never back++ — see _office_unzoom: a post-increment on 0 is
-        # arithmetic-false, and under err_return that is a silent return.
-        (( ++back ))
-      done
-      # Nothing visible and nothing parked: make one. This key must never do
-      # nothing. A silent no-op reads as a broken binding, and the honest answer
-      # to "show me my sessions" when there are none is to open one. Every other
-      # toggle already worked this way; this was the one that did not.
-      (( back )) || _office_add_pane "$OFFICE_SESSION_LABEL" "$OFFICE_SESSION_CMD$_OFFICE_DESK_END" \
-                      "$(_office_root "$PWD")" CLAUDE
-      _office_number "$s" ;;
     install)
       # The verb every tool here shares (zyx, murmurflow): set it up, start nothing.
       # Here that is install.sh, which is idempotent. Without this arm the word fell
@@ -1537,8 +1280,8 @@ office() {
       _office_watch_setup
       print "updated. The next 'office' command in any shell runs the new version;"
       print "panes already open keep what they are running until you close them." ;;
-    renumber)
-      _office_number "$(_office_here)" ;;
+    renumber|grid)
+      _office_grid "$(_office_here)" ;;
     sweep|stale)
       # `office sweep [hours]` — offices nobody has looked at in that long, and
       # everything inside them. Default 12h, so yesterday's office is fair game
@@ -1593,19 +1336,13 @@ office() {
       print -P "%F{green}${pick%%$'\t'*}%f  $dir"
       [[ -n $TMUX && $(tmux display -p '#{@office_kind}' 2>/dev/null) == SHELL ]] \
         || print -P "%F{240}  (the file editor follows the SHELL pane — run this there and it comes along)%f" ;;
-    layout|fix|repair)
-      _office_relayout "$(_office_here)"; print "layout rebuilt." ;;
-    hide|collapse)
+    hide|park)
       _office_hide "${2:-$(tmux display -p '#{pane_id}')}" ;;
-    # NOT also `back`: the case above already answers to `back` (coming back
-    # from a break), and a case statement takes the first match — a second
-    # `back` here was a word the help could promise and the code never reached.
-    show|restore)
-      local s k; s=$(_office_here)
-      k=${2:-$(tmux list-windows -t "=$_OFFICE_STASH" -F '#{window_name}' 2>/dev/null \
-               | fzf --prompt='bring back> ' --height=40% --reverse)}
-      [[ -n $k ]] || return
-      _office_unhide "$s" "${(U)k}" || print -u2 "office: nothing stashed as '$k'" ;;
+    show|restore|unpark)
+      local s pick; s=$(_office_here)
+      pick=$(_office_parked "$s" | fzf --prompt='bring back> ' --height=40% --reverse \
+               --delimiter=$'\t' --with-nth=2) || return
+      _office_unhide "$s" "${pick%%$'\t'*}" ;;
     break|pause|bg|away|brb)
       local -a live; live=(${(f)"$(_office_sessions)"})
       (( $#live )) || { print "office: nothing running"; return }
@@ -1733,6 +1470,10 @@ office() {
       done
       print -P "closed ${#sel} pane(s), %F{green}~${freed}MB%f reclaimed."
       tmux list-sessions >/dev/null 2>&1 || print "  (that was the last one — no offices left)" ;;
+    chat|talk|shell|sh|term|edit|editor|files|sessions|desks|layout|fix|repair)
+      # retired verbs, answered rather than fuzzy-matched as a repo name
+      print -u2 "office: '$cmd' is gone — Ctrl-Space n picks what any pane is (or: office new --shell / --edit)"
+      return 1 ;;
     help|-h|--help)
       _office_help ;;
     *)
diff --git a/theme/office-theme.tmux.conf b/theme/office-theme.tmux.conf
index ff3b0a9..fd14bfd 100644
--- a/theme/office-theme.tmux.conf
+++ b/theme/office-theme.tmux.conf
@@ -36,13 +36,11 @@ set -g status-justify right
 set -g status-interval 5
 set -g status-style "bg=$BAND,fg=$MUTED"
 
-# ...except the keys, because a pane's border carries the chord that toggles it
-# and that is no help once the pane is closed and the border went with it. The
-# bar keeps the whole set and dims what is already open, so what is bright is
-# what is missing. WHITE is the third and last tone, and it means one thing:
-# the way back out of a state you are in - today only zoom, where every other
-# pane is invisible while still counting as open. Clicking it opens a new
-# session.
+# ...except the keys: n new, x park, q close, z zoom, and how to move. All dim;
+# the parked count is a shade brighter, because a parked pane is running and
+# nothing else on screen shows it. WHITE is the last tone, and it means one
+# thing: the way back out of a state you are in - today only zoom, where every
+# other pane is hidden. Clicking the bar opens the same list as Ctrl-Space n.
 #
 # @office_bar is written by office itself, not polled with #(): a polled job is
 # always one interval behind, so the bar would keep calling a pane open until
@@ -68,7 +66,7 @@ set -g status-left-length 120
 # NAME — to mouse_status_range, not the word "user". Compared against "user"
 # this never matched, so the advertised click-to-open silently select-window'd.
 bind -n MouseDown1Status if -F '#{==:#{mouse_status_range},task}' \
-  { run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" zsh -ic 'office desk' >/dev/null 2>&1 || true" } \
+  { run-shell -b "OFFICE_PANE_PATH=\"#{pane_current_path}\" OFFICE_CLIENT=\"#{client_name}\" OFFICE_SESSION=\"#{session_name}\" zsh -ic 'office new' >/dev/null 2>&1 || true" } \
   { select-window -t= }
 
 # Right: the branch, then the clock. Nothing else, on purpose.