savepoint 1.0.1 → 1.0.2

package/internal/board/model.go

@@ -12,33 +12,42 @@ import (
 type OverlayType string
 
 const (
-	OverlayNone    OverlayType = ""
-	OverlayHelp    OverlayType = "help"
-	OverlayEpic    OverlayType = "epic"
-	OverlayRelease OverlayType = "release"
-	OverlayDetail  OverlayType = "detail"
+	OverlayNone       OverlayType = ""
+	OverlayHelp       OverlayType = "help"
+	OverlayEpic       OverlayType = "epic"
+	OverlayRelease    OverlayType = "release"
+	OverlayDetail     OverlayType = "detail"
+	OverlayEpicDetail OverlayType = "detail-epic"
 )
 
 // 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
-	RouterTask      string
-	Watcher         *fsnotify.Watcher
+	AllTasks          []data.Task
+	Tasks             map[data.ColumnType][]data.Task
+	FocusedColumn     data.ColumnType
+	FocusedTask       int
+	ColumnOffsets     map[data.ColumnType]int
+	DetailOffset      int
+	SelectedEpic      string
+	SelectedRelease   string
+	Epics             []string
+	EpicCursor        int
+	EpicPanelFocus    bool
+	EpicPanelCursor   int
+	EpicDetailOffset  int
+	EpicDetailContent string
+	Releases          []string
+	ReleaseEpics      map[string][]string
+	ReleaseCursor     int
+	Overlay           OverlayType
+	Width             int
+	Height            int
+	StatusMessage     string
+	Root              string
+	EpicStatus        map[string]string
+	RouterTask        string
+	RouterState       *data.RouterState
+	Watcher           *fsnotify.Watcher
 }
 
 // NewModel groups tasks by column and returns an initialized Model.
