savepoint 1.0.0

package/internal/board/detail.go

@@ -0,0 +1,140 @@
+package board
+
+import (
+	"strings"
+
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/styles"
+)
+
+const detailBorderPad = 4 // rounded border (2) + padding (2×1)
+
+// RenderDetail renders a task detail overlay panel at the given display width.
+func RenderDetail(t data.Task, overlayW int) string {
+	inner := overlayW - detailBorderPad
+	if inner < 4 {
+		inner = 4
+	}
+
+	lines := []string{
+		styles.ColumnTitleFocused.Render("TASK DETAIL"),
+		strings.Repeat("─", inner),
+	}
+	lines = append(lines,
+		detailRow("ID", t.ID, inner),
+		detailRow("Title", t.Title, inner),
+		detailRow("Epic", t.Epic, inner),
+		detailRow("Release", t.Release, inner),
+		detailRow("Status", string(t.Column), inner),
+		detailRow("Phase", phaseLabel(t.Stage), inner),
+	)
+
+	if t.Description != "" {
+		lines = append(lines,
+			"",
+			styles.ColumnTitle.Render("Description:"),
+		)
+		for _, line := range wrapText(t.Description, inner) {
+			lines = append(lines, styles.CardMeta.Render(line))
+		}
+	}
+
+	if len(t.Acceptance) > 0 {
+		lines = append(lines, "", styles.ColumnTitle.Render("Acceptance Criteria:"))
+		for _, a := range t.Acceptance {
+			for _, line := range wrapText(a, inner-2) {
+				lines = append(lines, styles.CardMeta.Render("  • "+line))
+			}
+		}
+	}
+
+	if len(t.Checklist) > 0 {
+		lines = append(lines, "", styles.ColumnTitle.Render("Implementation Plan:"))
+		for _, item := range t.Checklist {
+			for _, line := range wrapText(item, inner-2) {
+				lines = append(lines, styles.CardMeta.Render("  □ "+line))
+			}
+		}
+	}
+
+	lines = append(lines, "", styles.CardMeta.Render("esc:close"))
+
+	return styles.DetailOverlay.Width(overlayW).Render(strings.Join(lines, "\n"))
+}
+
+func detailRow(label, value string, width int) string {
+	prefix := label + ": "
+	wrapped := wrapText(value, width-len(prefix))
+	if len(wrapped) == 0 {
+		wrapped = []string{""}
+	}
+	lines := make([]string, 0, len(wrapped))
+	for i, line := range wrapped {
+		if i == 0 {
+			lines = append(lines, styles.ColumnTitle.Render(prefix)+styles.CardMeta.Render(line))
+			continue
+		}
+		lines = append(lines, strings.Repeat(" ", len(prefix))+styles.CardMeta.Render(line))
+	}
+	return strings.Join(lines, "\n")
+}
+
+func phaseLabel(s data.ProgressStage) string {
+	switch s {
+	case data.StageTest:
+		return "test"
+	case data.StageAudit:
+		return "audit"
+	default:
+		return "build"
+	}
+}
+
+func wrapText(s string, width int) []string {
+	if width < 4 {
+		width = 4
+	}
+	words := strings.Fields(s)
+	if len(words) == 0 {
+		return nil
+	}
+	lines := []string{}
+	current := ""
+	for _, word := range words {
+		if len([]rune(word)) > width {
+			if current != "" {
+				lines = append(lines, current)
+				current = ""
+			}
+			lines = append(lines, splitLongWord(word, width)...)
+			continue
+		}
+		if current == "" {
+			current = word
+			continue
+		}
+		if len([]rune(current))+1+len([]rune(word)) <= width {
+			current += " " + word
+			continue
+		}
+		lines = append(lines, current)
+		current = word
+	}
+	if current != "" {
+		lines = append(lines, current)
+	}
+	return lines
+}
+
+func splitLongWord(word string, width int) []string {
+	runes := []rune(word)
+	lines := []string{}
+	for len(runes) > width {
+		lines = append(lines, string(runes[:width]))
+		runes = runes[width:]
+	}
+	if len(runes) > 0 {
+		lines = append(lines, string(runes))
+	}
+	return lines
+}

package/internal/board/detail_test.go

