savepoint 1.0.0

package/internal/board/transitions.go

@@ -0,0 +1,88 @@
+package board
+
+import (
+	"fmt"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+// Advance moves a task forward through the phase lifecycle.
+func Advance(t *data.Task) {
+	switch t.Column {
+	case data.ColumnPlanned:
+		t.Column = data.ColumnInProgress
+		t.Stage = data.StageBuild
+	case data.ColumnInProgress:
+		switch t.Stage {
+		case data.StageBuild:
+			t.Stage = data.StageTest
+		case data.StageTest:
+			t.Stage = data.StageAudit
+		case data.StageAudit:
+			t.Column = data.ColumnDone
+			t.Stage = ""
+		}
+	}
+}
+
+// Retreat moves a task backward through the phase lifecycle.
+func Retreat(t *data.Task) {
+	switch t.Column {
+	case data.ColumnDone:
+		t.Column = data.ColumnInProgress
+		t.Stage = data.StageAudit
+	case data.ColumnInProgress:
+		switch t.Stage {
+		case data.StageAudit:
+			t.Stage = data.StageTest
+		case data.StageTest:
+			t.Stage = data.StageBuild
+		case data.StageBuild:
+			t.Column = data.ColumnPlanned
+			t.Stage = ""
+		}
+	}
+}
+
+// CanAdvance checks whether a task is allowed to advance to its next phase.
+// It validates phase adjacency and dependency completion.
+// Returns (true, "") if allowed, or (false, reason) if blocked.
+func CanAdvance(t *data.Task, allTasks []data.Task) (bool, string) {
+	switch t.Column {
+	case data.ColumnPlanned:
+		return true, ""
+	case data.ColumnInProgress:
+		switch t.Stage {
+		case data.StageBuild:
+			return true, ""
+		case data.StageTest:
+			return true, ""
+		case data.StageAudit:
+			for _, depID := range t.DependsOn {
+				dep := findTask(depID, allTasks)
+				if dep == nil {
+					return false, fmt.Sprintf("dependency %q not found", depID)
+				}
+				if dep.Column != data.ColumnDone {
+					return false, fmt.Sprintf("dependency %q is not done", depID)
+				}
+			}
+			return true, ""
+		default:
+			return false, fmt.Sprintf("unknown stage %q", t.Stage)
+		}
+	case data.ColumnDone:
+		return false, "task is already done"
+	default:
+		return false, fmt.Sprintf("unknown column %q", t.Column)
+	}
+}
+
+func findTask(id string, tasks []data.Task) *data.Task {
+	for i := range tasks {
+		if tasks[i].ID == id {
+			return &tasks[i]
+		}
+	}
+	return nil
+}

package/internal/board/transitions_test.go

@@ -0,0 +1,141 @@
+package board
+
+import (
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestAdvance(t *testing.T) {
+	tests := []struct {
+		name       string
+		initialCol data.ColumnType
+		initialSt  data.ProgressStage
+		expectCol  data.ColumnType
+		expectSt   data.ProgressStage
+	}{
+		{"planned to in_progress/build", data.ColumnPlanned, "", data.ColumnInProgress, data.StageBuild},
+		{"in_progress/build to test", data.ColumnInProgress, data.StageBuild, data.ColumnInProgress, data.StageTest},
+		{"in_progress/test to audit", data.ColumnInProgress, data.StageTest, data.ColumnInProgress, data.StageAudit},
+		{"in_progress/audit to done", data.ColumnInProgress, data.StageAudit, data.ColumnDone, ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := data.Task{Column: tt.initialCol, Stage: tt.initialSt}
+			Advance(&task)
+			if task.Column != tt.expectCol || task.Stage != tt.expectSt {
+				t.Errorf("Advance() = %v/%v, want %v/%v", task.Column, task.Stage, tt.expectCol, tt.expectSt)
+			}
+		})
+	}
+}
+
+func TestRetreat(t *testing.T) {
+	tests := []struct {
+		name       string
+		initialCol data.ColumnType
+		initialSt  data.ProgressStage
+		expectCol  data.ColumnType
+		expectSt   data.ProgressStage
+	}{
+		{"done to in_progress/audit", data.ColumnDone, "", data.ColumnInProgress, data.StageAudit},
+		{"in_progress/audit to test", data.ColumnInProgress, data.StageAudit, data.ColumnInProgress, data.StageTest},
+		{"in_progress/test to build", data.ColumnInProgress, data.StageTest, data.ColumnInProgress, data.StageBuild},
+		{"in_progress/build to planned", data.ColumnInProgress, data.StageBuild, data.ColumnPlanned, ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := data.Task{Column: tt.initialCol, Stage: tt.initialSt}
+			Retreat(&task)
+			if task.Column != tt.expectCol || task.Stage != tt.expectSt {
+				t.Errorf("Retreat() = %v/%v, want %v/%v", task.Column, task.Stage, tt.expectCol, tt.expectSt)
+			}
+		})
+	}
+}
+
+func TestCanAdvance_plannedAlwaysAllowed(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnPlanned}
+	ok, reason := CanAdvance(&task, nil)
+	if !ok {
+		t.Errorf("CanAdvance(planned) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_buildAlwaysAllowed(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageBuild}
+	ok, reason := CanAdvance(&task, nil)
+	if !ok {
+		t.Errorf("CanAdvance(build) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_testAlwaysAllowed(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageTest}
+	ok, reason := CanAdvance(&task, nil)
+	if !ok {
+		t.Errorf("CanAdvance(test) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_auditDoneBlockedByDependency(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
+		{ID: "T2", Column: data.ColumnInProgress, Stage: data.StageBuild},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if ok {
+		t.Fatal("CanAdvance(audit with undep) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}
+
+func TestCanAdvance_auditDoneAllowedWhenDepsDone(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
+		{ID: "T2", Column: data.ColumnDone},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if !ok {
+		t.Errorf("CanAdvance(audit with dep done) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_doneBlocked(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnDone}
+	ok, reason := CanAdvance(&task, nil)
+	if ok {
+		t.Fatal("CanAdvance(done) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}
+
+func TestCanAdvance_unknownStageBlocked(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: "invalid"}
+	ok, reason := CanAdvance(&task, nil)
+	if ok {
+		t.Fatal("CanAdvance(unknown stage) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}
+
+func TestCanAdvance_auditDepsNotFoundBlocked(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if ok {
+		t.Fatal("CanAdvance(audit missing dep) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}

package/internal/board/update.go

@@ -0,0 +1,155 @@
+package board
+
+import (
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+var columnOrder = []data.ColumnType{
+	data.ColumnPlanned,
+	data.ColumnInProgress,
+	data.ColumnDone,
+}
+
+func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if m.Overlay != OverlayNone {
+			return m.updateOverlay(msg)
+		}
+		switch msg.String() {
+		case "q", "ctrl+c":
+			return m, tea.Quit
+		case "left", "h":
+			m.FocusedColumn = prevColumn(m.FocusedColumn)
+			m.FocusedTask = 0
+			m.StatusMessage = ""
+		case "right", "l":
+			m.FocusedColumn = nextColumn(m.FocusedColumn)
+			m.FocusedTask = 0
+			m.StatusMessage = ""
+		case "up", "k":
+			if m.FocusedTask > 0 {
+				m.FocusedTask--
+			}
+			m.StatusMessage = ""
+		case "down", "j":
+			if m.FocusedTask < len(m.Tasks[m.FocusedColumn])-1 {
+				m.FocusedTask++
+			}
+			m.StatusMessage = ""
+		case "enter":
+			tasks := m.Tasks[m.FocusedColumn]
+			if len(tasks) > 0 && m.FocusedTask < len(tasks) {
+				m.Overlay = OverlayDetail
+			}
+			m.StatusMessage = ""
+		case " ":
+			tasks := m.Tasks[m.FocusedColumn]
+			if len(tasks) > 0 && m.FocusedTask < len(tasks) {
+				task := tasks[m.FocusedTask]
+				if ok, reason := CanAdvance(&task, m.AllTasks); !ok {
+					m.StatusMessage = reason
+				} else {
+					m.StatusMessage = ""
+					for i, t := range m.AllTasks {
+						if t.ID == task.ID {
+							Advance(&m.AllTasks[i])
+							break
+						}
+					}
+					m.refreshTasks()
+				}
+			}
+		case "backspace":
+			tasks := m.Tasks[m.FocusedColumn]
+			if len(tasks) > 0 && m.FocusedTask < len(tasks) {
+				task := tasks[m.FocusedTask]
+				for i, t := range m.AllTasks {
+					if t.ID == task.ID {
+						Retreat(&m.AllTasks[i])
+						break
+					}
+				}
+				m.refreshTasks()
+			}
+			m.StatusMessage = ""
+		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
+	}
+	return m, nil
+}
+
+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 == OverlayEpic && m.EpicCursor > 0 {
+			m.EpicCursor--
+		}
+		if m.Overlay == OverlayRelease && m.ReleaseCursor > 0 {
+			m.ReleaseCursor--
+		}
+	case "down", "j":
+		if m.Overlay == OverlayEpic && len(m.Epics) > 0 && m.EpicCursor < len(m.Epics)-1 {
+			m.EpicCursor++
+		}
+		if m.Overlay == OverlayRelease && len(m.Releases) > 0 && m.ReleaseCursor < len(m.Releases)-1 {
+			m.ReleaseCursor++
+		}
+	case "enter":
+		if m.Overlay == OverlayEpic && len(m.Epics) > 0 {
+			m.SelectedEpic = m.Epics[m.EpicCursor]
+			m.FocusedTask = 0
+			m.refreshTasks()
+			m.Overlay = OverlayNone
+			if m.Root != "" {
+				if err := m.writeRouterReleaseEpic(); err != nil {
+					m.StatusMessage = err.Error()
+				}
+			}
+		}
+		if m.Overlay == OverlayRelease && len(m.Releases) > 0 {
+			m.SelectedRelease = m.Releases[m.ReleaseCursor]
+			m.refreshEpicsForRelease()
+			m.FocusedTask = 0
+			m.refreshTasks()
+			m.Overlay = OverlayNone
+			if m.Root != "" {
+				if err := m.writeRouterReleaseEpic(); err != nil {
+					m.StatusMessage = err.Error()
+				}
+			}
+		}
+	}
+	return m, nil
+}
+
+func prevColumn(col data.ColumnType) data.ColumnType {
+	for i, c := range columnOrder {
+		if c == col {
+			return columnOrder[(i+len(columnOrder)-1)%len(columnOrder)]
+		}
+	}
+	return columnOrder[0]
+}
+
+func nextColumn(col data.ColumnType) data.ColumnType {
+	for i, c := range columnOrder {
+		if c == col {
+			return columnOrder[(i+1)%len(columnOrder)]
+		}
+	}
+	return columnOrder[0]
+}

package/internal/board/update_test.go

@@ -0,0 +1,128 @@
+package board
+
+import (
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func requireModel(t *testing.T, got tea.Model) Model {
+	t.Helper()
+	m, ok := got.(Model)
+	if !ok {
+		t.Fatalf("updated model type = %T, want board.Model", got)
+	}
+	return m
+}
+
+func TestUpdate_qQuits(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	_, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("q")})
+	if cmd == nil {
+		t.Fatal("expected tea.Quit cmd, got nil")
+	}
+}
+
+func TestUpdate_ctrlCQuits(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	_, cmd := m.Update(tea.KeyMsg{Type: tea.KeyCtrlC})
+	if cmd == nil {
+		t.Fatal("expected tea.Quit cmd, got nil")
+	}
+}
+
+func TestUpdate_windowSizeUpdatesModel(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	got, cmd := m.Update(tea.WindowSizeMsg{Width: 120, Height: 40})
+	updated := requireModel(t, got)
+	if cmd != nil {
+		t.Errorf("expected nil cmd for window resize, got %v", cmd)
+	}
+	if updated.Width != 120 {
+		t.Errorf("Width = %d, want 120", updated.Width)
+	}
+	if updated.Height != 40 {
+		t.Errorf("Height = %d, want 40", updated.Height)
+	}
+}
+
+func TestUpdate_rightMovesColumn(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	// FocusedColumn starts at Planned
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("l")})
+	updated := requireModel(t, got)
+	if updated.FocusedColumn != data.ColumnInProgress {
+		t.Errorf("FocusedColumn = %q, want %q", updated.FocusedColumn, data.ColumnInProgress)
+	}
+}
+
+func TestUpdate_leftWrapsAround(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	// Planned -> left -> Done (wrap)
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("h")})
+	updated := requireModel(t, got)
+	if updated.FocusedColumn != data.ColumnDone {
+		t.Errorf("FocusedColumn = %q, want %q", updated.FocusedColumn, data.ColumnDone)
+	}
+}
+
+func TestUpdate_rightWrapsAround(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.FocusedColumn = data.ColumnDone
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("l")})
+	updated := requireModel(t, got)
+	if updated.FocusedColumn != data.ColumnPlanned {
+		t.Errorf("FocusedColumn = %q, want %q", updated.FocusedColumn, data.ColumnPlanned)
+	}
+}
+
+func TestUpdate_downMovesTaskFocus(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned},
+		{ID: "T2", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("j")})
+	updated := requireModel(t, got)
+	if updated.FocusedTask != 1 {
+		t.Errorf("FocusedTask = %d, want 1", updated.FocusedTask)
+	}
+}
+
+func TestUpdate_upMovesTaskFocus(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned},
+		{ID: "T2", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+	m.FocusedTask = 1
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("k")})
+	updated := requireModel(t, got)
+	if updated.FocusedTask != 0 {
+		t.Errorf("FocusedTask = %d, want 0", updated.FocusedTask)
+	}
+}
+
+func TestUpdate_taskFocusClampedAtEnd(t *testing.T) {
+	tasks := []data.Task{{ID: "T1", Column: data.ColumnPlanned}}
+	m := NewModel(tasks, "v1", "E03")
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyDown})
+	updated := requireModel(t, got)
+	if updated.FocusedTask != 0 {
+		t.Errorf("FocusedTask = %d, want 0", updated.FocusedTask)
+	}
+}
+
+func TestUpdate_unknownMsgNoOp(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 80
+	got, cmd := m.Update(nil)
+	updated := requireModel(t, got)
+	if cmd != nil {
+		t.Errorf("expected nil cmd, got %v", cmd)
+	}
+	if updated.Width != 80 {
+		t.Errorf("Width changed unexpectedly: %d", updated.Width)
+	}
+}

package/internal/board/view.go

@@ -0,0 +1,190 @@
+package board
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+	xansi "github.com/charmbracelet/x/ansi"
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/styles"
+)
+
+const defaultTermH = 24
+
+const defaultTermW = 80
+
+func (m Model) View() string {
+	w := m.Width
+	if w == 0 {
+		w = defaultTermW
+	}
+
+	layout := CalculateLayout(w, m.Height)
+	icon := styles.HeaderIcon.Render("▣")
+	text := styles.HeaderText.Render("S A V E P O I N T")
+	header := styles.HeaderFrame.Width(w).Render(icon + "  " + text)
+	board := m.renderBoard(layout)
+	footer := m.renderFooter(w)
+	base := lipgloss.JoinVertical(lipgloss.Left, header, board, footer)
+
+	h := m.Height
+	if h == 0 {
+		h = defaultTermH
+	}
+
+	if m.Overlay == OverlayEpic {
+		overlay := RenderEpicDropdown(m.Epics, m.EpicCursor, min(40, w))
+		return overlayOnBase(dimLines(base), overlay, w, h)
+	}
+
+	if m.Overlay == OverlayRelease {
+		overlay := RenderReleaseDropdown(m.Releases, m.ReleaseCursor, min(40, w))
+		return overlayOnBase(dimLines(base), overlay, w, h)
+	}
+
+	if m.Overlay == OverlayHelp {
+		help := RenderHelp(overlayWidth(w))
+		return overlayOnBase(dimLines(base), help, w, h)
+	}
+
+	if m.Overlay == OverlayDetail {
+		task, ok := m.focusedTask()
+		if !ok {
+			return base
+		}
+		ow := overlayWidth(w)
+		detail := RenderDetail(task, ow)
+		return overlayOnBase(dimLines(base), detail, w, h)
+	}
+
+	return base
+}
+
+func (m Model) focusedTask() (data.Task, bool) {
+	tasks := m.Tasks[m.FocusedColumn]
+	if len(tasks) == 0 || m.FocusedTask >= len(tasks) {
+		return data.Task{}, false
+	}
+	return tasks[m.FocusedTask], true
+}
+
+func overlayWidth(termW int) int {
+	ow := termW - 4
+	if ow > 80 {
+		ow = 80
+	}
+	if ow < 20 {
+		ow = 20
+	}
+	return ow
+}
+
+// dimLines applies faint ANSI styling to each line individually.
+func dimLines(s string) string {
+	dim := lipgloss.NewStyle().Faint(true)
+	lines := strings.Split(s, "\n")
+	for i, l := range lines {
+		lines[i] = dim.Render(l)
+	}
+	return strings.Join(lines, "\n")
+}
+
+// overlayOnBase places overlay centered on base, preserving base lines outside
+// the overlay area and replacing the left portion of intersecting lines.
+func overlayOnBase(base, overlay string, termW, termH int) string {
+	baseLines := strings.Split(base, "\n")
+	overlayLines := strings.Split(overlay, "\n")
+
+	overlayH := len(overlayLines)
+	overlayW := 0
+	for _, l := range overlayLines {
+		if lw := lipgloss.Width(l); lw > overlayW {
+			overlayW = lw
+		}
+	}
+
+	startY := (termH - overlayH) / 2
+	if startY < 0 {
+		startY = 0
+	}
+	startX := (termW - overlayW) / 2
+	if startX < 0 {
+		startX = 0
+	}
+
+	for len(baseLines) < termH {
+		baseLines = append(baseLines, "")
+	}
+
+	result := make([]string, len(baseLines))
+	for i, line := range baseLines {
+		oi := i - startY
+		if oi >= 0 && oi < overlayH {
+			left := xansi.Truncate(line, startX, "")
+			leftW := lipgloss.Width(left)
+			if leftW < startX {
+				left += strings.Repeat(" ", startX-leftW)
+			}
+			result[i] = left + overlayLines[oi]
+		} else {
+			result[i] = line
+		}
+	}
+	return strings.Join(result, "\n")
+}
+
+func (m Model) renderBoard(layout Layout) string {
+	cols := m.renderColumns(layout)
+	var content string
+	if layout.EpicPanelVisible {
+		epic := m.renderEpicPanel(layout.EpicPanelWidth)
+		content = lipgloss.JoinHorizontal(lipgloss.Top, epic, cols)
+	} else {
+		content = cols
+	}
+	return styles.BoardFrame.Width(m.Width).Render(content)
+}
+
+func (m Model) renderColumns(layout Layout) string {
+	if layout.ColCount == 1 {
+		return m.renderColumn(m.FocusedColumn, layout.ColWidths[0])
+	}
+	allCols := []data.ColumnType{data.ColumnPlanned, data.ColumnInProgress, data.ColumnDone}
+	rendered := make([]string, len(allCols))
+	for i, col := range allCols {
+		rendered[i] = m.renderColumn(col, layout.ColWidths[i])
+	}
+	return lipgloss.JoinHorizontal(lipgloss.Top, rendered...)
+}
+
+func (m Model) renderEpicPanel(w int) string {
+	return RenderEpicSidebar(m.Epics, m.SelectedEpic, w)
+}
+
+func (m Model) renderColumn(col data.ColumnType, colW int) string {
+	focused := m.FocusedColumn == col
+	return RenderColumn(m.Tasks[col], col, colW, m.FocusedTask, focused)
+}
+
+func (m Model) renderFooter(termW int) string {
+	phase := footerLine(termW,
+		styles.FooterPhasePlan.Render("PLAN")+
+			styles.FooterDivider.Render(" │ ")+
+			styles.FooterPhaseBuild.Render("BUILD")+
+			styles.FooterDivider.Render(" │ ")+
+			styles.FooterPhaseAudit.Render("AUDIT"),
+	)
+	hints := footerLine(termW, styles.FooterHints.Render("←/→:nav  E:epic  R:release  ?:help  q:quit"))
+	spacer := footerLine(termW, "")
+	return lipgloss.JoinVertical(lipgloss.Center, phase, spacer, hints)
+}
+
+func footerLine(termW int, content string) string {
+	if termW <= 0 {
+		termW = defaultTermW
+	}
+	if lipgloss.Width(content) > termW {
+		content = xansi.Truncate(content, termW, "")
+	}
+	return lipgloss.NewStyle().Width(termW).Align(lipgloss.Center).Render(content)
+}