@@ -47,6 +56,7 @@ func NewModel(tasks []data.Task, release, epic string) Model {
 		AllTasks:        append([]data.Task(nil), tasks...),
 		FocusedColumn:   data.ColumnPlanned,
 		FocusedTask:     0,
+		ColumnOffsets:   newColumnOffsets(),
 		SelectedEpic:    epic,
 		SelectedRelease: release,
 		Overlay:         OverlayNone,
@@ -91,6 +101,15 @@ func (m *Model) refreshTasks() {
 	}
 	m.Tasks = groupedTasks(visible)
 	m.clampFocusedTask()
+	m.clampColumnOffsets()
+}
+
+func newColumnOffsets() map[data.ColumnType]int {
+	return map[data.ColumnType]int{
+		data.ColumnPlanned:    0,
+		data.ColumnInProgress: 0,
+		data.ColumnDone:       0,
+	}
 }
 
 func (m *Model) refreshEpicsForRelease() {
@@ -103,18 +122,36 @@ func (m *Model) refreshEpicsForRelease() {
 	if len(m.Epics) == 0 {
 		m.SelectedEpic = ""
 		m.EpicCursor = 0
+		m.EpicPanelCursor = 0
+		m.EpicPanelFocus = false
 		return
 	}
 
 	for _, epic := range m.Epics {
 		if epic == m.SelectedEpic {
 			m.EpicCursor = epicIndex(m.Epics, m.SelectedEpic)
+			m.clampEpicPanelCursor()
 			return
 		}
 	}
 
 	m.SelectedEpic = m.Epics[0]
 	m.EpicCursor = 0
+	m.clampEpicPanelCursor()
+}
+
+func (m *Model) clampEpicPanelCursor() {
+	if len(m.Epics) == 0 {
+		m.EpicPanelCursor = 0
+		m.EpicPanelFocus = false
+		return
+	}
+	if m.EpicPanelCursor >= len(m.Epics) {
+		m.EpicPanelCursor = len(m.Epics) - 1
+	}
+	if m.EpicPanelCursor < 0 {
+		m.EpicPanelCursor = 0
+	}
 }
 
 func (m *Model) clampFocusedTask() {
@@ -131,6 +168,23 @@ func (m *Model) clampFocusedTask() {
 	}
 }
 
+func (m *Model) clampColumnOffsets() {
+	if m.ColumnOffsets == nil {
+		m.ColumnOffsets = newColumnOffsets()
+	}
+	for _, col := range columnOrder {
+		tasks := m.Tasks[col]
+		offset := m.ColumnOffsets[col]
+		if offset < 0 || len(tasks) == 0 {
+			m.ColumnOffsets[col] = 0
+			continue
+		}
+		if offset >= len(tasks) {
+			m.ColumnOffsets[col] = len(tasks) - 1
+		}
+	}
+}
+
 func (m *Model) writeRouterReleaseEpic() error {
 	routerPath := filepath.Join(m.Root, "router.md")
 
@@ -150,8 +204,71 @@ func (m *Model) writeRouterReleaseEpic() error {
 		return err
 	}
 
-	state.Epic = m.SelectedEpic
+	state.Epic = shortID(m.SelectedEpic)
 	state.Release = m.SelectedRelease
 
 	return data.WriteRouterState(m.Root, state, fi.ModTime())
 }
+
+func (m *Model) writeRouterTask(task data.Task) (string, 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.Release = task.Release
+	state.Epic = task.Epic
+	if m.isLastUncompletedTask(task) {
+		state.State = "audit-pending"
+		state.Task = ""
+		state.NextAction = "Audit " + task.Epic + "."
+		if err := data.WriteRouterState(m.Root, state, fi.ModTime()); err != nil {
+			return "", err
+		}
+		m.RouterState = state
+		m.RouterTask = ""
+		return "Audit pending for " + task.Epic, nil
+	}
+
+	state.State = "task-building"
+	state.Task = task.ID
+	state.NextAction = "Build " + task.ID + "."
+	if err := data.WriteRouterState(m.Root, state, fi.ModTime()); err != nil {
+		return "", err
+	}
+	m.RouterState = state
+	m.RouterTask = task.ID
+	return "Router set to " + task.Release + " " + task.Epic + "/" + shortID(task.ID), nil
+}
+
+func (m Model) isLastUncompletedTask(task data.Task) bool {
+	for _, candidate := range m.AllTasks {
+		if candidate.ID == task.ID {
+			continue
+		}
+		if candidate.Release != task.Release || candidate.Epic != task.Epic {
+			continue
+		}
+		if !taskDone(candidate) {
+			return false
+		}
+	}
+	return true
+}
+
+func taskDone(task data.Task) bool {
+	return task.Column == data.ColumnDone || task.Status == string(data.StatusDone)
+}

package/internal/board/render_policy_test.go

@@ -0,0 +1,77 @@
+package board
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/termenv"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestRenderPolicy_noBackgroundEscapes(t *testing.T) {
+	lipgloss.SetColorProfile(termenv.ANSI256)
+
+	task := data.Task{
+		ID:      "E05-tasking-permissions/T004-implement-m-hotkey",
+		Title:   "Implement router priority",
+		Release: "v1.1",
+		Epic:    "E05-tasking-permissions",
+		Column:  data.ColumnInProgress,
+		Stage:   data.StageBuild,
+	}
+	m := NewModel([]data.Task{
+		{
+			ID:      task.ID,
+			Title:   task.Title,
+			Release: task.Release,
+			Epic:    task.Epic,
+			Column:  task.Column,
+			Stage:   task.Stage,
+		},
+	}, "v1.1", "E05-tasking-permissions")
+	m.Width = 120
+	m.Height = 30
+	m.FocusedColumn = data.ColumnInProgress
+	m.RouterState = &data.RouterState{
+		State:      "task-building",
+		Release:    "v1.1",
+		Epic:       "E05-tasking-permissions",
+		Task:       "E05-tasking-permissions/T004-implement-m-hotkey",
+		NextAction: "Build E05-tasking-permissions/T004-implement-m-hotkey.",
+	}
+
+	cases := map[string]string{
+		"board":            m.View(),
+		"card":             RenderCard(task, 30, true, m.RouterState),
+		"detail":           RenderDetail(task, 60, m.RouterState, 0, 0),
+		"epic dropdown":    RenderEpicDropdown([]string{"E05-tasking-permissions"}, 0, 40),
+		"release dropdown": RenderReleaseDropdown([]string{"v1.1"}, 0, 40),
+		"help":             RenderHelp(60),
+	}
+	for name, got := range cases {
+		assertNoBackgroundEscapes(t, name, got)
+	}
+}
+
+func assertNoBackgroundEscapes(t *testing.T, name, got string) {
+	t.Helper()
+	for _, escape := range []string{"\x1b[48;", "\x1b[40m"} {
+		if strings.Contains(got, escape) {
+			t.Fatalf("%s emitted background escape prefix %q in %q", name, escape, got)
+		}
+	}
+}
+
+func TestRenderPolicy_usesSingleLineBorders(t *testing.T) {
+	m := NewModel([]data.Task{{ID: "T001", Title: "Task", Column: data.ColumnPlanned}}, "v1", "E01")
+	m.Width = 120
+	got := m.View()
+
+	if strings.Contains(got, "╭") || strings.Contains(got, "╮") || strings.Contains(got, "╰") || strings.Contains(got, "╯") {
+		t.Fatalf("View should use single-line borders, got rounded border glyphs in %q", got)
+	}
+	if !strings.Contains(got, "┌") || !strings.Contains(got, "┐") || !strings.Contains(got, "└") || !strings.Contains(got, "┘") {
+		t.Fatalf("View missing expected single-line border glyphs in %q", got)
+	}
+}

