fix: tighten drag & drop edge cases

Reset drag on dialog open, key press, and stale-card refresh so a
swallowed mouse-release can never silently move a card later. Drop
resolves the card by ID (moveCard) rather than by current selection,
bounds-check dragCol in renderFooter, ignore non-left releases, and
suppress jitter-within-card so double-click attach still works.

Assisted-By: Claude

Author: dgageot

docs/features/board/index.md

@@ -49,11 +49,12 @@ Requirements: `tmux` and `git` must be installed.
 | `o`           | Open the card's worktree in `$DOCKER_AGENT_BOARD_EDITOR` (`code`) |
 | `s`           | Open an interactive shell in the card's worktree    |
 | `[` / `]`     | Move the card back / forward                        |
+| `1`-`9`       | Move the card to column N                           |
 | `x`           | Delete the card, its session, worktree, and branch  |
 | `p`           | Manage projects (add, edit, reorder, remove)        |
 | `e`           | Edit the selected column's prompt                   |
 | `←↓↑→` `hjkl` | Navigate                                            |
-| mouse         | Click selects, double-click attaches, wheel scrolls |
+| mouse         | Click selects, double-click attaches, drag moves, wheel scrolls |
 | `?`           | Help                                                |
 | `q`           | Quit (agents keep running)                          |
 

pkg/board/tui/tui.go