@@ -0,0 +1,233 @@
+package board
+
+import (
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func sampleTask() data.Task {
+	return data.Task{
+		ID:      "E04/T001",
+		Title:   "My Task",
+		Epic:    "E04-board-components",
+		Release: "v1",
+		Column:  data.ColumnInProgress,
+		Stage:   data.StageBuild,
+	}
+}
+
+func TestRenderDetail_containsID(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if !strings.Contains(got, "E04/T001") {
+		t.Error("RenderDetail missing task ID")
+	}
+}
+
+func TestRenderDetail_containsTitle(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if !strings.Contains(got, "My Task") {
+		t.Error("RenderDetail missing task title")
+	}
+}
+
+func TestRenderDetail_containsEpic(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if !strings.Contains(got, "E04-board-components") {
+		t.Error("RenderDetail missing epic")
+	}
+}
+
+func TestRenderDetail_containsRelease(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if !strings.Contains(got, "v1") {
+		t.Error("RenderDetail missing release")
+	}
+}
+
+func TestRenderDetail_containsStatus(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if !strings.Contains(got, "in_progress") {
+		t.Error("RenderDetail missing status")
+	}
+}
+
+func TestRenderDetail_containsPhase(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if !strings.Contains(got, "build") {
+		t.Error("RenderDetail missing phase")
+	}
+}
+
+func TestRenderDetail_containsEscHint(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if !strings.Contains(got, "esc") {
+		t.Error("RenderDetail missing esc:close hint")
+	}
+}
+
+func TestRenderDetail_containsDescription(t *testing.T) {
+	tk := sampleTask()
+	tk.Description = "some description text"
+	got := RenderDetail(tk, 60)
+	if !strings.Contains(got, "some description text") {
+		t.Error("RenderDetail missing description text")
+	}
+}
+
+func TestRenderDetail_noDescriptionSectionWhenEmpty(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if strings.Contains(got, "Description:") {
+		t.Error("RenderDetail should not show Description section when empty")
+	}
+}
+
+func TestRenderDetail_containsAcceptanceCriteria(t *testing.T) {
+	tk := sampleTask()
+	tk.Acceptance = []string{"criterion one", "criterion two"}
+	got := RenderDetail(tk, 60)
+	if !strings.Contains(got, "criterion one") {
+		t.Error("RenderDetail missing first acceptance criterion")
+	}
+	if !strings.Contains(got, "criterion two") {
+		t.Error("RenderDetail missing second acceptance criterion")
+	}
+}
+
+func TestRenderDetail_containsChecklist(t *testing.T) {
+	tk := sampleTask()
+	tk.Checklist = []string{"first implementation item", "second implementation item"}
+	got := RenderDetail(tk, 60)
+	if !strings.Contains(got, "Implementation Plan:") {
+		t.Error("RenderDetail missing implementation plan heading")
+	}
+	if !strings.Contains(got, "first implementation item") {
+		t.Error("RenderDetail missing first checklist item")
+	}
+	if !strings.Contains(got, "second implementation item") {
+		t.Error("RenderDetail missing second checklist item")
+	}
+}
+
+func TestRenderDetail_wrapsLongDescription(t *testing.T) {
+	tk := sampleTask()
+	tk.Description = "alpha beta gamma delta epsilon zeta eta theta iota kappa lambda"
+	got := RenderDetail(tk, 30)
+	if strings.Contains(got, tk.Description) {
+		t.Error("RenderDetail should wrap long description text")
+	}
+	if !strings.Contains(got, "alpha beta") || !strings.Contains(got, "lambda") {
+		t.Error("RenderDetail should preserve wrapped description words")
+	}
+}
+
+func TestRenderDetail_noAcceptanceSectionWhenEmpty(t *testing.T) {
+	got := RenderDetail(sampleTask(), 60)
+	if strings.Contains(got, "Acceptance Criteria:") {
+		t.Error("RenderDetail should not show Acceptance section when empty")
+	}
+}
+
+func TestPhaseLabel_build(t *testing.T) {
+	if got := phaseLabel(data.StageBuild); got != "build" {
+		t.Errorf("phaseLabel(StageBuild) = %q, want %q", got, "build")
+	}
+}
+
+func TestPhaseLabel_test(t *testing.T) {
+	if got := phaseLabel(data.StageTest); got != "test" {
+		t.Errorf("phaseLabel(StageTest) = %q, want %q", got, "test")
+	}
+}
+
+func TestPhaseLabel_audit(t *testing.T) {
+	if got := phaseLabel(data.StageAudit); got != "audit" {
+		t.Errorf("phaseLabel(StageAudit) = %q, want %q", got, "audit")
+	}
+}
+
+func TestPhaseLabel_default(t *testing.T) {
+	if got := phaseLabel(""); got != "build" {
+		t.Errorf("phaseLabel(%q) = %q, want %q", "", got, "build")
+	}
+}
+
+func TestUpdate_enterOpensDetailOverlay(t *testing.T) {
+	tasks := []data.Task{sampleTask()}
+	m := NewModel(tasks, "v1", "E04-board-components")
+	m.FocusedColumn = data.ColumnInProgress
+	m.FocusedTask = 0
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayDetail {
+		t.Errorf("Overlay = %q, want %q", updated.Overlay, OverlayDetail)
+	}
+}
+
+func TestUpdate_enterNoOpWhenNoTasks(t *testing.T) {
+	m := NewModel(nil, "v1", "E04-board-components")
+	m.FocusedColumn = data.ColumnPlanned
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q, want none when column has no tasks", updated.Overlay)
+	}
+}
+
+func TestUpdate_detailOverlayEscCloses(t *testing.T) {
+	m := NewModel(nil, "v1", "E04-board-components")
+	m.Overlay = OverlayDetail
+	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_detailOverlayBlocksColumnNav(t *testing.T) {
+	m := NewModel(nil, "v1", "E04-board-components")
+	m.Overlay = OverlayDetail
+	m.FocusedColumn = data.ColumnPlanned
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("l")})
+	updated := requireModel(t, got)
+	if updated.FocusedColumn != data.ColumnPlanned {
+		t.Error("column nav should be blocked when detail overlay is open")
+	}
+}
+
+func TestView_detailOverlayRendered(t *testing.T) {
+	tasks := []data.Task{sampleTask()}
+	m := NewModel(tasks, "v1", "E04-board-components")
+	m.Width = 100
+	m.Height = 30
+	m.FocusedColumn = data.ColumnInProgress
+	m.FocusedTask = 0
+	m.Overlay = OverlayDetail
+	got := m.View()
+	if !strings.Contains(got, "TASK DETAIL") {
+		t.Error("View() with OverlayDetail missing TASK DETAIL header")
+	}
+	if !strings.Contains(got, "E04/T001") {
+		t.Error("View() with OverlayDetail missing task ID")
+	}
+}
+
+func TestOverlayWidth_clampMax(t *testing.T) {
+	if got := overlayWidth(120); got != 80 {
+		t.Errorf("overlayWidth(120) = %d, want 80", got)
+	}
+}
+
+func TestOverlayWidth_termMinus4(t *testing.T) {
+	if got := overlayWidth(60); got != 56 {
+		t.Errorf("overlayWidth(60) = %d, want 56", got)
+	}
+}
+
+func TestOverlayWidth_clampMin(t *testing.T) {
+	if got := overlayWidth(10); got != 20 {
+		t.Errorf("overlayWidth(10) = %d, want 20", got)
+	}
+}