package/internal/board/status.go

@@ -0,0 +1,23 @@
+package board
+
+import (
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/styles"
+)
+
+const statusGlyphDefault = " "
+
+func statusGlyph(status string) string {
+	switch status {
+	case string(data.StatusPlanned):
+		return styles.CardMeta.Render("○")
+	case string(data.StatusInProgress):
+		return styles.GlyphBuild.Render("▶")
+	case string(data.StatusDone):
+		return styles.TagDone.Render("◉")
+	case string(data.StatusAudited):
+		return styles.TagDone.Render("✓")
+	default:
+		return statusGlyphDefault
+	}
+}

package/internal/board/update.go

@@ -1,6 +1,10 @@
 package board
 
 import (
+	"os"
+	"path/filepath"
+	"strings"
+
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/opencode/savepoint/internal/data"
 )
@@ -19,7 +23,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 	case reloadMsg:
 		m.AllTasks = msg.tasks
+		m.Releases = append([]string(nil), msg.releases...)
+		m.ReleaseEpics = copyReleaseEpics(msg.releaseEpics)
+		m.EpicStatus = msg.epicStatuses
+		m.SelectedRelease = firstKnown(m.SelectedRelease, m.Releases)
+		m.refreshEpicsForRelease()
 		m.refreshTasks()
+		m.ensureFocusedTaskVisible()
 		if m.Watcher != nil {
 			return m, watchFiles(m.Watcher)
 		}
@@ -33,28 +43,85 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m.Watcher.Close()
 			}
 			return m, tea.Quit
