savepoint 1.0.0

package/internal/board/help.go

@@ -0,0 +1,40 @@
+package board
+
+import (
+	"strings"
+
+	"github.com/opencode/savepoint/internal/styles"
+)
+
+const helpBorderPad = 4 // rounded border (2) + padding (2x1)
+
+// RenderHelp renders the keyboard shortcut reference overlay.
+func RenderHelp(width int) string {
+	inner := width - helpBorderPad
+	if inner < 4 {
+		inner = 4
+	}
+
+	lines := []string{
+		styles.ColumnTitleFocused.Render("KEYBOARD SHORTCUTS"),
+		strings.Repeat("─", inner),
+		helpRow("h / left", "previous column"),
+		helpRow("l / right", "next column"),
+		helpRow("enter", "open task detail / select item"),
+		helpRow("e", "open epic selector on narrow screens"),
+		helpRow("r", "open release selector"),
+		helpRow("up / k", "move selector up"),
+		helpRow("down / j", "move selector down"),
+		helpRow("?", "open help"),
+		helpRow("esc / q", "close overlay"),
+		helpRow("q / ctrl+c", "quit from board"),
+		"",
+		styles.CardMeta.Render("esc/q:close"),
+	}
+
+	return styles.DetailOverlay.Width(width).Render(strings.Join(lines, "\n"))
+}
+
+func helpRow(key, action string) string {
+	return styles.ColumnTitle.Render(key+": ") + styles.CardMeta.Render(action)
+}

package/internal/board/help_test.go

@@ -0,0 +1,85 @@
+package board
+
+import (
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func TestRenderHelp_containsTitle(t *testing.T) {
+	got := RenderHelp(60)
+	if !strings.Contains(got, "KEYBOARD SHORTCUTS") {
+		t.Error("RenderHelp missing title")
+	}
+}
+
+func TestRenderHelp_containsShortcuts(t *testing.T) {
+	got := RenderHelp(60)
+	for _, shortcut := range []string{
+		"h / left",
+		"l / right",
+		"enter",
+		"e",
+		"r",
+		"up / k",
+		"down / j",
+		"?",
+		"esc / q",
+		"q / ctrl+c",
+	} {
+		if !strings.Contains(got, shortcut) {
+			t.Errorf("RenderHelp missing shortcut %q", shortcut)
+		}
+	}
+}
+
+func TestRenderHelp_containsCloseHint(t *testing.T) {
+	got := RenderHelp(60)
+	if !strings.Contains(got, "esc/q:close") {
+		t.Error("RenderHelp missing close hint")
+	}
+}
+
+func TestUpdate_questionMarkOpensHelpOverlay(t *testing.T) {
+	m := NewModel(nil, "v1", "E04")
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("?")})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayHelp {
+		t.Errorf("Overlay = %q, want %q", updated.Overlay, OverlayHelp)
+	}
+}
+
+func TestUpdate_helpOverlayEscCloses(t *testing.T) {
+	m := NewModel(nil, "v1", "E04")
+	m.Overlay = OverlayHelp
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q after esc, want none", updated.Overlay)
+	}
+}
+
+func TestUpdate_helpOverlayQCloses(t *testing.T) {
+	m := NewModel(nil, "v1", "E04")
+	m.Overlay = OverlayHelp
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("q")})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q after q, want none", updated.Overlay)
+	}
+}
+
+func TestView_helpOverlayRendered(t *testing.T) {
+	m := NewModel(nil, "v1", "E04")
+	m.Width = 100
+	m.Height = 30
+	m.Overlay = OverlayHelp
+	got := m.View()
+	if !strings.Contains(got, "KEYBOARD SHORTCUTS") {
+		t.Error("View() with OverlayHelp missing help header")
+	}
+	if !strings.Contains(got, "q / ctrl+c") {
+		t.Error("View() with OverlayHelp missing quit shortcut")
+	}
+}

package/internal/board/layout.go