package/internal/board/epic_panel.go

@@ -0,0 +1,69 @@
+package board
+
+import (
+	"strings"
+
+	"github.com/opencode/savepoint/internal/styles"
+)
+
+const epicActiveMarker = "►"
+
+// RenderEpicSidebar renders the fixed left sidebar listing epics with active indicator.
+// If epics is empty and selected is non-empty, selected is shown as the sole entry.
+func RenderEpicSidebar(epics []string, selected string, width int) string {
+	inner := width - epicPanelOverhead
+	if inner < 2 {
+		inner = 2
+	}
+	list := epics
+	if len(list) == 0 && selected != "" {
+		list = []string{selected}
+	}
+
+	lines := []string{styles.ColumnTitle.Render("EPICS"), strings.Repeat("─", inner)}
+	for _, e := range list {
+		label := truncate(e, inner-2)
+		if e == selected {
+			lines = append(lines, styles.TaskItemFocused.Render(epicActiveMarker+" "+label))
+		} else {
+			lines = append(lines, styles.TaskItem.Render("  "+label))
+		}
+	}
+	if len(list) == 0 {
+		lines = append(lines, styles.TaskItem.Render("(none)"))
+	}
+	return styles.EpicPanel.Width(width).Render(strings.Join(lines, "\n"))
+}
+
+// RenderEpicDropdown renders the epic selection dropdown overlay.
+func RenderEpicDropdown(epics []string, cursor int, width int) string {
+	inner := width - epicPanelOverhead
+	if inner < 2 {
+		inner = 2
+	}
+
+	lines := []string{styles.ColumnTitleFocused.Render("SELECT EPIC"), strings.Repeat("─", inner)}
+	for i, e := range epics {
+		label := truncate(e, inner-2)
+		if i == cursor {
+			lines = append(lines, styles.TaskItemFocused.Render(epicActiveMarker+" "+label))
+		} else {
+			lines = append(lines, styles.TaskItem.Render("  "+label))
+		}
+	}
+	if len(epics) == 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"))
+}
+
+// epicIndex returns the index of selected in epics, or 0 if not found.
+func epicIndex(epics []string, selected string) int {
+	for i, e := range epics {
+		if e == selected {
+			return i
+		}
+	}
+	return 0
+}