+		case "e":
+			m.Overlay = OverlayEpic
+			m.EpicCursor = epicIndex(m.Epics, m.SelectedEpic)
+			return m, nil
+		case "r":
+			m.Overlay = OverlayRelease
+			m.ReleaseCursor = releaseIndex(m.Releases, m.SelectedRelease)
+			return m, nil
+		case "?":
+			m.Overlay = OverlayHelp
+			return m, nil
+		case "m":
+			task, ok := m.focusedTask()
+			if !ok {
+				return m, nil
+			}
+			if taskDone(task) {
+				m.StatusMessage = "Router not updated: focused task is done"
+				return m, nil
+			}
+			if m.Root == "" {
+				m.StatusMessage = "Router not updated: no savepoint root"
+				return m, nil
+			}
+			message, err := m.writeRouterTask(task)
+			if err != nil {
+				m.StatusMessage = err.Error()
+				return m, nil
+			}
+			m.StatusMessage = message
+			return m, nil
+		}
+		if m.EpicPanelFocus {
+			if !m.epicPanelAvailable() {
+				m.EpicPanelFocus = false
+			} else {
+				return m.updateEpicPanel(msg)
+			}
+		}
+		switch msg.String() {
 		case "left", "h":
+			if m.FocusedColumn == data.ColumnPlanned && m.epicPanelAvailable() {
+				m.EpicPanelFocus = true
+				m.EpicPanelCursor = epicIndex(m.Epics, m.SelectedEpic)
+				m.StatusMessage = ""
+				return m, nil
+			}
 			m.FocusedColumn = prevColumn(m.FocusedColumn)
 			m.FocusedTask = 0
+			m.ensureFocusedTaskVisible()
 			m.StatusMessage = ""
 		case "right", "l":
 			m.FocusedColumn = nextColumn(m.FocusedColumn)
 			m.FocusedTask = 0
+			m.ensureFocusedTaskVisible()
 			m.StatusMessage = ""
 		case "up", "k":
 			if m.FocusedTask > 0 {
 				m.FocusedTask--
 			}
+			m.ensureFocusedTaskVisible()
 			m.StatusMessage = ""
 		case "down", "j":
 			if m.FocusedTask < len(m.Tasks[m.FocusedColumn])-1 {
 				m.FocusedTask++
 			}
+			m.ensureFocusedTaskVisible()
+			m.StatusMessage = ""
+		case "pgup":
+			m.scrollFocusedColumn(-m.columnPageSize())
+			m.StatusMessage = ""
+		case "pgdown":
+			m.scrollFocusedColumn(m.columnPageSize())
 			m.StatusMessage = ""
 		case "enter":
 			tasks := m.Tasks[m.FocusedColumn]
 			if len(tasks) > 0 && m.FocusedTask < len(tasks) {
 				m.Overlay = OverlayDetail
+				m.DetailOffset = 0
 			}
 			m.StatusMessage = ""
 		case " ":
@@ -77,6 +144,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 						}
 					}
 					m.refreshTasks()
+					m.ensureFocusedTaskVisible()
 				}
 			}
 		case "backspace":
@@ -96,28 +164,124 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					}
 				}
 				m.refreshTasks()
+				m.ensureFocusedTaskVisible()
 			}
-		case "e":
-			m.Overlay = OverlayEpic
-			m.EpicCursor = epicIndex(m.Epics, m.SelectedEpic)
-		case "r":
-			m.Overlay = OverlayRelease
-			m.ReleaseCursor = releaseIndex(m.Releases, m.SelectedRelease)
-		case "?":
-			m.Overlay = OverlayHelp
 		}
 	case tea.WindowSizeMsg:
 		m.Width = msg.Width
 		m.Height = msg.Height
+		if !m.epicPanelAvailable() {
+			m.EpicPanelFocus = false
+		}
+		m.ensureFocusedTaskVisible()
+	}
+	return m, nil
+}
+
+func (m Model) updateEpicPanel(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	if len(m.Epics) == 0 {
+		m.EpicPanelFocus = false
+		return m, nil
+	}
+
+	m.StatusMessage = ""
+	switch msg.String() {
+	case "up", "k":
+		if m.EpicPanelCursor > 0 {
+			m.EpicPanelCursor--
+			m.selectEpicPanelEpic()
+		}
+	case "down", "j":
+		if m.EpicPanelCursor < len(m.Epics)-1 {
+			m.EpicPanelCursor++
+			m.selectEpicPanelEpic()
+		}
+	case "enter":
+		m.openEpicDetailOverlay()
+	case "right", "l":
+		m.EpicPanelFocus = false
+		m.FocusedColumn = data.ColumnPlanned
+		m.FocusedTask = 0
+		m.ensureFocusedTaskVisible()
+	case "left", "h":
+		// Stay in the panel; there is no focusable region further left.
 	}
 	return m, nil
 }
 