@@ -0,0 +1,58 @@
+package board
+
+const (
+	colOverhead = 4 // rounded border (1) + padding (1) each side
+
+	minColWidth = 10
+
+	epicPanelWidth    = 28
+	epicPanelOverhead = 4
+
+	boardFrameOverhead = 4 // rounded border (2) + padding (2×1)
+
+	breakpointWide   = 120
+	breakpointNarrow = 80
+)
+
+// Layout describes board geometry for a given terminal size.
+type Layout struct {
+	EpicPanelVisible bool
+	EpicPanelWidth   int
+	ColCount         int
+	ColWidths        []int
+}
+
+// CalculateLayout returns the board layout for the given terminal dimensions.
+//
+//   - >=120 cols: epic panel (28w) + 3 columns
+//   - 80–119 cols: 3 columns only
+//   - <80 cols: 1 column
+func CalculateLayout(width, _ int) Layout {
+	inner := width - boardFrameOverhead
+	switch {
+	case width >= breakpointWide:
+		available := inner - (epicPanelWidth + epicPanelOverhead) - 3*colOverhead
+		cw := max(available/3, minColWidth)
+		return Layout{
+			EpicPanelVisible: true,
+			EpicPanelWidth:   epicPanelWidth,
+			ColCount:         3,
+			ColWidths:        []int{cw, cw, cw},
+		}
+	case width >= breakpointNarrow:
+		available := inner - 3*colOverhead
+		cw := max(available/3, minColWidth)
+		return Layout{
+			EpicPanelVisible: false,
+			ColCount:         3,
+			ColWidths:        []int{cw, cw, cw},
+		}
+	default:
+		cw := max(inner-colOverhead, minColWidth)
+		return Layout{
+			EpicPanelVisible: false,
+			ColCount:         1,
+			ColWidths:        []int{cw},
+		}
+	}
+}

package/internal/board/layout_test.go

@@ -0,0 +1,89 @@
+package board
+
+import "testing"
+
+func TestCalculateLayout_wide(t *testing.T) {
+	l := CalculateLayout(120, 40)
+	if !l.EpicPanelVisible {
+		t.Error("expected epic panel visible at width=120")
+	}
+	if l.EpicPanelWidth != epicPanelWidth {
+		t.Errorf("EpicPanelWidth = %d, want %d", l.EpicPanelWidth, epicPanelWidth)
+	}
+	if l.ColCount != 3 {
+		t.Errorf("ColCount = %d, want 3", l.ColCount)
+	}
+	if len(l.ColWidths) != 3 {
+		t.Fatalf("len(ColWidths) = %d, want 3", len(l.ColWidths))
+	}
+	// inner = 120-4 = 116; available = 116-(28+4)-3*4 = 72; cw = 72/3 = 24
+	for i, w := range l.ColWidths {
+		if w != 24 {
+			t.Errorf("ColWidths[%d] = %d, want 24", i, w)
+		}
+	}
+}
+
+func TestCalculateLayout_medium(t *testing.T) {
+	l := CalculateLayout(100, 40)
+	if l.EpicPanelVisible {
+		t.Error("epic panel should be hidden at width=100")
+	}
+	if l.ColCount != 3 {
+		t.Errorf("ColCount = %d, want 3", l.ColCount)
+	}
+	if len(l.ColWidths) != 3 {
+		t.Fatalf("len(ColWidths) = %d, want 3", len(l.ColWidths))
+	}
+	for i, w := range l.ColWidths {
+		if w != 28 {
+			t.Errorf("ColWidths[%d] = %d, want 28", i, w)
+		}
+	}
+}
+
+func TestCalculateLayout_narrow(t *testing.T) {
+	l := CalculateLayout(60, 40)
+	if l.EpicPanelVisible {
+		t.Error("epic panel should be hidden at width=60")
+	}
+	if l.ColCount != 1 {
+		t.Errorf("ColCount = %d, want 1", l.ColCount)
+	}
+	// inner = 60 - 4 = 56; cw = 56 - 4 = 52
+	if l.ColWidths[0] != 52 {
+		t.Errorf("ColWidths[0] = %d, want 52", l.ColWidths[0])
+	}
+}
+
+func TestCalculateLayout_tinyWidth_floorsAtMinColWidth(t *testing.T) {
+	l := CalculateLayout(4, 40)
+	if l.ColCount != 1 {
+		t.Errorf("ColCount = %d, want 1", l.ColCount)
+	}
+	if l.ColWidths[0] != minColWidth {
+		t.Errorf("ColWidths[0] = %d, want %d (minColWidth floor)", l.ColWidths[0], minColWidth)
+	}
+}
+
+func TestCalculateLayout_breakpointBoundaries(t *testing.T) {
+	cases := []struct {
+		width        int
+		wantColCount int
+		wantEpic     bool
+	}{
+		{119, 3, false},
+		{120, 3, true},
+		{79, 1, false},
+		{80, 3, false},
+	}
+	for _, tc := range cases {
+		l := CalculateLayout(tc.width, 40)
+		if l.ColCount != tc.wantColCount {
+			t.Errorf("width=%d: ColCount = %d, want %d", tc.width, l.ColCount, tc.wantColCount)
+		}
+		if l.EpicPanelVisible != tc.wantEpic {
+			t.Errorf("width=%d: EpicPanelVisible = %v, want %v", tc.width, l.EpicPanelVisible, tc.wantEpic)
+		}
+	}
+}

