feat(tui): mouse click and double-click support (#293)

## Summary

- Enables `MouseModeCellMotion` on all three TUI model `View()` methods
so mouse events are delivered to the app
- Left-click on the tab bar switches views (fires same init commands as
keyboard — fixes Tasks showing blank on first click)
- Left-click in list/tree area moves cursor across all views (sessions,
tasks, messages, docs, store); clicks in preview/detail panes are
correctly ignored using each view's actual split-ratio math
- Double-click within 300ms at the same cell synthesizes an Enter key
press (activate session, open doc, etc.)
- `PasteMsg` now routes through `handleFallthrough` so bracketed paste
works in text inputs (new session form, rename modal, etc.)
- Notification modal scrolls on mouse wheel; all other wheel events fall
through unchanged
- `switchToView()` consolidates tab-switching logic — keyboard and mouse
tab-bar click now share one path, eliminating duplication

## Bug fixes caught during review

- `messages.Controller.SelectAt` was validating `idx` against
`displayed` instead of `filteredAt` — with an active filter this put
`cursor` out of bounds for `filteredAt`, making `Selected()` return
`nil`
- `messages.View.SelectAtRow` used wrong split-ratio defaults vs the
renderer (bounds `> 90`, default `40` vs `> 80`, default `25` with
`min-20` floor); click hit regions were misaligned from what was
rendered
- `messages.View.SelectAtRow` ignored the filter line when computing the
row offset, causing off-by-one clicks whenever a filter was active
- `sessions.View.SelectAtRow` bounds-checked against `Items()` instead
of `VisibleItems()`, allowing clicks to select hidden items when the
list was filtered
- `kv_view.SelectAtRow` accepted clicks anywhere in the row, including
the preview pane; now guards against clicks right of the key-list pane
- Tab bar click previously bypassed the `isModalActive()` guard,
silently switching views while modals were open
- Double-click state now resets on view switch to prevent a stale
cross-view double-click

## Test plan

- [ ] `mise run check` passes (0 lint issues, all tests green)
- [ ] Click a session row to select it; double-click to activate (open
in terminal)
- [ ] Click the Tasks/Messages/Docs/Store tab labels to switch views
- [ ] Click a task row; detail pane updates; clicking in the detail pane
does not move the cursor
- [ ] Click a doc in the Docs tree; preview updates in right pane
- [ ] Paste text into the new-session form using terminal paste (Cmd+V /
bracketed paste)
- [ ] Open notification modal, scroll with mouse wheel
- [ ] With a modal open (rename, confirm), click a tab → view should NOT
switch

Author: hay-kot

.github/workflows/partial-tests.yml

@@ -26,7 +26,7 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v9
         with:
-          version: latest
+          version: v2.11.4
           args: --timeout=6m
 
       - name: Build

internal/tui/hc_only.go

@@ -368,5 +368,7 @@ func (m HoneycombOnlyModel) View() tea.View {
 	if m.helpDialog != nil {
 		content = m.helpDialog.Overlay(content, m.width, m.height)
 	}
-	return tea.NewView(content)
+	v := tea.NewView(content)
+	v.MouseMode = tea.MouseModeCellMotion
+	return v
 }

internal/tui/kv_view.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"time"
 
+	tea "charm.land/bubbletea/v2"
 	"github.com/charmbracelet/x/ansi"
 	"github.com/colonyops/hive/internal/core/kv"
 	"github.com/colonyops/hive/internal/core/styles"
@@ -78,6 +79,34 @@ func (v *KVView) SelectedKey() string {
 	return v.keys[v.filtered[v.cursor]]
 }
 
+// SelectAtRow moves the cursor to the key at contentY rows from the view top.
+// The key list renders a one-line header and, when filtering is active, a filter line.
+// Clicks in the preview pane (right of the key list) are ignored.
+func (v *KVView) SelectAtRow(x, contentY int) tea.Cmd {
+	// Key list occupies 20% of width (min 15), matching View().
+	listWidth := int(float64(v.width) * 0.20)
+	if listWidth < 15 {
+		listWidth = 15
+	}
+	if x >= listWidth {
+		return nil
+	}
+	headerRows := 1 // "Keys" header
+	if v.filtering || v.filter != "" {
+		headerRows = 2 // header + filter line
+	}
+	listRow := contentY - headerRows
+	if listRow < 0 || len(v.filtered) == 0 {
+		return nil
+	}
+	idx := v.offset + listRow
+	if idx >= len(v.filtered) {
+		return nil
+	}
+	v.cursor = idx
+	return nil
+}
+
 // MoveUp moves the cursor up in the key list.
 func (v *KVView) MoveUp() {
 	if v.cursor > 0 {

internal/tui/kv_view_test.go

@@ -0,0 +1,83 @@
+package tui
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// newKVViewWithKeys creates a KVView preloaded with the given keys.
+func newKVViewWithKeys(keys []string) *KVView {
+	v := NewKVView()
+	v.SetSize(100, 24)
+	v.SetKeys(keys)
+	return v
+}
+
+// --- SelectAtRow ---
+
+func TestKVView_SelectAtRow_ClickInPreview_NoOp(t *testing.T) {
+	v := newKVViewWithKeys([]string{"key-a", "key-b", "key-c"})
+	// listWidth = int(100 * 0.20) = 20; x=50 >= 20 → no-op
+	v.SelectAtRow(50, 1)
+	assert.Equal(t, 0, v.cursor, "click in preview pane should be no-op")
+}
+
+func TestKVView_SelectAtRow_HeaderRow_NoOp(t *testing.T) {
+	v := newKVViewWithKeys([]string{"key-a", "key-b", "key-c"})
+	// headerRows=1 (no filter); listRow = contentY - 1 = -1 → no-op
+	v.SelectAtRow(0, 0)
+	assert.Equal(t, 0, v.cursor, "clicking header row (contentY=0) should be no-op")
+}
+
+func TestKVView_SelectAtRow_HappyPath(t *testing.T) {
+	v := newKVViewWithKeys([]string{"key-a", "key-b", "key-c"})
+	// headerRows=1; contentY=1 → listRow=0, idx=offset+0=0
+	v.SelectAtRow(0, 1)
+	assert.Equal(t, 0, v.cursor, "contentY=1 should select cursor=0")
+
+	// contentY=2 → listRow=1, idx=1
+	v.SelectAtRow(0, 2)
+	assert.Equal(t, 1, v.cursor, "contentY=2 should select cursor=1")
+}
+
+func TestKVView_SelectAtRow_FilterActive_FilterLineIsNoOp(t *testing.T) {
+	v := newKVViewWithKeys([]string{"alpha", "beta", "gamma"})
+	v.StartFilter()
+	v.AddFilterRune('a')
+
+	// headerRows=2 (header + filter line); contentY=1 → listRow=-1 → no-op
+	v.SelectAtRow(0, 1)
+	assert.Equal(t, 0, v.cursor, "contentY=1 (filter line) should be no-op when filter active")
+}
+
+func TestKVView_SelectAtRow_FilterActive_ContentY2_SelectsFirst(t *testing.T) {
+	v := newKVViewWithKeys([]string{"alpha", "beta", "gamma"})
+	v.StartFilter()
+	v.AddFilterRune('a') // matches "alpha" and "gamma" (2 items)
+
+	require.NotEmpty(t, v.filtered, "filter should produce at least one match")
+
+	// headerRows=2; contentY=2 → listRow=0, idx=0
+	v.SelectAtRow(0, 2)
+	assert.Equal(t, 0, v.cursor, "contentY=2 should select first filtered item")
+}
+
+func TestKVView_SelectAtRow_EmptyFiltered_NoOp(t *testing.T) {
+	v := newKVViewWithKeys([]string{"alpha", "beta"})
+	v.StartFilter()
+	v.AddFilterRune('z') // no matches
+
+	require.Empty(t, v.filtered, "filter should produce no matches")
+
+	v.SelectAtRow(0, 1)
+	assert.Equal(t, 0, v.cursor, "no-op when filtered list is empty")
+}
+
+func TestKVView_SelectAtRow_BeyondFiltered_NoOp(t *testing.T) {
+	v := newKVViewWithKeys([]string{"key-a"})
+	// filtered has 1 entry; contentY=10 → idx=9 >= 1 → no-op
+	v.SelectAtRow(0, 10)
+	assert.Equal(t, 0, v.cursor, "row beyond filtered items should be no-op")
+}

internal/tui/model.go

@@ -154,6 +154,10 @@ type Model struct {
 
 	// Startup warnings to show as toasts after init
 	startupWarnings []string
+
+	// Double-click tracking: last left-button click position and time.
+	lastClickX, lastClickY int
+	lastClickTime          time.Time
 }
 
 // actionCompleteMsg is sent when an action completes.
@@ -626,6 +630,21 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		model, cmd = m.handleKeyMsg(msg)
 	case spinner.TickMsg:
 		model, cmd = m.handleSpinnerTick(msg)
+	case tea.MouseClickMsg:
+		model, cmd = m.handleMouseClick(msg)
+	case tea.MouseWheelMsg:
+		if m.state == stateShowingNotifications && m.modals.Notification != nil {
+			if msg.Button == tea.MouseWheelUp {
+				m.modals.Notification.ScrollUp()
+			} else {
+				m.modals.Notification.ScrollDown()
+			}
+			model, cmd = m, nil
+		} else {
+			model, cmd = m.handleFallthrough(msg)
+		}
+	case tea.PasteMsg:
+		model, cmd = m.handleFallthrough(msg)
 
 	default:
 		model, cmd = m.handleFallthrough(msg)
@@ -1418,35 +1437,7 @@ func (m Model) handleTabKey(direction int) (tea.Model, tea.Cmd) {
 	}
 
 	next := (current + direction + len(tabs)) % len(tabs)
-	m.activeView = tabs[next]
-
-	m.handler.SetActiveView(m.activeView)
-	m.sessionsView.SetActive(m.activeView == ViewSessions)
-	if m.msgView != nil {
-		m.msgView.SetActive(m.activeView == ViewMessages)
-	}
-	if m.tasksView != nil {
-		m.tasksView.SetActive(m.activeView == ViewTasks)
-	}
-
-	// Load data when switching to Store or Tasks tab
-	switch m.activeView {
-	case ViewStore:
-		return m, m.loadKVKeys()
-	case ViewTasks:
-		if cmd := m.syncTasksRepoFromSessions(); cmd != nil {
-			return m, cmd
-		}
-		return m, func() tea.Msg { return tasks.RefreshTasksMsg{} }
-	case ViewReview:
-		if cmd := m.syncDocsRepoFromSessions(); cmd != nil {
-			return m, cmd
-		}
-	case ViewSessions, ViewMessages:
-		// No special load action needed
-	}
-
-	return m, nil
+	return m.switchToView(tabs[next])
 }
 
 // renameCompleteMsg is sent when a rename operation completes.

internal/tui/model_handlers.go

@@ -1067,6 +1067,137 @@ func (m Model) handleFallthrough(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, tea.Batch(cmds...)
 }
 
+const doubleClickWindow = 300 * time.Millisecond
+
+// handleMouseClick routes left-button clicks to the active view or tab bar.
+// Two clicks within doubleClickWindow at the same cell synthesize an Enter key press.
+func (m Model) handleMouseClick(msg tea.MouseClickMsg) (tea.Model, tea.Cmd) {
+	if msg.Button != tea.MouseLeft || m.isModalActive() {
+		return m, nil
+	}
+
+	// Tab bar is at terminal row 1 (topDivider=0, header=1, headerDivider=2).
+	if msg.Y == 1 {
+		return m.handleTabClick(msg.X)
+	}
+
+	const tabChrome = 3
+	contentY := msg.Y - tabChrome
+	if contentY < 0 {
+		return m, nil
+	}
+
+	// Detect double-click: same cell within the window.
+	now := time.Now()
+	isDouble := msg.X == m.lastClickX && msg.Y == m.lastClickY &&
+		now.Sub(m.lastClickTime) <= doubleClickWindow
+	m.lastClickX = msg.X
+	m.lastClickY = msg.Y
+	m.lastClickTime = now
+
+	if isDouble {
+		return m.handleKeyMsg(tea.KeyPressMsg{Code: tea.KeyEnter})
+	}
+
+	var cmd tea.Cmd
+	switch m.activeView {
+	case ViewSessions:
+		if m.sessionsView != nil {
+			cmd = m.sessionsView.SelectAtRow(msg.X, contentY)
+		}
+	case ViewTasks:
+		if m.tasksView != nil {
+			cmd = m.tasksView.SelectAtRow(msg.X, contentY)
+		}
+	case ViewMessages:
+		if m.msgView != nil {
+			cmd = m.msgView.SelectAtRow(msg.X, contentY)
+		}
+	case ViewReview:
+		if m.reviewView != nil {
+			cmd = m.reviewView.SelectAtRow(msg.X, contentY)
+		}
+	case ViewStore:
+		if m.kvView != nil {
+			cmd = m.kvView.SelectAtRow(msg.X, contentY)
+		}
+	}
+	return m, cmd
+}
+
+// switchToView activates the given view, updating all per-view active flags and
+// firing any data-load commands required on first entry. This is the single
+// source of truth for view switching used by both keyboard (tab key) and mouse
+// (tab bar click).
+func (m Model) switchToView(view ViewType) (tea.Model, tea.Cmd) {
+	m.lastClickTime = time.Time{} // reset double-click state across view changes
+	m.activeView = view
+	m.handler.SetActiveView(view)
+	m.sessionsView.SetActive(view == ViewSessions)
+	if m.msgView != nil {
+		m.msgView.SetActive(view == ViewMessages)
+	}
+	if m.tasksView != nil {
+		m.tasksView.SetActive(view == ViewTasks)
+	}
+
+	switch view {
+	case ViewStore:
+		return m, m.loadKVKeys()
+	case ViewTasks:
+		if cmd := m.syncTasksRepoFromSessions(); cmd != nil {
+			return m, cmd
+		}
+		return m, func() tea.Msg { return tasks.RefreshTasksMsg{} }
+	case ViewReview:
+		if cmd := m.syncDocsRepoFromSessions(); cmd != nil {
+			return m, cmd
+		}
+	case ViewSessions, ViewMessages:
+		// No data load needed on switch.
+	}
+	return m, nil
+}
+
+// handleTabClick switches the active view based on which tab label was clicked at column x.
+// Tab labels start at column 1 (one-space left margin) and are separated by " | " (3 cols).
+func (m Model) handleTabClick(x int) (tea.Model, tea.Cmd) {
+	showStoreTab := m.kvStore != nil && m.cfg.TUI.Store
+
+	type tabEntry struct {
+		view  ViewType
+		label string
+	}
+	tabs := []tabEntry{{ViewSessions, "Sessions"}}
+	if m.tasksView != nil {
+		tabs = append(tabs, tabEntry{ViewTasks, "Tasks"})
+	}
+	if m.reviewView != nil {
+		tabs = append(tabs, tabEntry{ViewReview, "Docs"})
+	}
+	tabs = append(tabs, tabEntry{ViewMessages, "Messages"})
+	if showStoreTab || m.activeView == ViewStore {
+		tabs = append(tabs, tabEntry{ViewStore, "Store"})
+	}
+
+	const (
+		leftMargin = 1
+		sepWidth   = 3 // " | "
+	)
+	pos := leftMargin
+	for i, t := range tabs {
+		w := len(t.label) // styles use no padding/borders, so visual width == len
+		if x >= pos && x < pos+w {
+			return m.switchToView(t.view)
+		}
+		pos += w
+		if i < len(tabs)-1 {
+			pos += sepWidth
+		}
+	}
+	return m, nil
+}
+
 // --- Helper for repo header opening ---
 
 func (m Model) openRepoHeaderByRemote(name, remote string) (tea.Model, tea.Cmd) {