+func (m *Model) selectEpicPanelEpic() {
+	if len(m.Epics) == 0 || m.EpicPanelCursor < 0 || m.EpicPanelCursor >= len(m.Epics) {
+		return
+	}
+	m.SelectedEpic = m.Epics[m.EpicPanelCursor]
+	m.FocusedTask = 0
+	m.DetailOffset = 0
+	m.refreshTasks()
+	m.ensureFocusedTaskVisible()
+	if m.Root != "" {
+		if err := m.writeRouterReleaseEpic(); err != nil {
+			m.StatusMessage = err.Error()
+		}
+	}
+}
+
+func (m *Model) openEpicDetailOverlay() {
+	if len(m.Epics) == 0 || m.EpicPanelCursor < 0 || m.EpicPanelCursor >= len(m.Epics) {
+		return
+	}
+	epicSlug := m.Epics[m.EpicPanelCursor]
+	shortEpicID := epicSlug
+	if idx := strings.Index(epicSlug, "-"); idx >= 0 {
+		shortEpicID = epicSlug[:idx]
+	}
+	epicDir := filepath.Join(m.Root, "releases", m.SelectedRelease, "epics", epicSlug)
+	m.EpicDetailContent = readEpicDetailFile(epicDir, shortEpicID)
+	m.EpicDetailOffset = 0
+	m.Overlay = OverlayEpicDetail
+}
+
+// readEpicDetailFile finds and reads the canonical detail file for an epic.
+// Tries E##-Detail.md then E##-Design.md; falls back to any E##-*.md in the dir.
+func readEpicDetailFile(epicDir, shortID string) string {
+	for _, suffix := range []string{"-Detail.md", "-Design.md"} {
+		if raw, err := os.ReadFile(filepath.Join(epicDir, shortID+suffix)); err == nil {
+			return string(raw)
+		}
+	}
+	entries, err := os.ReadDir(epicDir)
+	if err != nil {
+		return "(no detail available)"
+	}
+	prefix := shortID + "-"
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasPrefix(e.Name(), prefix) && strings.HasSuffix(e.Name(), ".md") {
+			if raw, err := os.ReadFile(filepath.Join(epicDir, e.Name())); err == nil {
+				return string(raw)
+			}
+		}
+	}
+	return "(no detail available)"
+}
+
+func copyReleaseEpics(in map[string][]string) map[string][]string {
+	out := make(map[string][]string, len(in))
+	for release, epics := range in {
+		out[release] = append([]string(nil), epics...)
+	}
+	return out
+}
+
 func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	switch msg.String() {
 	case "esc", "q":
 		m.Overlay = OverlayNone
 	case "up", "k":
+		if m.Overlay == OverlayDetail && m.DetailOffset > 0 {
+			m.DetailOffset--
+		}
+		if m.Overlay == OverlayEpicDetail && m.EpicDetailOffset > 0 {
+			m.EpicDetailOffset--
+		}
 		if m.Overlay == OverlayEpic && m.EpicCursor > 0 {
 			m.EpicCursor--
 		}
@@ -125,6 +289,12 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.ReleaseCursor--
 		}
 	case "down", "j":
+		if m.Overlay == OverlayDetail {
+			m.DetailOffset++
+		}
+		if m.Overlay == OverlayEpicDetail {
+			m.EpicDetailOffset++
+		}
 		if m.Overlay == OverlayEpic && len(m.Epics) > 0 && m.EpicCursor < len(m.Epics)-1 {
 			m.EpicCursor++
 		}