@@ -6,6 +6,7 @@ import (
 	"image/color"
 	"os"
 	"os/exec"
+	"slices"
 	"strings"
 	"time"
 
@@ -254,6 +255,7 @@ func newModel(app *board.App, refresh chan struct{}) *model {
 
 // openDialog installs a dialog and runs its init command.
 func (m *model) openDialog(d dialog) tea.Cmd {
+	m.resetDrag() // the dialog captures the release: the drag cannot finish
 	m.dialog = d
 	return d.Init()
 }
@@ -269,6 +271,15 @@ func (m *model) reload() {
 		m.projectColors[p.Name] = projectColorAt(i)
 	}
 	m.clampSelection()
+	// A refresh can remove the dragged card or shrink the column list;
+	// re-validate so a drop cannot act on stale state.
+	if m.dragCardID != "" {
+		if m.cardByID(m.dragCardID) == nil {
+			m.resetDrag()
+		} else if m.dragCol >= len(m.columns) {
+			m.dragCol = -1
+		}
+	}
 }
 
 // groupCards buckets cards by column, in board order. A card whose column
@@ -313,6 +324,18 @@ func (m *model) selectedCard() *board.Card {
 	return cards[m.selRow]
 }
 
+// cardByID finds a card anywhere on the board.
+func (m *model) cardByID(id string) *board.Card {
+	for _, cards := range m.cards {
+		for _, c := range cards {
+			if c.ID == id {
+				return c
+			}
+		}
+	}
+	return nil
+}
+
 func (m *model) Init() tea.Cmd {
 	return tea.Batch(m.waitRefresh(), m.scheduleTick())
 }
@@ -522,6 +545,10 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 func (m *model) handleKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
+	// A key press cancels any drag in progress (esc cancels a drag) and
+	// keeps the state clean across paths that lose the release event, like
+	// tea.ExecProcess (attach, shell) leaving mouse mode.
+	m.resetDrag()
 	switch {
 	case key.Matches(msg, keys.Quit):
 		return m, tea.Quit
@@ -712,12 +739,19 @@ func (m *model) handleClick(msg tea.MouseClickMsg) (tea.Model, tea.Cmd) {
 }
 
 // handleMotion tracks a pressed card being dragged. Cell-motion mode only
-// reports motion while a button is held, so any motion after a card press
+// reports motion while a button is held, so motion after a card press
 // means a drag; the column under the pointer becomes the drop target.
 func (m *model) handleMotion(msg tea.MouseMotionMsg) {
 	if m.dragCardID == "" || msg.Button != tea.MouseLeft {
 		return
 	}
+	// Jitter within the pressed card stays a click (double-click keeps
+	// working): the drag starts once the pointer leaves the card.
+	if !m.dragging {
+		if col, row, ok := m.cardAt(msg.X, msg.Y); ok && col == m.selCol && row == m.selRow {
+			return
+		}
+	}
 	m.dragging = true
 	if col, ok := m.columnAt(msg.X, msg.Y); ok {
 		m.dragCol = col
@@ -730,19 +764,31 @@ func (m *model) handleMotion(msg tea.MouseMotionMsg) {
 // column moves it there. A release without prior motion is a plain click,
 // already handled by handleClick.
 func (m *model) handleRelease(msg tea.MouseReleaseMsg) (tea.Model, tea.Cmd) {
-	wasDragging, dst := m.dragging, m.dragCol
-	m.dragCardID, m.dragging, m.dragCol = "", false, -1
+	if msg.Button != tea.MouseLeft {
+		return m, nil
+	}
+	cardID, wasDragging, dst := m.dragCardID, m.dragging, m.dragCol
+	m.resetDrag()
 	if !wasDragging {
 		return m, nil
 	}
 	m.lastClickCard = "" // a completed drag must not arm double-click
 	if col, ok := m.columnAt(msg.X, msg.Y); ok {
 		dst = col
 	}
-	cmd := m.moveCardTo(dst)
+	cmd := m.moveCard(cardID, dst)
 	return m, cmd
 }
 
+// resetDrag abandons any drag in progress. Called whenever a drag can no
+// longer complete cleanly: a dialog opening (it captures the release), a
+// key press, or the dragged card disappearing on a refresh.
+func (m *model) resetDrag() {
+	m.dragCardID = ""
+	m.dragging = false
+	m.dragCol = -1
+}
+
 // handleWheel moves the selection through the column under the cursor, so
 // scrolling anywhere on a column walks its cards (the scroll window follows
 // the selection). Wheel events outside the columns area are ignored.
@@ -787,13 +833,25 @@ func (m *model) createCard(project board.Project, prompt string) tea.Cmd {
 
 // moveCardTo moves the selected card to the column at index dst.
 func (m *model) moveCardTo(dst int) tea.Cmd {
-	card := m.selectedCard()
-	if card == nil || dst == m.selCol || dst < 0 || dst >= len(m.columns) {
+	if card := m.selectedCard(); card != nil {
+		return m.moveCard(card.ID, dst)
+	}
+	return nil
+}
+
+// moveCard moves a card — by ID, so a board refresh mid-drag cannot
+// redirect the move to another card — to the column at index dst. Moving a
+// card to the column it already occupies is a no-op.
+func (m *model) moveCard(cardID string, dst int) tea.Cmd {
+	if dst < 0 || dst >= len(m.columns) {
 		return nil
 	}
 	colID := m.columns[dst].ID
+	if slices.ContainsFunc(m.cards[colID], func(c *board.Card) bool { return c.ID == cardID }) {
+		return nil
+	}
 	return func() tea.Msg {
-		if err := m.app.MoveCard(card.ID, colID); err != nil {
+		if err := m.app.MoveCard(cardID, colID); err != nil {
 			return flashMsg{text: err.Error(), isErr: true}
 		}
 		return cardMovedMsg{colIdx: dst}

pkg/board/tui/tui_test.go

@@ -158,6 +158,68 @@ func TestDragBackToOriginIsANoop(t *testing.T) {
 	assert.False(t, m.dragging)
 }
 
+func TestDragJitterWithinCardStaysAClick(t *testing.T) {
+	t.Parallel()
+
+	m := dragTestModel()
+	_, _ = m.handleClick(tea.MouseClickMsg{X: 5, Y: 5, Button: tea.MouseLeft})
+
+	// Motion within the pressed card does not start a drag…
+	m.handleMotion(tea.MouseMotionMsg{X: 6, Y: 6, Button: tea.MouseLeft})
+	assert.False(t, m.dragging)
+
+	// …so the release is a plain click and double-click stays armed.
+	_, cmd := m.handleRelease(tea.MouseReleaseMsg{X: 6, Y: 6, Button: tea.MouseLeft})
+	assert.Nil(t, cmd)
+	assert.Equal(t, "a", m.lastClickCard)
+}
+
+func TestNonLeftReleaseDoesNotDrop(t *testing.T) {
+	t.Parallel()
+
+	m := dragTestModel()
+	_, _ = m.handleClick(tea.MouseClickMsg{X: 5, Y: 5, Button: tea.MouseLeft})
+	m.handleMotion(tea.MouseMotionMsg{X: 65, Y: 5, Button: tea.MouseLeft})
+
+	// A stray non-left release mid-drag neither drops nor cancels.
+	_, cmd := m.handleRelease(tea.MouseReleaseMsg{X: 65, Y: 5, Button: tea.MouseRight})
+	assert.Nil(t, cmd)
+	assert.True(t, m.dragging)
+}
+
+func TestDragCancelledByDialogAndKeys(t *testing.T) {
+	t.Parallel()
+
+	// A dialog opening mid-drag captures the release: the drag must not
+	// survive, or the next click would silently move a card.
+	m := dragTestModel()
+	_, _ = m.handleClick(tea.MouseClickMsg{X: 5, Y: 5, Button: tea.MouseLeft})
+	m.handleMotion(tea.MouseMotionMsg{X: 65, Y: 5, Button: tea.MouseLeft})
+	_ = m.openDialog(newHelpDialog())
+	assert.False(t, m.dragging)
+	assert.Empty(t, m.dragCardID)
+
+	// A key press cancels a drag too (esc cancels).
+	m = dragTestModel()
+	_, _ = m.handleClick(tea.MouseClickMsg{X: 5, Y: 5, Button: tea.MouseLeft})
+	m.handleMotion(tea.MouseMotionMsg{X: 65, Y: 5, Button: tea.MouseLeft})
+	_, _ = m.handleKey(tea.KeyPressMsg{Code: tea.KeyEscape})
+	assert.False(t, m.dragging)
+}
+
+func TestMoveCardResolvesByID(t *testing.T) {
+	t.Parallel()
+
+	m := dragTestModel()
+
+	// Moving a card to the column it already occupies is a no-op, wherever
+	// the selection points (the drop path resolves the card by ID).
+	assert.Nil(t, m.moveCard("c", 1), "card c already sits in column done")
+	assert.NotNil(t, m.moveCard("c", 0))
+	assert.Nil(t, m.moveCard("a", -1))
+	assert.Nil(t, m.moveCard("a", 2))
+}
+
 func TestReleaseWithoutMotionIsAClick(t *testing.T) {
 	t.Parallel()
 

pkg/board/tui/view.go

@@ -412,9 +412,10 @@ func (m *model) renderStatus(status board.CardStatus, width int) string {
 
 func (m *model) renderFooter() string {
 	if m.dragging {
-		if m.dragCol >= 0 && m.dragCol != m.selCol {
+		if m.dragCol >= 0 && m.dragCol < len(m.columns) && m.dragCol != m.selCol {
+			const hint = " Release to move the card to "
 			name := strings.TrimSpace(m.columns[m.dragCol].Emoji + " " + m.columns[m.dragCol].Name)
-			return styles.SuccessStyle.Render(" Release to move the card to " + toolcommon.TruncateText(sanitize(name), max(m.width-31, 1)))
+			return styles.SuccessStyle.Render(hint + toolcommon.TruncateText(sanitize(name), max(m.width-len(hint)-1, 1)))
 		}
 		return styles.MutedStyle.Render(" Drop the card on another column to move it")
 	}