nook: split/close pane keybindings via alt+w window leader

Layers the split keybindings onto the 2a render compositor. alt+w arms a
one-shot window-command state; the next key runs a window op (v splits into
columns, s into stacked rows, c closes the focused pane) or disarms. The
leader is read at the top of routeKey, ahead of the global switch, so the
chord's second key is consumed instead of typed into the buffer.

alt+w rather than the vim/tmux ctrl+w: ctrl+w is already close-tab and
several tests press a bare ctrl+w expecting an immediate close, so a prefix
state would break both them and the close-tab muscle memory. alt+w is free
and fits nook's existing alt-leader idiom.

splitPane requires two open buffers (a lone-buffer split would show the same
content twice, which per-pane sizing can't honor) and v1 caps at one split.
closePane drops only the pane binding; the buffer stays open as a tab, so no
bufman reindex is needed and the focus==active invariant holds.

Author: truffle-dev

cmd/nook/main.go

@@ -180,6 +180,12 @@ type model struct {
 	split   *splitlayout.Tree
 	paneBuf map[splitlayout.PaneID]int
 
+	// awaitingWindowKey is the one-shot "window command" leader state. alt+w
+	// arms it; the next key runs a window op (v/s split, c close pane) or
+	// disarms. alt+w is used rather than the vim/tmux ctrl+w so the historical
+	// ctrl+w = close-tab binding stays intact.
+	awaitingWindowKey bool
+
 	gitPane  git.Pane
 	termPane term.Pane
 	picker   picker.Picker
@@ -2127,6 +2133,27 @@ func (m model) routeKey(km tea.KeyMsg) (tea.Model, tea.Cmd) {
 		return m.routeOutline(km)
 	}
 
+	// Window-command leader: alt+w arms awaitingWindowKey, and the very next
+	// key either runs a window op or disarms. This sits ahead of the global
+	// switch so the chord's second key (a plain rune like v/s/c) is consumed
+	// here instead of being typed into the buffer.
+	if m.awaitingWindowKey {
+		m.awaitingWindowKey = false
+		if km.Type == tea.KeyRunes && len(km.Runes) == 1 && !km.Alt {
+			switch km.Runes[0] {
+			case 'v':
+				return m.splitPane(splitlayout.Columns)
+			case 's':
+				return m.splitPane(splitlayout.Rows)
+			case 'c':
+				return m.closePane()
+			}
+		}
+		// Any other key cancels the leader without acting on the workspace.
+		m.status = ""
+		return m, nil
+	}
+
 	// Global keys
 	switch km.Type {
 	case tea.KeyCtrlQ:
@@ -2392,6 +2419,15 @@ func (m model) routeKey(km tea.KeyMsg) (tea.Model, tea.Cmd) {
 			// is reserved by most terminal emulators for paste, so alt+v is
 			// the portable surface.
 			return m.toggleMdPreview()
+		case 'w':
+			// Alt+w is the window-command leader (mnemonic: window). It arms a
+			// one-shot state read at the top of routeKey: the next key runs a
+			// window op. v splits the focused pane into side-by-side columns, s
+			// splits it into stacked rows, c closes the focused pane. Kept off
+			// ctrl+w so the historical close-tab binding survives unchanged.
+			m.awaitingWindowKey = true
+			m.status = "window: v split right · s split down · c close pane"
+			return m, nil
 		case 'y':
 			// Alt+y toggles gopls inlay hints (type annotations + parameter
 			// names) for every open buffer. Hints are visual-only; the
@@ -3953,6 +3989,59 @@ func (m model) closeActiveTab() (tea.Model, tea.Cmd) {
 	return m, cmd
 }
 
+// splitPane divides the focused pane along o and binds the new pane to a
+// different open buffer, so the split immediately shows two files. v1 caps the
+// layout at two panes (one split) and needs at least two open buffers:
+// splitting a lone buffer would show the same content twice, which the
+// per-pane sizing can't honor. The fresh pane takes focus, and its buffer is
+// made active so every existing editing path operates on the focused pane.
+func (m model) splitPane(o splitlayout.Orientation) (tea.Model, tea.Cmd) {
+	if m.split == nil {
+		return m, nil
+	}
+	if m.split.Count() > 1 {
+		m.status = "nook shows two panes in this version — close one with alt+w c"
+		return m, nil
+	}
+	if m.bufs.Count() < 2 {
+		m.status = "open another file to split (ctrl+P)"
+		return m, nil
+	}
+	old := m.split.Focused()
+	m.paneBuf[old] = m.bufs.ActiveIndex()
+	other := (m.bufs.ActiveIndex() + 1) % m.bufs.Count()
+	newID := m.split.SplitFocused(o)
+	m.paneBuf[newID] = other
+	m.bufs.Switch(other)
+	m = m.resize()
+	m = m.applyDiagnosticsToActive()
+	m.status = "split — alt+w c to close the pane"
+	return m, nil
+}
+
+// closePane closes the focused split pane; its space collapses into the
+// sibling. The buffer the pane showed stays open as a tab, so only the pane
+// binding is dropped. Closing the sole remaining pane is refused by the layout
+// tree. After a close the surviving focused pane's buffer becomes active.
+func (m model) closePane() (tea.Model, tea.Cmd) {
+	if m.split == nil {
+		return m, nil
+	}
+	closed := m.split.Focused()
+	if !m.split.CloseFocused() {
+		m.status = "only one pane open"
+		return m, nil
+	}
+	delete(m.paneBuf, closed)
+	if idx, ok := m.paneBuf[m.split.Focused()]; ok {
+		m.bufs.Switch(idx)
+	}
+	m = m.resize()
+	m = m.applyDiagnosticsToActive()
+	m.status = "pane closed"
+	return m, nil
+}
+
 func min(a, b int) int {
 	if a < b {
 		return a

cmd/nook/main_splitpane_test.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"testing"
 
+	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/truffle-dev/glyph/cmd/nook/internal/splitlayout"
 )
@@ -209,3 +210,120 @@ func TestRenderSinglePaneUnchanged(t *testing.T) {
 		t.Error("single-pane renderMainColumn diverged from the active buffer view")
 	}
 }
+
+// altW presses the window-command leader (alt+w) and returns the updated model.
+func altW(m model) model {
+	u, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'w'}, Alt: true})
+	return u.(model)
+}
+
+// runeKey presses a single plain rune (no modifiers) and returns the model.
+func runeKey(m model, r rune) model {
+	u, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+	return u.(model)
+}
+
+// openTwo seeds a model sized for split work with two real buffers open. The
+// keybinding tests start here and then drive the alt+w leader so the split /
+// close handlers are exercised through the same key path a user takes.
+func openTwo(t *testing.T) model {
+	t.Helper()
+	root := fixtureRepo(t)
+	m := newModel(root)
+	m.width = 120
+	m.height = 32
+	m = m.resize()
+	m.bufs.OpenOrSwitch(filepath.Join(root, "a.go"))
+	m.bufs.OpenOrSwitch(filepath.Join(root, "sub", "b.go"))
+	if m.bufs.Count() != 2 {
+		t.Fatalf("want 2 buffers, got %d", m.bufs.Count())
+	}
+	return m
+}
+
+// TestWindowLeaderSplitColumns drives alt+w v and asserts a second column pane
+// appears bound to the other buffer, leaving the leader state disarmed.
+func TestWindowLeaderSplitColumns(t *testing.T) {
+	m := openTwo(t)
+	m = altW(m)
+	if !m.awaitingWindowKey {
+		t.Fatal("alt+w did not arm the window leader")
+	}
+	m = runeKey(m, 'v')
+	if m.awaitingWindowKey {
+		t.Error("window leader still armed after running a window op")
+	}
+	if m.split.Count() != 2 {
+		t.Fatalf("split count = %d, want 2", m.split.Count())
+	}
+	divs := m.split.Dividers(m.editorRegion())
+	if len(divs) != 1 || divs[0].Orient != splitlayout.Columns {
+		t.Errorf("want a single columns divider, got %+v", divs)
+	}
+}
+
+// TestWindowLeaderSplitRows drives alt+w s and asserts a stacked-row split.
+func TestWindowLeaderSplitRows(t *testing.T) {
+	m := openTwo(t)
+	m = altW(m)
+	m = runeKey(m, 's')
+	if m.split.Count() != 2 {
+		t.Fatalf("split count = %d, want 2", m.split.Count())
+	}
+	divs := m.split.Dividers(m.editorRegion())
+	if len(divs) != 1 || divs[0].Orient != splitlayout.Rows {
+		t.Errorf("want a single rows divider, got %+v", divs)
+	}
+}
+
+// TestWindowLeaderClosePane splits then closes via alt+w c, returning to one
+// pane while both buffers stay open as tabs.
+func TestWindowLeaderClosePane(t *testing.T) {
+	m := openTwo(t)
+	m = altW(m)
+	m = runeKey(m, 'v')
+	if m.split.Count() != 2 {
+		t.Fatalf("split count = %d after split, want 2", m.split.Count())
+	}
+	m = altW(m)
+	m = runeKey(m, 'c')
+	if m.split.Count() != 1 {
+		t.Fatalf("split count = %d after close, want 1", m.split.Count())
+	}
+	if m.bufs.Count() != 2 {
+		t.Errorf("closing a pane dropped a buffer: count = %d, want 2", m.bufs.Count())
+	}
+}
+
+// TestWindowLeaderCancels guards the disarm path: alt+w then an unrelated key
+// runs no window op and clears the leader, never splitting.
+func TestWindowLeaderCancels(t *testing.T) {
+	m := openTwo(t)
+	m = altW(m)
+	m = runeKey(m, 'z')
+	if m.awaitingWindowKey {
+		t.Error("unrelated key left the window leader armed")
+	}
+	if m.split.Count() != 1 {
+		t.Errorf("unrelated key after alt+w changed the split: count = %d, want 1", m.split.Count())
+	}
+}
+
+// TestWindowLeaderRefusesSingleBuffer guards the v1 rule that a split needs a
+// second buffer to show; with one buffer open alt+w v is a no-op with a hint.
+func TestWindowLeaderRefusesSingleBuffer(t *testing.T) {
+	root := fixtureRepo(t)
+	m := newModel(root)
+	m.width = 120
+	m.height = 32
+	m = m.resize()
+	m.bufs.OpenOrSwitch(filepath.Join(root, "a.go"))
+	if m.bufs.Count() != 1 {
+		t.Fatalf("want 1 buffer, got %d", m.bufs.Count())
+	}
+	m = altW(m)
+	m = runeKey(m, 'v')
+	if m.split.Count() != 1 {
+		t.Errorf("split with one buffer should be refused, count = %d", m.split.Count())
+	}
+}

docs/nook/design/01-split-panes-host-wiring.md

@@ -123,33 +123,44 @@ the region and show both buffers; a mutation-proof confirms the width guard
 goes red on a doubled divider. **v1 caps at two panes (one split).** A general
 N-pane compositor is deferred until a real use case needs it.
 
-#### Slice 2b — split / close keybindings — NEXT
-
-- **ctrl+w conflict, pinned.** `ctrl+w` is already bound to
-  `closeActiveTab()` (`main.go`, the `tea.KeyCtrlW` case in the global
-  switch). The vim/Zed `ctrl+w <motion>` chord prefix cannot be added
-  naively without stealing that binding. Resolution for 2b: introduce a
-  pending-`ctrl+w` prefix state — the first `ctrl+w` arms it, a following
-  `v`/`s`/`c`/`h`/`j`/`k`/`l`/`w`/`<`/`>` consumes the chord, and any other
-  key (or a second `ctrl+w`) falls back to `closeActiveTab()`. This keeps
-  the existing close-tab muscle memory (bare `ctrl+w`) while layering the
-  window chords on top, exactly as vim does with its own `ctrl+w` prefix.
-- `ctrl+w v` (Columns / split right) and `ctrl+w s` (Rows / split down).
-  On split: `SplitFocused`, bind the new pane to the next open buffer (or
-  the current one if only a single buffer is open), then `bufs.Switch` to it.
-- `ctrl+w c` closes the focused pane: `CloseFocused`, drop the binding,
-  collapse. `CloseFocused` already refuses the last pane.
-- Tests: the prefix arms and disarms correctly; bare `ctrl+w` still closes
-  a tab; split raises pane count and binds a buffer; close refuses the last
-  pane; the binding map stays consistent across split/close cycles.
+#### Slice 2b — split / close keybindings — LANDED
+
+Done, with one decision changed from the plan below. **The window leader is
+`alt+w`, not a pending-`ctrl+w` prefix.** The pinned ctrl+w-prefix idea was
+abandoned because `ctrl+w` is already bound to `closeActiveTab()` and several
+existing tests (`TestTabFlow`, `TestTabFlowDirtyBlocksClose`) press a single
+`ctrl+w` expecting an immediate tab close — a prefix state would have made
+the first `ctrl+w` swallow that close, breaking both the tests and the
+committed promise to preserve close-tab muscle memory. `alt+w` is free, reads
+as "window," and fits nook's existing alt-leader idiom (alt+v markdown
+preview, alt+] / alt+[ tab cycle). `ctrl+w` stays exactly as it was.
+
+- **`alt+w` arms a one-shot `awaitingWindowKey` state.** A handler at the top
+  of `routeKey` reads it before the global switch, so the chord's second key
+  (a plain rune) is consumed there instead of being typed into the buffer.
+  The next key runs a window op or disarms.
+- `alt+w v` (Columns / split right) and `alt+w s` (Rows / split down).
+  `splitPane` requires ≥2 open buffers — a lone-buffer split would show the
+  same content twice, which per-pane sizing cannot honor — and v1 caps at one
+  split (two panes). It binds the new pane to the next open buffer and
+  `bufs.Switch`es to it, keeping the focus==active invariant.
+- `alt+w c` closes the focused pane: `CloseFocused`, drop the `paneBuf`
+  binding, re-switch the active buffer to the surviving pane's binding. The
+  buffer stays open as a tab; only the pane binding drops, so no bufman
+  reindex is needed. `CloseFocused` already refuses the last pane.
+- Tests (`main_splitpane_test.go`): `alt+w v` / `alt+w s` raise pane count and
+  produce the right divider orientation; `alt+w c` returns to one pane with
+  both buffers still open; `alt+w` + an unrelated key disarms without
+  splitting; split is refused with a single buffer; existing `TestTabFlow`
+  confirms bare `ctrl+w` still closes a tab.
 
 ### Slice 3 — focus routing
 
-- `ctrl+w h/j/k/l` → `FocusDir`, then `bufs.Switch` to the focused pane's
-  bound buffer. `ctrl+w w` → `FocusNext`.
+- `alt+w h/j/k/l` → `FocusDir`, then `bufs.Switch` to the focused pane's
+  bound buffer. `alt+w w` → `FocusNext`.
 - Active-pane affordance: brighten the focused pane's divider/border so
   the user can see which split has the cursor.
-- `ctrl+w <` / `ctrl+w >` → `ResizeFocused` to shift the divider.
+- `alt+w <` / `alt+w >` → `ResizeFocused` to shift the divider.
 - If mouse is wired: click → `PaneAt` → focus.
 - Tests: directional focus selects the correct neighbor; focusing a pane
   changes `bufs.ActiveIndex()` to that pane's bound buffer.