@@ -135,7 +305,9 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		if m.Overlay == OverlayEpic && len(m.Epics) > 0 {
 			m.SelectedEpic = m.Epics[m.EpicCursor]
 			m.FocusedTask = 0
+			m.DetailOffset = 0
 			m.refreshTasks()
+			m.ensureFocusedTaskVisible()
 			m.Overlay = OverlayNone
 			if m.Root != "" {
 				if err := m.writeRouterReleaseEpic(); err != nil {
@@ -147,7 +319,9 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.SelectedRelease = m.Releases[m.ReleaseCursor]
 			m.refreshEpicsForRelease()
 			m.FocusedTask = 0
+			m.DetailOffset = 0
 			m.refreshTasks()
+			m.ensureFocusedTaskVisible()
 			m.Overlay = OverlayNone
 			if m.Root != "" {
 				if err := m.writeRouterReleaseEpic(); err != nil {
@@ -155,10 +329,104 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 				}
 			}
 		}
+	case "pgup":
+		if m.Overlay == OverlayDetail {
+			m.DetailOffset -= m.detailPageSize()
+			if m.DetailOffset < 0 {
+				m.DetailOffset = 0
+			}
+		}
+		if m.Overlay == OverlayEpicDetail {
+			m.EpicDetailOffset -= m.detailPageSize()
+			if m.EpicDetailOffset < 0 {
+				m.EpicDetailOffset = 0
+			}
+		}
+	case "pgdown":
+		if m.Overlay == OverlayDetail {
+			m.DetailOffset += m.detailPageSize()
+		}
+		if m.Overlay == OverlayEpicDetail {
+			m.EpicDetailOffset += m.detailPageSize()
+		}
 	}
 	return m, nil
 }
 
+func (m *Model) ensureFocusedTaskVisible() {
+	if m.ColumnOffsets == nil {
+		m.ColumnOffsets = newColumnOffsets()
+	}
+	tasks := m.Tasks[m.FocusedColumn]
+	if len(tasks) == 0 {
+		m.ColumnOffsets[m.FocusedColumn] = 0
+		return
+	}
+	pageSize := m.columnPageSize()
+	offset := m.ColumnOffsets[m.FocusedColumn]
+	if m.FocusedTask < offset {
+		offset = m.FocusedTask
+	}
+	if m.FocusedTask >= offset+pageSize {
+		offset = m.FocusedTask - pageSize + 1
+	}
+	maxOffset := max(len(tasks)-pageSize, 0)
+	if offset > maxOffset {
+		offset = maxOffset
+	}
+	if offset < 0 {
+		offset = 0
+	}
+	m.ColumnOffsets[m.FocusedColumn] = offset
+}
+
+func (m *Model) scrollFocusedColumn(delta int) {
+	if m.ColumnOffsets == nil {
+		m.ColumnOffsets = newColumnOffsets()
+	}
+	tasks := m.Tasks[m.FocusedColumn]
+	if len(tasks) == 0 {
+		m.ColumnOffsets[m.FocusedColumn] = 0
+		m.FocusedTask = 0
+		return
+	}
+	pageSize := m.columnPageSize()
+	maxOffset := max(len(tasks)-pageSize, 0)
+	offset := m.ColumnOffsets[m.FocusedColumn] + delta
+	if offset < 0 {
+		offset = 0
+	}
+	if offset > maxOffset {
+		offset = maxOffset
+	}
+	m.ColumnOffsets[m.FocusedColumn] = offset
+	m.FocusedTask = min(offset, len(tasks)-1)
+}
+
+func (m Model) columnPageSize() int {
+	h := m.Height
+	if h == 0 {
+		h = defaultTermH
+	}
+	return visibleColumnTaskLimit(CalculateLayout(m.Width, h).ContentHeight)
+}
+
+func (m Model) detailPageSize() int {
+	return max(detailMaxHeight(m.Height)-3, 1)
+}
+
+func (m Model) epicPanelPageSize() int {
+	h := m.Height
+	if h == 0 {
+		h = defaultTermH
+	}
+	return max(h/2, 1)
+}
+
+func (m Model) epicPanelAvailable() bool {
+	return len(m.Epics) > 0 && CalculateLayout(m.Width, m.Height).EpicPanelVisible
+}
+
 func prevColumn(col data.ColumnType) data.ColumnType {
 	for i, c := range columnOrder {
 		if c == col {