package/internal/board/epic_panel_test.go

@@ -0,0 +1,246 @@
+package board
+
+import (
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestRenderEpicSidebar_containsEpicsHeader(t *testing.T) {
+	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28)
+	if !strings.Contains(got, "EPICS") {
+		t.Error("RenderEpicSidebar missing EPICS header")
+	}
+}
+
+func TestRenderEpicSidebar_activeEpicMarked(t *testing.T) {
+	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28)
+	if !strings.Contains(got, epicActiveMarker) {
+		t.Errorf("RenderEpicSidebar missing active marker %q", epicActiveMarker)
+	}
+}
+
+func TestRenderEpicSidebar_allEpicsPresent(t *testing.T) {
+	epics := []string{"E01-foo", "E02-bar", "E03-baz"}
+	got := RenderEpicSidebar(epics, "E01-foo", 32)
+	for _, e := range epics {
+		if !strings.Contains(got, e) {
+			t.Errorf("RenderEpicSidebar missing epic %q", e)
+		}
+	}
+}
+
+func TestRenderEpicSidebar_emptyEpicsFallback(t *testing.T) {
+	got := RenderEpicSidebar(nil, "E03", 28)
+	if !strings.Contains(got, "E03") {
+		t.Error("RenderEpicSidebar with empty list should show selected epic")
+	}
+}
+
+func TestRenderEpicSidebar_emptyBothShowsNone(t *testing.T) {
+	got := RenderEpicSidebar(nil, "", 28)
+	if !strings.Contains(got, "(none)") {
+		t.Error("RenderEpicSidebar with no epics and no selected should show (none)")
+	}
+}
+
+func TestRenderEpicDropdown_containsHeader(t *testing.T) {
+	got := RenderEpicDropdown([]string{"E01", "E02"}, 0, 32)
+	if !strings.Contains(got, "SELECT EPIC") {
+		t.Error("RenderEpicDropdown missing SELECT EPIC header")
+	}
+}
+
+func TestRenderEpicDropdown_cursorMarked(t *testing.T) {
+	got := RenderEpicDropdown([]string{"E01", "E02"}, 1, 32)
+	if !strings.Contains(got, epicActiveMarker) {
+		t.Errorf("RenderEpicDropdown missing cursor marker %q", epicActiveMarker)
+	}
+}
+
+func TestRenderEpicDropdown_containsHint(t *testing.T) {
+	got := RenderEpicDropdown([]string{"E01"}, 0, 32)
+	if !strings.Contains(got, "esc") {
+		t.Error("RenderEpicDropdown missing esc hint")
+	}
+}
+
+func TestRenderEpicDropdown_emptyShowsNone(t *testing.T) {
+	got := RenderEpicDropdown(nil, 0, 32)
+	if !strings.Contains(got, "(none)") {
+		t.Error("RenderEpicDropdown with no epics should show (none)")
+	}
+}
+
+func TestEpicIndex_found(t *testing.T) {
+	epics := []string{"E01", "E02", "E03"}
+	if got := epicIndex(epics, "E02"); got != 1 {
+		t.Errorf("epicIndex = %d, want 1", got)
+	}
+}
+
+func TestEpicIndex_notFound(t *testing.T) {
+	if got := epicIndex([]string{"E01"}, "E99"); got != 0 {
+		t.Errorf("epicIndex not-found = %d, want 0", got)
+	}
+}
+
+func TestEpicIndex_empty(t *testing.T) {
+	if got := epicIndex(nil, "E01"); got != 0 {
+		t.Errorf("epicIndex empty = %d, want 0", got)
+	}
+}
+
+// Update integration tests for epic dropdown
+
+func TestUpdate_eKeyOpensDropdownNarrow(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 80 // narrow: < 120
+	m.Epics = []string{"E01", "E03"}
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("e")})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayEpic {
+		t.Errorf("Overlay = %q, want %q", updated.Overlay, OverlayEpic)
+	}
+}
+
+func TestUpdate_eKeyOpensDropdownWide(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.Epics = []string{"E01", "E03"}
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("e")})
+	updated := requireModel(t, got)
+	if updated.Overlay != OverlayEpic {
+		t.Errorf("Overlay = %q, want %q", updated.Overlay, OverlayEpic)
+	}
+}
+
+func TestUpdate_epicDropdownEscCloses(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Overlay = OverlayEpic
+	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_epicDropdownDownMovesCursor(t *testing.T) {
+	m := NewModel(nil, "v1", "E01")
+	m.Overlay = OverlayEpic
+	m.Epics = []string{"E01", "E02", "E03"}
+	m.EpicCursor = 0
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyDown})
+	updated := requireModel(t, got)
+	if updated.EpicCursor != 1 {
+		t.Errorf("EpicCursor = %d, want 1", updated.EpicCursor)
+	}
+}
+
+func TestUpdate_epicDropdownUpMovesCursor(t *testing.T) {
+	m := NewModel(nil, "v1", "E02")
+	m.Overlay = OverlayEpic
+	m.Epics = []string{"E01", "E02", "E03"}
+	m.EpicCursor = 2
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyUp})
+	updated := requireModel(t, got)
+	if updated.EpicCursor != 1 {
+		t.Errorf("EpicCursor = %d, want 1", updated.EpicCursor)
+	}
+}
+
+func TestUpdate_epicDropdownEnterSelectsEpic(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Epic: "E01", Release: "v1", Column: data.ColumnPlanned},
+		{ID: "T3", Epic: "E03", Release: "v1", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E01")
+	m.Overlay = OverlayEpic
+	m.Epics = []string{"E01", "E02", "E03"}
+	m.EpicCursor = 2
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	updated := requireModel(t, got)
+	if updated.SelectedEpic != "E03" {
+		t.Errorf("SelectedEpic = %q, want %q", updated.SelectedEpic, "E03")
+	}
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q after enter, want none", updated.Overlay)
+	}
+	if got := len(updated.Tasks[data.ColumnPlanned]); got != 1 {
+		t.Errorf("planned task count = %d, want 1 after epic selection", got)
+	}
+	if updated.Tasks[data.ColumnPlanned][0].ID != "T3" {
+		t.Errorf("visible task = %q, want T3", updated.Tasks[data.ColumnPlanned][0].ID)
+	}
+}
+
+func TestUpdate_epicDropdownDownClampedAtEnd(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Overlay = OverlayEpic
+	m.Epics = []string{"E01", "E02"}
+	m.EpicCursor = 1
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyDown})
+	updated := requireModel(t, got)
+	if updated.EpicCursor != 1 {
+		t.Errorf("EpicCursor = %d, want 1 (clamped)", updated.EpicCursor)
+	}
+}
+
+func TestUpdate_epicDropdownUpClampedAtStart(t *testing.T) {
+	m := NewModel(nil, "v1", "E01")
+	m.Overlay = OverlayEpic
+	m.Epics = []string{"E01", "E02"}
+	m.EpicCursor = 0
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyUp})
+	updated := requireModel(t, got)
+	if updated.EpicCursor != 0 {
+		t.Errorf("EpicCursor = %d, want 0 (clamped)", updated.EpicCursor)
+	}
+}
+
+func TestUpdate_overlayBlocksColumnNav(t *testing.T) {
+	m := NewModel(nil, "v1", "E01")
+	m.Overlay = OverlayEpic
+	m.FocusedColumn = "planned"
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("l")})
+	updated := requireModel(t, got)
+	if updated.FocusedColumn != "planned" {
+		t.Error("column nav should be blocked when overlay is open")
+	}
+}
+
+func TestView_epicDropdownOverlayRendered(t *testing.T) {
+	m := NewModel(nil, "v1", "E01")
+	m.Width = 80
+	m.Height = 24
+	m.Overlay = OverlayEpic
+	m.Epics = []string{"E01", "E02"}
+	got := m.View()
+	if !strings.Contains(got, "SELECT EPIC") {
+		t.Error("View() with OverlayEpic missing SELECT EPIC")
+	}
+}
+
+func TestView_epicDropdownKeepsBoardBehind(t *testing.T) {
+	m := NewModel(nil, "v1", "E01")
+	m.Width = 100
+	m.Height = 24
+	m.Overlay = OverlayEpic
+	m.Epics = []string{"E01", "E02"}
+	got := m.View()
+	if !strings.Contains(got, "S A V E P O I N T") {
+		t.Error("View() with OverlayEpic should keep board visible behind overlay")
+	}
+}
+
+func TestView_epicSidebarOnWide(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.Epics = []string{"E01", "E03"}
+	got := m.View()
+	if !strings.Contains(got, "EPICS") {
+		t.Error("View() at width>=120 missing EPICS header in sidebar")
+	}
+}