package/internal/board/model.go

@@ -0,0 +1,151 @@
+package board
+
+import (
+	"os"
+	"path/filepath"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+type OverlayType string
+
+const (
+	OverlayNone    OverlayType = ""
+	OverlayHelp    OverlayType = "help"
+	OverlayEpic    OverlayType = "epic"
+	OverlayRelease OverlayType = "release"
+	OverlayDetail  OverlayType = "detail"
+)
+
+// Model holds all board state. Tasks are grouped by column for O(1) column access.
+type Model struct {
+	AllTasks        []data.Task
+	Tasks           map[data.ColumnType][]data.Task
+	FocusedColumn   data.ColumnType
+	FocusedTask     int
+	SelectedEpic    string
+	SelectedRelease string
+	Epics           []string
+	EpicCursor      int
+	Releases        []string
+	ReleaseEpics    map[string][]string
+	ReleaseCursor   int
+	Overlay         OverlayType
+	Width           int
+	Height          int
+	StatusMessage   string
+	Root            string
+}
+
+// NewModel groups tasks by column and returns an initialized Model.
+func NewModel(tasks []data.Task, release, epic string) Model {
+	m := Model{
+		AllTasks:        append([]data.Task(nil), tasks...),
+		FocusedColumn:   data.ColumnPlanned,
+		FocusedTask:     0,
+		SelectedEpic:    epic,
+		SelectedRelease: release,
+		Overlay:         OverlayNone,
+	}
+	m.refreshTasks()
+	return m
+}
+
+func (m Model) Init() tea.Cmd {
+	return tea.Batch()
+}
+
+func groupedTasks(tasks []data.Task) map[data.ColumnType][]data.Task {
+	grouped := map[data.ColumnType][]data.Task{
+		data.ColumnPlanned:    {},
+		data.ColumnInProgress: {},
+		data.ColumnDone:       {},
+	}
+	for _, t := range tasks {
+		col := t.Column
+		if col == "" {
+			col = data.ColumnPlanned
+		}
+		grouped[col] = append(grouped[col], t)
+	}
+	return grouped
+}
+
+func (m *Model) refreshTasks() {
+	visible := make([]data.Task, 0, len(m.AllTasks))
+	for _, t := range m.AllTasks {
+		if m.SelectedRelease != "" && t.Release != "" && t.Release != m.SelectedRelease {
+			continue
+		}
+		if m.SelectedEpic != "" && t.Epic != "" && t.Epic != m.SelectedEpic {
+			continue
+		}
+		visible = append(visible, t)
+	}
+	m.Tasks = groupedTasks(visible)
+	m.clampFocusedTask()
+}
+
+func (m *Model) refreshEpicsForRelease() {
+	if len(m.ReleaseEpics) == 0 {
+		return
+	}
+
+	epics := m.ReleaseEpics[m.SelectedRelease]
+	m.Epics = append([]string(nil), epics...)
+	if len(m.Epics) == 0 {
+		m.SelectedEpic = ""
+		m.EpicCursor = 0
+		return
+	}
+
+	for _, epic := range m.Epics {
+		if epic == m.SelectedEpic {
+			m.EpicCursor = epicIndex(m.Epics, m.SelectedEpic)
+			return
+		}
+	}
+
+	m.SelectedEpic = m.Epics[0]
+	m.EpicCursor = 0
+}
+
+func (m *Model) clampFocusedTask() {
+	tasks := m.Tasks[m.FocusedColumn]
+	if len(tasks) == 0 {
+		m.FocusedTask = 0
+		return
+	}
+	if m.FocusedTask >= len(tasks) {
+		m.FocusedTask = len(tasks) - 1
+	}
+	if m.FocusedTask < 0 {
+		m.FocusedTask = 0
+	}
+}
+
+func (m *Model) writeRouterReleaseEpic() error {
+	routerPath := filepath.Join(m.Root, "router.md")
+
+	fi, err := os.Stat(routerPath)
+	if err != nil {
+		return err
+	}
+
+	content, err := os.ReadFile(routerPath)
+	if err != nil {
+		return err
+	}
+
+	r := data.NewRouterReader()
+	state, err := r.ReadState(string(content))
+	if err != nil {
+		return err
+	}
+
+	state.Epic = m.SelectedEpic
+	state.Release = m.SelectedRelease
+
+	return data.WriteRouterState(m.Root, state, fi.ModTime())
+}

package/internal/board/model_test.go

@@ -0,0 +1,67 @@
+package board
+
+import (
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestNewModel_emptyTasks(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+
+	if m.SelectedRelease != "v1" {
+		t.Errorf("SelectedRelease = %q, want %q", m.SelectedRelease, "v1")
+	}
+	if m.SelectedEpic != "E03" {
+		t.Errorf("SelectedEpic = %q, want %q", m.SelectedEpic, "E03")
+	}
+	if m.FocusedColumn != data.ColumnPlanned {
+		t.Errorf("FocusedColumn = %q, want %q", m.FocusedColumn, data.ColumnPlanned)
+	}
+	if m.FocusedTask != 0 {
+		t.Errorf("FocusedTask = %d, want 0", m.FocusedTask)
+	}
+	if m.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q, want empty", m.Overlay)
+	}
+	for _, col := range []data.ColumnType{data.ColumnPlanned, data.ColumnInProgress, data.ColumnDone} {
+		if _, ok := m.Tasks[col]; !ok {
+			t.Errorf("Tasks missing column %q", col)
+		}
+	}
+}
+
+func TestNewModel_groupsByColumn(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned},
+		{ID: "T2", Column: data.ColumnInProgress},
+		{ID: "T3", Column: data.ColumnDone},
+		{ID: "T4", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+
+	if got := len(m.Tasks[data.ColumnPlanned]); got != 2 {
+		t.Errorf("Planned count = %d, want 2", got)
+	}
+	if got := len(m.Tasks[data.ColumnInProgress]); got != 1 {
+		t.Errorf("InProgress count = %d, want 1", got)
+	}
+	if got := len(m.Tasks[data.ColumnDone]); got != 1 {
+		t.Errorf("Done count = %d, want 1", got)
+	}
+}
+
+func TestNewModel_emptyColumnDefaultsToPlanned(t *testing.T) {
+	tasks := []data.Task{{ID: "T1"}}
+	m := NewModel(tasks, "v1", "E03")
+
+	if got := len(m.Tasks[data.ColumnPlanned]); got != 1 {
+		t.Errorf("Planned count = %d, want 1 (empty column defaulted)", got)
+	}
+}
+
+func TestModel_Init(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	// Init must not panic and returns a valid Cmd (nil or batch).
+	_ = m.Init()
+}

package/internal/board/release.go

@@ -0,0 +1,42 @@
+package board
+
+import (
+	"strings"
+
+	"github.com/opencode/savepoint/internal/styles"
+)
+
+const releaseActiveMarker = "►"
+
+// RenderReleaseDropdown renders the release selection dropdown overlay.
+func RenderReleaseDropdown(releases []string, cursor int, width int) string {
+	inner := width - epicPanelOverhead
+	if inner < 2 {
+		inner = 2
+	}
+
+	lines := []string{styles.ColumnTitleFocused.Render("SELECT RELEASE"), strings.Repeat("─", inner)}
+	for i, r := range releases {
+		label := truncate(r, inner-2)
+		if i == cursor {
+			lines = append(lines, styles.TaskItemFocused.Render(releaseActiveMarker+" "+label))
+		} else {
+			lines = append(lines, styles.TaskItem.Render("  "+label))
+		}
+	}
+	if len(releases) == 0 {
+		lines = append(lines, styles.TaskItem.Render("(none)"))
+	}
+	lines = append(lines, "", styles.CardMeta.Render("↑↓:nav  enter:select  esc:cancel"))
+	return styles.EpicPanel.Width(width).Render(strings.Join(lines, "\n"))
+}
+
+// releaseIndex returns the index of selected in releases, or 0 if not found.
+func releaseIndex(releases []string, selected string) int {
+	for i, r := range releases {
+		if r == selected {
+			return i
+		}
+	}
+	return 0
+}

package/internal/board/release_test.go

@@ -0,0 +1,177 @@
+package board
+
+import (
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestRenderReleaseDropdown_showsReleases(t *testing.T) {
+	releases := []string{"v1", "v2", "v3"}
+	out := RenderReleaseDropdown(releases, 0, 40)
+	for _, r := range releases {
+		if !strings.Contains(out, r) {
+			t.Errorf("output missing release %q", r)
+		}
+	}
+}
+
+func TestRenderReleaseDropdown_marksCurrentCursor(t *testing.T) {
+	releases := []string{"v1", "v2"}
+	out := RenderReleaseDropdown(releases, 1, 40)
+	if !strings.Contains(out, releaseActiveMarker) {
+		t.Error("output missing active marker")
+	}
+}
+
+func TestRenderReleaseDropdown_emptyList(t *testing.T) {
+	out := RenderReleaseDropdown(nil, 0, 40)
+	if !strings.Contains(out, "(none)") {
+		t.Error("expected '(none)' for empty releases")
+	}
+}
+
+func TestRenderReleaseDropdown_hintsPresent(t *testing.T) {
+	out := RenderReleaseDropdown([]string{"v1"}, 0, 40)
+	if !strings.Contains(out, "esc:cancel") {
+		t.Error("expected hint text in dropdown")
+	}
+}
+
+func TestReleaseIndex_found(t *testing.T) {
+	releases := []string{"v1", "v2", "v3"}
+	if got := releaseIndex(releases, "v2"); got != 1 {
+		t.Errorf("releaseIndex = %d, want 1", got)
+	}
+}
+
+func TestReleaseIndex_notFound(t *testing.T) {
+	releases := []string{"v1", "v2"}
+	if got := releaseIndex(releases, "v9"); got != 0 {
+		t.Errorf("releaseIndex = %d, want 0", got)
+	}
+}
+
+func TestUpdate_rOpensReleaseOverlay(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Releases = []string{"v1", "v2"}
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("r")})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayRelease {
+		t.Errorf("Overlay = %q, want %q", updated.Overlay, OverlayRelease)
+	}
+}
+
+func TestUpdate_rSetsCursorToCurrentRelease(t *testing.T) {
+	m := NewModel(nil, "v2", "E03")
+	m.Releases = []string{"v1", "v2", "v3"}
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("r")})
+	updated := requireModel(t, got)
+	if updated.ReleaseCursor != 1 {
+		t.Errorf("ReleaseCursor = %d, want 1", updated.ReleaseCursor)
+	}
+}
+
+func TestUpdate_escClosesReleaseOverlay(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Overlay = OverlayRelease
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q, want empty", updated.Overlay)
+	}
+}
+
+func TestUpdate_releaseNavDown(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Releases = []string{"v1", "v2"}
+	m.Overlay = OverlayRelease
+	m.ReleaseCursor = 0
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
+	updated := requireModel(t, got)
+	if updated.ReleaseCursor != 1 {
+		t.Errorf("ReleaseCursor = %d, want 1", updated.ReleaseCursor)
+	}
+}
+
+func TestUpdate_releaseNavUp(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Releases = []string{"v1", "v2"}
+	m.Overlay = OverlayRelease
+	m.ReleaseCursor = 1
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
+	updated := requireModel(t, got)
+	if updated.ReleaseCursor != 0 {
+		t.Errorf("ReleaseCursor = %d, want 0", updated.ReleaseCursor)
+	}
+}
+
+func TestUpdate_releaseEnterSelects(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Epic: "E03", Release: "v1", Column: data.ColumnPlanned},
+		{ID: "T2", Epic: "E03", Release: "v2", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+	m.Releases = []string{"v1", "v2"}
+	m.Overlay = OverlayRelease
+	m.ReleaseCursor = 1
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	updated := requireModel(t, got)
+	if updated.SelectedRelease != "v2" {
+		t.Errorf("SelectedRelease = %q, want %q", updated.SelectedRelease, "v2")
+	}
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q, want empty after selection", updated.Overlay)
+	}
+	if got := len(updated.Tasks[data.ColumnPlanned]); got != 1 {
+		t.Errorf("planned task count = %d, want 1 after release selection", got)
+	}
+	if updated.Tasks[data.ColumnPlanned][0].ID != "T2" {
+		t.Errorf("visible task = %q, want T2", updated.Tasks[data.ColumnPlanned][0].ID)
+	}
+}
+
+func TestUpdate_releaseEnterRefreshesEpics(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Epic: "E01", Release: "v1", Column: data.ColumnPlanned},
+		{ID: "T2", Epic: "E03", Release: "v2", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E01")
+	m.Releases = []string{"v1", "v2"}
+	m.ReleaseEpics = map[string][]string{
+		"v1": []string{"E01"},
+		"v2": []string{"E03"},
+	}
+	m.Overlay = OverlayRelease
+	m.ReleaseCursor = 1
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	updated := requireModel(t, got)
+
+	if updated.SelectedEpic != "E03" {
+		t.Errorf("SelectedEpic = %q, want E03", updated.SelectedEpic)
+	}
+	if len(updated.Epics) != 1 || updated.Epics[0] != "E03" {
+		t.Errorf("Epics = %v, want [E03]", updated.Epics)
+	}
+	if got := len(updated.Tasks[data.ColumnPlanned]); got != 1 {
+		t.Fatalf("planned task count = %d, want 1", got)
+	}
+	if updated.Tasks[data.ColumnPlanned][0].ID != "T2" {
+		t.Errorf("visible task = %q, want T2", updated.Tasks[data.ColumnPlanned][0].ID)
+	}
+}
+
+func TestView_releaseDropdownKeepsBoardBehind(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 100
+	m.Height = 24
+	m.Overlay = OverlayRelease
+	m.Releases = []string{"v1", "v2"}
+	got := m.View()
+	if !strings.Contains(got, "S A V E P O I N T") {
+		t.Error("View() with OverlayRelease should keep board visible behind overlay")
+	}
+}