@jx0/jmux 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jarred Kenny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+# jmux
+
+A persistent session sidebar for tmux. See every project at a glance, switch instantly, never lose context.
+
+![jmux sidebar with grouped sessions alongside vim and server logs](docs/screenshots/hero.png)
+
+---
+
+## The Problem
+
+You have 30+ tmux sessions. Each one is a project, a context, a train of thought. But tmux gives you a flat list and a status bar that shows one session name. To switch, you `prefix-s`, scan a wall of text, find the one you want, and hope you remember which window you were in.
+
+You lose context constantly. You forget what's running where. You can't see at a glance which sessions have new output or which ones need attention.
+
+## The Solution
+
+jmux wraps tmux with a persistent sidebar that shows all your sessions, all the time. It doesn't replace tmux — it sits alongside it. Your keybindings, your panes, your workflow. Everything works exactly like before, plus a sidebar.
+
+**What you get:**
+- Every session visible at all times with git branch and window count
+- Sessions grouped by project directory — related work stays together
+- Instant switching with `Ctrl-Shift-Up/Down` — no prefix, no menu, no delay
+- Activity indicators (green dot) and attention flags (orange `!`) for agentic workflows
+- Mouse click to switch sessions
+- New session modal with fuzzy directory picker
+- A self-contained tmux distribution — ships its own config, doesn't touch `~/.tmux.conf`
+
+![jmux sidebar alongside vim with split panes and a dev server](docs/screenshots/blog.png)
+
+## How It Works
+
+jmux owns the terminal. It spawns tmux in a PTY, feeds the output through a headless terminal emulator ([xterm.js](https://xtermjs.org/)), and composites a 24-column sidebar alongside the tmux rendering. A separate tmux control mode connection provides real-time session metadata via push notifications.
+
+Your tmux is unmodified. Sessions, windows, panes, keybindings — all unchanged. jmux just adds a persistent view of what's happening across your projects.
+
+```
+┌─ jmux sidebar ──┬─ your normal tmux ──────────────────────┐
+│                  │                                         │
+│  jmux            │  $ vim src/server.ts                    │
+│ ──────────────── │  ...                                    │
+│ Code/work        │                                         │
+│ ▎ api-server  3w │                                         │
+│              main│                                         │
+│                  │                                         │
+│   dashboard   1w │                                         │
+│            feat/x│                                         │
+│                  │                                         │
+│ Code/personal    │                                         │
+│ ● blog        1w │                                         │
+│                  │                                         │
+│   dotfiles    2w │                                         │
+│                  ├─────────────────────────────────────────┤
+│                  │  1:vim  2:zsh  3:bun                    │
+└──────────────────┴─────────────────────────────────────────┘
+```
+
+### Sidebar Features
+
+**Session grouping** — Sessions that share a parent directory are automatically grouped under a header. `~/Code/work/api` and `~/Code/work/web` group under `Code/work`. Solo sessions render ungrouped.
+
+**Two-line entries** — Each session shows its name and window count on the first line, git branch on the second. Grouped sessions inherit directory context from the group header. Ungrouped sessions show their directory path.
+
+**Visual indicators:**
+- Green `▎` left marker — active session
+- Green `●` dot — new output since you last viewed that session
+- Orange `!` flag — attention needed (set programmatically)
+- Blue highlight — sidebar navigation mode (prefix + j)
+
+## Installation
+
+### Requirements
+
+- [Bun](https://bun.sh) 1.2+
+- [tmux](https://github.com/tmux/tmux) 3.2+
+- [fzf](https://github.com/junegunn/fzf) (for new session modal and window picker)
+- [git](https://git-scm.com/) (optional, for branch display)
+
+### Install
+
+```bash
+git clone https://github.com/jarredkenny/jmux.git
+cd jmux
+bun install
+```
+
+### Run
+
+```bash
+bun run bin/jmux
+```
+
+Or with a named session:
+
+```bash
+bun run bin/jmux my-project
+```
+
+### Isolated Server
+
+To run jmux on a separate tmux server (keeps your existing tmux sessions untouched):
+
+```bash
+bun run bin/jmux -L jmux
+```
+
+## New Session Modal
+
+Press `Ctrl-a n` to create a new session. The modal walks you through two steps:
+
+1. **Pick a directory** — fuzzy search over all git repos found under `~/Code`, `~/Projects`, `~/src`, `~/work`, and `~/dev`. Start typing to narrow down instantly.
+
+2. **Name the session** — pre-filled with the directory basename. Edit or accept with Enter.
+
+The session is created in the selected directory and the sidebar updates immediately. The new session is auto-selected.
+
+## Keybindings
+
+### Session Navigation (always active)
+
+| Key | Action |
+|-----|--------|
+| `Ctrl-Shift-Up` | Switch to previous session |
+| `Ctrl-Shift-Down` | Switch to next session |
+| `Ctrl-a n` | New session (directory picker + name) |
+| Click sidebar | Switch to that session |
+
+### Sidebar Mode (`Ctrl-a j` to enter)
+
+| Key | Action |
+|-----|--------|
+| `j` / `k` / arrows | Move highlight |
+| `Enter` | Switch to highlighted session |
+| `Escape` | Exit sidebar mode |
+
+### Windows
+
+| Key | Action |
+|-----|--------|
+| `Ctrl-a c` | New window (opens in `~`) |
+| `Ctrl-Right` / `Ctrl-Left` | Next / previous window |
+| `Ctrl-Shift-Right` / `Ctrl-Shift-Left` | Reorder windows |
+
+### Panes
+
+| Key | Action |
+|-----|--------|
+| `Ctrl-a \|` | Split horizontal |
+| `Ctrl-a -` | Split vertical |
+| `Shift-arrows` | Navigate panes (vim-aware via smart-splits) |
+| `Ctrl-a arrows` | Resize panes |
+| `Ctrl-a P` | Toggle pane border titles |
+
+### Utilities
+
+| Key | Action |
+|-----|--------|
+| `Ctrl-a k` | Clear pane screen and scrollback |
+| `Ctrl-a y` | Copy entire pane to clipboard |
+| `Ctrl-a Space` | Toggle scratchpad popup |
+
+## Claude Code Integration
+
+jmux is built for agentic workflows. When you have Claude Code running in multiple sessions, you need to know which ones need your attention.
+
+### One-Command Setup
+
+```bash
+bun run bin/jmux --install-agent-hooks
+```
+
+This adds a hook to `~/.claude/settings.json` that sets the attention flag whenever Claude Code finishes a response. The orange `!` appears in your sidebar so you know which session to check.
+
+### Manual Setup
+
+Set an attention flag on any session:
+
+```bash
+tmux set-option -t my-session @jmux-attention 1
+```
+
+jmux shows an orange `!` indicator. When you switch to that session, the flag clears automatically.
+
+### Workflow
+
+1. Start jmux
+2. Create sessions for each project (`Ctrl-a n`)
+3. Run Claude Code in each session on different tasks
+4. Work in one session while others run in the background
+5. Orange `!` flags appear when Claude finishes — switch instantly with `Ctrl-Shift-Down`
+
+## Self-Contained Config
+
+jmux ships its own `config/tmux.conf`. It never reads `~/.tmux.conf`. This means:
+
+- Your existing tmux setup is untouched
+- Every jmux user gets the same keybindings and behavior
+- No plugin manager needed — everything is built in
+- The status bar shows only window tabs (session info is in the sidebar)
+- Windows auto-rename to the running command (`vim`, `zsh`, `bun`, etc.)
+
+The config is fully customizable — see [docs/configuration.md](docs/configuration.md) for details.
+
+## Architecture
+
+```
+Terminal (Ghostty, iTerm, etc.)
+  └── jmux (owns the terminal surface)
+       ├── Sidebar (24 cols) ── session groups, indicators, navigation
+       ├── Border (1 col) ──── vertical separator
+       └── tmux PTY (remaining cols)
+            ├── PTY client ──── spawns tmux, feeds output through @xterm/headless
+            └── Control client ─ tmux -C for real-time session metadata
+```
+
+jmux is ~1500 lines of TypeScript. It has no opinions about what you run inside tmux.
+
+## License
+
+MIT

package/bin/jmux

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/main.ts";

package/config/new-session.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+# jmux new session — name + directory picker
+# Called via: display-popup -E "new-session.sh"
+
+FZF_COLORS="border:#4f565d,header:#b5bcc9,prompt:#9fe8c3,label:#9fe8c3,pointer:#9fe8c3,fg:#6b7280,fg+:#b5bcc9,hl:#fbd4b8,hl+:#fbd4b8"
+
+# ─── Step 1: Pick a directory ─────────────────────────────────────────
+
+# Build project list: find directories with .git (real projects)
+# Search common code directories, limit depth for speed
+PROJECT_DIRS=$(find \
+    "$HOME/Code" \
+    "$HOME/Projects" \
+    "$HOME/src" \
+    "$HOME/work" \
+    "$HOME/dev" \
+    2>/dev/null \
+    -maxdepth 3 -name ".git" -type d 2>/dev/null \
+    | sed 's|/\.git$||' \
+    | sort -u)
+
+# Add home directory as fallback
+PROJECT_DIRS=$(printf "%s\n%s" "$HOME" "$PROJECT_DIRS" | grep -v '^$')
+
+# Replace $HOME with ~ for display, but keep original paths
+DISPLAY_DIRS=$(echo "$PROJECT_DIRS" | sed "s|^$HOME|~|")
+
+SELECTED_DIR=$(echo "$DISPLAY_DIRS" | fzf \
+    --height=100% \
+    --layout=reverse \
+    --border=rounded \
+    --border-label=" New Session — Pick Directory " \
+    --header="Search for a project directory" \
+    --header-first \
+    --prompt="Dir: " \
+    --pointer="▸" \
+    --color="$FZF_COLORS")
+
+[ -z "$SELECTED_DIR" ] && exit 0
+
+# Expand ~ back to $HOME
+WORK_DIR="${SELECTED_DIR/#\~/$HOME}"
+
+# Default session name to directory basename
+DEFAULT_NAME=$(basename "$WORK_DIR")
+
+# ─── Step 2: Session name ─────────────────────────────────────────────
+
+SESSION_NAME=$(echo "" | fzf --print-query \
+    --height=100% \
+    --layout=reverse \
+    --border=rounded \
+    --border-label=" New Session — Name " \
+    --header="Directory: $SELECTED_DIR" \
+    --header-first \
+    --prompt="Name: " \
+    --query="$DEFAULT_NAME" \
+    --pointer="" \
+    --no-info \
+    --color="$FZF_COLORS" \
+    | head -1)
+
+[ -z "$SESSION_NAME" ] && exit 0
+
+# ─── Create session ───────────────────────────────────────────────────
+
+PARENT_CLIENT=$(tmux display-message -p '#{client_name}' 2>/dev/null)
+tmux new-session -d -s "$SESSION_NAME" -c "$WORK_DIR"
+tmux switch-client -c "$PARENT_CLIENT" -t "$SESSION_NAME"

package/config/tmux.conf

@@ -0,0 +1,115 @@
+# jmux tmux configuration
+# Self-contained — does not read ~/.tmux.conf
+
+# --- Prefix ---
+set -g prefix C-a
+unbind C-b
+bind-key C-a send-prefix
+
+# jmux-managed bindings
+bind-key n display-popup -E -w 60% -h 70% -b heavy -S 'fg=#4f565d' "$JMUX_DIR/config/new-session.sh"
+unbind p  # free up for future use
+
+# --- Windows ---
+set -g base-index 1
+set -g pane-base-index 1
+set -g renumber-windows on
+set -g automatic-rename on
+set -g automatic-rename-format "#{pane_current_command}"
+bind c new-window -c ~
+bind -n C-Right next-window
+bind -n C-Left previous-window
+
+# Reorder windows with Ctrl-Shift-Left/Right
+bind-key -n C-S-Left run-shell 'W=#{window_index}; T=$((W-1)); [ $T -ge 1 ] && tmux swap-window -s ":$W" -t ":$T" && tmux select-window -t ":$T"'
+bind-key -n C-S-Right run-shell 'W=#{window_index}; T=$((W+1)); MAX=$(tmux list-windows | wc -l | tr -d " "); [ $T -le $MAX ] && tmux swap-window -s ":$W" -t ":$T" && tmux select-window -t ":$T"'
+
+# --- Panes ---
+bind | split-window -h -c "#{pane_current_path}"
+bind - split-window -v -c "#{pane_current_path}"
+unbind '"'
+unbind %
+bind -r Left resize-pane -L 5
+bind -r Down resize-pane -D 5
+bind -r Up resize-pane -U 5
+bind -r Right resize-pane -R 5
+
+# Smart-splits.nvim integration
+is_vim="ps -o state= -o comm= -t '#{pane_tty}' | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|l?n?vim?x?|fzf)(diff)?$'"
+bind -n S-Left if-shell "$is_vim" "send-keys S-Left" "select-pane -L"
+bind -n S-Right if-shell "$is_vim" "send-keys S-Right" "select-pane -R"
+bind -n S-Up if-shell "$is_vim" "send-keys S-Up" "select-pane -U"
+bind -n S-Down if-shell "$is_vim" "send-keys S-Down" "select-pane -D"
+
+# --- Pane borders ---
+set -g pane-border-lines heavy
+set -g pane-border-status off
+set -g pane-border-style 'fg=#3a4450'
+set -g pane-active-border-style 'fg=#4f565d'
+set -g pane-border-format "#{?pane_active, #[fg=#9fe8c3 bold]#{pane_title} #[fg=#b5bcc9 nobold]#{b:pane_current_path} #[fg=#4f565d]| #{pane_current_command} , #[fg=#4f565d]#{pane_title} #[fg=#3a4450]#{b:pane_current_path} | #{pane_current_command} }"
+
+# Auto-show pane borders only when window has multiple panes
+set-hook -g window-layout-changed 'if -F "#{==:#{window_panes},1}" "set -w pane-border-status off" "set -w pane-border-status top"'
+set-hook -g after-select-window 'if -F "#{==:#{window_panes},1}" "set -w pane-border-status off" "set -w pane-border-status top"'
+bind-key P set -w pane-border-status
+
+# --- Window styles ---
+set -g window-style 'fg=#6b7280'
+set -g window-active-style 'fg=#b5bcc9'
+
+# --- Utilities ---
+bind k send-keys -R \; clear-history \; display-message "Pane cleared"
+bind y run-shell "tmux capture-pane -pS - -E - | grep . | pbcopy" \; display-message "Copied pane to clipboard"
+
+# Window switcher popup (C-a j) — jmux overrides this for sidebar mode,
+# but it's still available if sidebar mode changes
+bind-key j display-popup -E -x 0 -y 0 -w 30% -h 100% -b heavy -S 'fg=#4f565d' \
+  "tmux list-windows -F '#I: #W#{?window_active, *, }' | \
+   fzf --reverse --no-info --prompt=' Window> ' --pointer='▸' \
+       --color='bg:#0c1117,fg:#6b7280,hl:#fbd4b8,fg+:#b5bcc9,hl+:#fbd4b8,pointer:#9fe8c3,prompt:#9fe8c3' | \
+   cut -d: -f1 | \
+   xargs -I{} tmux select-window -t :{}"
+
+# Scratchpad toggle (C-a Space)
+bind-key Space if-shell -F '#{==:#{session_name},scratch}' {
+  detach-client
+} {
+  display-popup -E -w 80% -h 70% -b heavy -S 'fg=#4f565d' "tmux new-session -A -s scratch"
+}
+
+# --- Terminal ---
+set -g default-terminal "tmux-256color"
+set -g set-clipboard on
+set -g focus-events on
+set -g mouse on
+set -gq status-utf8 on
+set-window-option -gq utf8 on
+set-option -ga terminal-overrides ",xterm-256color:Tc"
+set-option -ga terminal-overrides ',*:Smulx=\E[4::%p1%dm'
+set-option -ga terminal-overrides ',*:Setulc=\E[58::2::%p1%{65536}%/%d::%p1%{256}%/%{255}%&%d::%p1%{255}%&%d%;m'
+
+# --- Bell / Activity ---
+set-window-option -g visual-bell off
+set-window-option -g bell-action other
+set-window-option -g monitor-activity off
+set-window-option -g visual-activity off
+set-hook -g pane-focus-in 'setw monitor-bell off; setw monitor-bell on'
+unbind -T root DoubleClick1Pane
+unbind -T root TripleClick1Pane
+
+# --- Status bar ---
+# Minimal — session indicator handled by jmux sidebar, no system metrics
+set -g status-position bottom
+set -g status-interval 1
+set -g status-justify left
+set -g status-bg "#181f26"
+set -g status-left ""
+set -g status-right ""
+set -g status-left-length 0
+set -g status-right-length 0
+
+# Window tabs
+setw -g window-status-current-format "#[bg=#181f26 fg=#fbd4b8]◢#[bg=#fbd4b8 fg=#131a21] #W #{?window_zoomed_flag,󰊓 ,}#[bg=#181f26 fg=#fbd4b8]◣"
+setw -g window-status-format "#{?window_bell_flag,#[bg=#181f26 fg=#ced4df] #W #{?window_zoomed_flag,󰊓 ,},#[bg=#181f26 fg=#4f565d] #W #{?window_zoomed_flag,󰊓 ,}}"
+set -g window-status-bell-style 'fg=#ced4df,bg=#0c1117'
+set -g window-status-activity-style 'fg=#b5bcc9,bg=#4e555c,bold'

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@jx0/jmux",
+  "version": "0.1.0",
+  "description": "A persistent session sidebar for tmux",
+  "type": "module",
+  "bin": {
+    "jmux": "./bin/jmux"
+  },
+  "files": [
+    "bin",
+    "src",
+    "config"
+  ],
+  "scripts": {
+    "dev": "bun run src/main.ts",
+    "test": "bun test",
+    "typecheck": "bun run tsc --noEmit"
+  },
+  "keywords": [
+    "tmux",
+    "terminal",
+    "sidebar",
+    "session-manager",
+    "tui",
+    "cli"
+  ],
+  "author": "Jarred Kenny",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jarredkenny/jmux.git"
+  },
+  "homepage": "https://github.com/jarredkenny/jmux",
+  "dependencies": {
+    "@xterm/headless": "^6.0.0",
+    "bun-pty": "^0.4.8"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  }
+}

package/src/__tests__/cell-grid.test.ts

@@ -0,0 +1,75 @@
+import { describe, test, expect } from "bun:test";
+import { createGrid, writeString, DEFAULT_CELL } from "../cell-grid";
+import { ColorMode } from "../types";
+
+describe("createGrid", () => {
+  test("creates grid with correct dimensions", () => {
+    const grid = createGrid(10, 5);
+    expect(grid.cols).toBe(10);
+    expect(grid.rows).toBe(5);
+    expect(grid.cells.length).toBe(5);
+    expect(grid.cells[0].length).toBe(10);
+  });
+
+  test("fills cells with spaces and default attributes", () => {
+    const grid = createGrid(3, 2);
+    const cell = grid.cells[0][0];
+    expect(cell.char).toBe(" ");
+    expect(cell.fg).toBe(0);
+    expect(cell.bg).toBe(0);
+    expect(cell.fgMode).toBe(ColorMode.Default);
+    expect(cell.bgMode).toBe(ColorMode.Default);
+    expect(cell.bold).toBe(false);
+  });
+});
+
+describe("writeString", () => {
+  test("writes characters at specified position", () => {
+    const grid = createGrid(10, 3);
+    writeString(grid, 1, 2, "hello");
+    expect(grid.cells[1][2].char).toBe("h");
+    expect(grid.cells[1][3].char).toBe("e");
+    expect(grid.cells[1][4].char).toBe("l");
+    expect(grid.cells[1][5].char).toBe("l");
+    expect(grid.cells[1][6].char).toBe("o");
+  });
+
+  test("applies attributes to written characters", () => {
+    const grid = createGrid(10, 3);
+    writeString(grid, 0, 0, "hi", {
+      fg: 2,
+      fgMode: ColorMode.Palette,
+      bold: true,
+    });
+    expect(grid.cells[0][0].fg).toBe(2);
+    expect(grid.cells[0][0].fgMode).toBe(ColorMode.Palette);
+    expect(grid.cells[0][0].bold).toBe(true);
+    expect(grid.cells[0][1].bold).toBe(true);
+  });
+
+  test("truncates at grid boundary", () => {
+    const grid = createGrid(5, 1);
+    writeString(grid, 0, 3, "hello");
+    expect(grid.cells[0][3].char).toBe("h");
+    expect(grid.cells[0][4].char).toBe("e");
+    // "llo" truncated — no crash
+  });
+
+  test("ignores writes outside grid bounds", () => {
+    const grid = createGrid(5, 3);
+    writeString(grid, 5, 0, "hello"); // row 5 doesn't exist
+    // no crash
+  });
+});
+
+describe("DEFAULT_CELL", () => {
+  test("is a space with default colors and no attributes", () => {
+    expect(DEFAULT_CELL.char).toBe(" ");
+    expect(DEFAULT_CELL.fgMode).toBe(ColorMode.Default);
+    expect(DEFAULT_CELL.bgMode).toBe(ColorMode.Default);
+    expect(DEFAULT_CELL.bold).toBe(false);
+    expect(DEFAULT_CELL.italic).toBe(false);
+    expect(DEFAULT_CELL.underline).toBe(false);
+    expect(DEFAULT_CELL.dim).toBe(false);
+  });
+});

package/src/__tests__/input-router.test.ts

@@ -0,0 +1,113 @@
+import { describe, test, expect } from "bun:test";
+import { translateMouseX, parseSgrMouse, InputRouter } from "../input-router";
+
+describe("parseSgrMouse", () => {
+  test("parses SGR mouse button press", () => {
+    const result = parseSgrMouse("\x1b[<0;30;5M");
+    expect(result).not.toBeNull();
+    expect(result!.button).toBe(0);
+    expect(result!.x).toBe(30);
+    expect(result!.y).toBe(5);
+    expect(result!.release).toBe(false);
+  });
+
+  test("parses SGR mouse button release", () => {
+    const result = parseSgrMouse("\x1b[<0;30;5m");
+    expect(result).not.toBeNull();
+    expect(result!.release).toBe(true);
+  });
+
+  test("parses wheel up event", () => {
+    const result = parseSgrMouse("\x1b[<64;10;5M");
+    expect(result).not.toBeNull();
+    expect(result!.button).toBe(64);
+    expect(result!.x).toBe(10);
+  });
+
+  test("returns null for non-mouse sequence", () => {
+    const result = parseSgrMouse("\x1b[A");
+    expect(result).toBeNull();
+  });
+});
+
+describe("translateMouseX", () => {
+  test("translates x coordinate by subtracting sidebar offset", () => {
+    const result = translateMouseX("\x1b[<0;30;5M", 25);
+    expect(result).toBe("\x1b[<0;5;5M");
+  });
+
+  test("preserves release suffix", () => {
+    const result = translateMouseX("\x1b[<0;30;5m", 25);
+    expect(result).toBe("\x1b[<0;5;5m");
+  });
+
+  test("returns null if translated x would be <= 0", () => {
+    const result = translateMouseX("\x1b[<0;10;5M", 25);
+    expect(result).toBeNull();
+  });
+});
+
+describe("Ctrl-Shift arrow detection", () => {
+  test("calls onSessionPrev for Ctrl-Shift-Up", () => {
+    let prevCalled = false;
+    const router = new InputRouter(
+      {
+        sidebarCols: 24,
+        onPtyData: () => {},
+        onSidebarClick: () => {},
+        onSessionPrev: () => { prevCalled = true; },
+      },
+      true,
+    );
+    router.handleInput("\x1b[1;6A");
+    expect(prevCalled).toBe(true);
+  });
+
+  test("calls onSessionNext for Ctrl-Shift-Down", () => {
+    let nextCalled = false;
+    const router = new InputRouter(
+      {
+        sidebarCols: 24,
+        onPtyData: () => {},
+        onSidebarClick: () => {},
+        onSessionNext: () => { nextCalled = true; },
+      },
+      true,
+    );
+    router.handleInput("\x1b[1;6B");
+    expect(nextCalled).toBe(true);
+  });
+
+  test("Ctrl-Shift arrows are not forwarded to PTY", () => {
+    let ptyData = "";
+    const router = new InputRouter(
+      {
+        sidebarCols: 24,
+        onPtyData: (d) => { ptyData += d; },
+        onSidebarClick: () => {},
+        onSessionPrev: () => {},
+        onSessionNext: () => {},
+      },
+      true,
+    );
+    router.handleInput("\x1b[1;6A");
+    router.handleInput("\x1b[1;6B");
+    expect(ptyData).toBe("");
+  });
+});
+
+describe("passthrough", () => {
+  test("forwards regular input to PTY", () => {
+    let ptyData = "";
+    const router = new InputRouter(
+      {
+        sidebarCols: 24,
+        onPtyData: (d) => { ptyData += d; },
+        onSidebarClick: () => {},
+      },
+      true,
+    );
+    router.handleInput("hello");
+    expect(ptyData).toBe("hello");
+  });
+});