fix(tools): Anchor select_pane direction=next/previous to the targeted window

why: window.cmd("select-pane", "-t", "+1") assembles to
`tmux select-pane -t @window_id -t +1`. tmux's args_get() returns
the LAST -t value (arguments.c:675-683), so the effective target
is the bare `+1`. Bare relative pane targets resolve against
`fs->current = c->session->curw` — the ATTACHED CLIENT's currently
focused window (cmd-find.c:876-878, 513-517, 612-623), not any
earlier -t on the command line.

Practical effect: calling select_pane(direction="next",
window_id=w2) while the client has w1 focused shifts the active
pane in w1 and leaves w2 untouched. Reproduced on a scratch tmux
server. This is the same class of bug that commit 8a8d7c6 fixed
for select_window directional navigation, which I previously
dismissed on select_pane based on a single-window probe that
couldn't expose the misrouting.

The fix uses the window-scoped relative pane spec
`@window_id.+` / `@window_id.-`. The target-parser at
cmd-find.c:1049-1097 splits on `.`, resolves the window part via
window_find_by_id_str (cmd-find.c:317-321), and applies the
offset against that explicit window's active pane
(cmd-find.c:612-623 with fs->w already bound to the named window
rather than s->curw). Routed through server.cmd(..., target=...)
to bypass Window.cmd's auto-target injection that would otherwise
reintroduce the duplicate-`-t` situation.

what:
- Switch the "next" and "previous" branches in select_pane from
  `window.cmd("select-pane", "-t", "+1"/"-1")` to
  `server.cmd("select-pane", target=f"{window.window_id}.+"/".-")`.
- Add test_select_pane_next_previous_respects_target_window: a
  multi-window fixture where w1 is the active window and w2 is
  not. The test calls select_pane(direction="next", window_id=w2)
  and asserts (a) w2's active pane changed, (b) w1's active pane
  did NOT change, and (c) the returned PaneInfo describes a pane
  in w2. Verified to FAIL against the previous code and PASS with
  the fix.
- No change to the "up/down/left/right/last" branches — those
  route through window.select_pane(flag), which uses the non-
  relative `-U/-D/-L/-R/-l` flags and is not affected by
  relative-target resolution.

Author: tony

src/libtmux_mcp/tools/pane_tools.py

@@ -870,9 +870,14 @@ def select_pane(
     if direction in _DIRECTION_FLAGS:
         window.select_pane(_DIRECTION_FLAGS[direction])
     elif direction == "next":
-        window.cmd("select-pane", "-t", "+1")
+        # Anchor the relative target to the requested window. A bare
+        # `-t +` resolves against the attached client's current window
+        # (tmux cmd-find.c), NOT the window we're targeting.
+        # `@window_id.+` forces tmux to resolve the `+` offset against
+        # the explicit window's active pane.
+        server.cmd("select-pane", target=f"{window.window_id}.+")
     elif direction == "previous":
-        window.cmd("select-pane", "-t", "-1")
+        server.cmd("select-pane", target=f"{window.window_id}.-")
 
     # Query the active pane ID directly from tmux to avoid stale cache
     target = window.window_id or ""

tests/test_pane_tools.py

@@ -696,6 +696,65 @@ def test_select_pane_requires_target(mcp_server: Server) -> None:
         select_pane(socket_name=mcp_server.socket_name)
 
 
+def test_select_pane_next_previous_respects_target_window(
+    mcp_server: Server, mcp_session: Session
+) -> None:
+    """select_pane direction=next/previous must anchor to window_id.
+
+    Regression guard: bare `-t +1` / `-t -1` pane targets resolve
+    against the attached client's current window (tmux cmd-find.c),
+    not against any earlier -t on the command line. Targeting a
+    non-active window must use a window-scoped syntax like
+    `@window_id.+` to actually affect that window. Without the fix,
+    calling select_pane(direction='next', window_id=w2) when w1 is
+    the client's active window shifts focus in w1 and leaves w2
+    untouched.
+    """
+    w1 = mcp_session.active_window
+    assert w1.active_pane is not None
+    w1.split()
+    w1.split()
+    w2 = mcp_session.new_window()
+    w2.split()
+    w2.split()
+
+    # Make w1 the active window again, so w2 is the NON-active target.
+    w1.select()
+    w1.refresh()
+    w2.refresh()
+
+    w1_before = w1.active_pane.pane_id
+    assert w2.active_pane is not None
+    w2_before = w2.active_pane.pane_id
+
+    result = select_pane(
+        direction="next",
+        window_id=w2.window_id,
+        socket_name=mcp_server.socket_name,
+    )
+
+    w1.refresh()
+    w2.refresh()
+    assert w2.active_pane is not None
+    w2_after = w2.active_pane.pane_id
+    assert w1.active_pane is not None
+    w1_after = w1.active_pane.pane_id
+
+    # Result must describe a pane in w2 (the target), not w1.
+    w2_pane_ids = {p.pane_id for p in w2.panes}
+    assert result.pane_id in w2_pane_ids, (
+        f"select_pane returned {result.pane_id} which is not in target "
+        f"window {w2.window_id}'s panes {w2_pane_ids}"
+    )
+    # w2's active pane must have actually changed.
+    assert w2_after != w2_before, "target window w2's active pane did not change"
+    # w1's active pane must NOT have changed — the wrong-window bug.
+    assert w1_after == w1_before, (
+        f"select_pane targeting w2 shifted focus in w1 "
+        f"({w1_before} -> {w1_after}) — anchor missing"
+    )
+
+
 # ---------------------------------------------------------------------------
 # swap_pane tests
 # ---------------------------------------------------------------------------