savepoint 1.0.1 → 1.0.3

package/internal/board/view.go

@@ -1,6 +1,7 @@
 package board
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
@@ -19,21 +20,34 @@ func (m Model) View() string {
 		w = defaultTermW
 	}
 	m.Width = w
+	h := m.Height
+	if h == 0 {
+		h = defaultTermH
+	}
+	m.Height = h
 
-	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)
+	header := m.renderHeader(w)
+	nextActivity := m.renderNextActivityLine(w)
+	extra := extraHeaderLines(nextActivity)
+	layout := CalculateLayoutWithChrome(w, h, extra)
 	topDivider := dividerLine(w)
 	board := m.renderBoard(layout)
+	boardBudget := h - 8 - extra
+	if boardBudget < 0 {
+		boardBudget = 0
+	}
+	boardLines := strings.Split(board, "\n")
+	if len(boardLines) > boardBudget {
+		board = strings.Join(boardLines[:boardBudget], "\n")
+	}
 	bottomDivider := dividerLine(w)
 	footer := m.renderFooter(w)
-	base := lipgloss.JoinVertical(lipgloss.Left, header, topDivider, board, bottomDivider, footer)
-
-	h := m.Height
-	if h == 0 {
-		h = defaultTermH
+	sections := []string{header}
+	if nextActivity != "" {
+		sections = append(sections, nextActivity)
 	}
+	sections = append(sections, topDivider, board, bottomDivider, footer)
+	base := lipgloss.JoinVertical(lipgloss.Left, sections...)
 
 	if m.Overlay == OverlayEpic {
 		overlay := RenderEpicDropdown(m.Epics, m.EpicCursor, min(40, w))
@@ -56,13 +70,101 @@ func (m Model) View() string {
 			return base
 		}
 		ow := overlayWidth(w)
-		detail := RenderDetail(task, ow, m.RouterTask)
+		detail := RenderDetail(task, ow, m.RouterState, detailMaxHeight(h), m.DetailOffset)
+		return overlayOnBase(dimLines(base), detail, w, h)
+	}
+
+	if m.Overlay == OverlayEpicDetail {
+		ow := overlayWidth(w)
+		epicSlug := m.epicDetailEpic()
+		var detail string
+		if m.EpicDetailTab == 1 {
+			detail = RenderEpicAuditTab(epicSlug, m.EpicAuditContent, ow, detailMaxHeight(h), m.EpicDetailOffset, m.EpicDetailTab)
+		} else {
+			detail = RenderEpicDetail(epicSlug, m.EpicDetailContent, ow, detailMaxHeight(h), m.EpicDetailOffset, m.EpicDetailTab)
+		}
 		return overlayOnBase(dimLines(base), detail, w, h)
 	}
 
 	return base
 }
 
+func (m Model) renderHeader(w int) string {
+	icon := styles.HeaderIcon.Render("▣")
+	text := styles.HeaderText.Render("S A V E P O I N T")
+	left := icon + "  " + text
+	return styles.HeaderFrame.Width(w).Render(left)
+}
+
+func extraHeaderLines(line string) int {
+	if line == "" {
+		return 0
+	}
+	return 1
+}
+
+func (m Model) renderNextActivityLine(w int) string {
+	if w <= 0 {
+		w = defaultTermW
+	}
+	return renderNextActivityLine(m.RouterState, w)
+}
+
+func renderNextActivityLine(state *data.RouterState, w int) string {
+	tag, style, ok := nextActivityPhase(state)
+	if !ok || strings.TrimSpace(state.NextAction) == "" {
+		return ""
+	}
+
+	content := style.Render(tag+":") + " " + state.NextAction
+	if lipgloss.Width(content) > w {
+		content = xansi.Truncate(content, w, "…")
+	}
+	return styles.RootLine.Width(w).Render(content)
+}
+
+func nextActivityPhase(state *data.RouterState) (string, lipgloss.Style, bool) {
+	if state == nil {
+		return "", lipgloss.Style{}, false
+	}
+	switch state.State {
+	case "task-building":
+		return "BUILD", styles.FooterPhaseBuild, true
+	case "audit-pending":
+		return "AUDIT", styles.FooterPhaseAudit, true
+	case "pre-implementation", "epic-design", "epic-task-breakdown":
+		return "PLAN", styles.FooterPhasePlan, true
+	default:
+		return "", lipgloss.Style{}, false
+	}
+}
+
+// FormatNextActivity formats a compact activity string from router state.
+// Returns empty string when state is nil. Result is capped at 20 visible chars.
+func FormatNextActivity(state *data.RouterState) string {
+	if state == nil {
+		return ""
+	}
+	var s string
+	switch state.State {
+	case "task-building":
+		s = fmt.Sprintf("Build %s %s/%s", state.Release, shortID(state.Epic), shortID(state.Task))
+	case "audit-pending":
+		s = fmt.Sprintf("Audit %s", shortID(state.Epic))
+	case "epic-design":
+		s = fmt.Sprintf("Design %s", shortID(state.Epic))
+	case "epic-task-breakdown":
+		s = fmt.Sprintf("Plan %s", shortID(state.Epic))
+	case "pre-implementation":
+		s = fmt.Sprintf("Planning %s", state.Release)
+	default:
+		s = state.State
+	}
+	return xansi.Truncate(s, 20, "…")
+}
+
+
+
 func (m Model) focusedTask() (data.Task, bool) {
 	tasks := m.Tasks[m.FocusedColumn]
 	if len(tasks) == 0 || m.FocusedTask >= len(tasks) {
@@ -140,7 +242,7 @@ func (m Model) renderBoard(layout Layout) string {
 	cols := m.renderColumns(layout)
 	var content string
 	if layout.EpicPanelVisible {
-		epic := m.renderEpicPanel(layout.EpicPanelWidth)
+		epic := m.renderEpicPanel(layout.EpicPanelWidth, layout.ContentHeight)
 		content = lipgloss.JoinHorizontal(lipgloss.Top, epic, cols)
 	} else {
 		content = cols
@@ -150,23 +252,34 @@ func (m Model) renderBoard(layout Layout) string {
 
 func (m Model) renderColumns(layout Layout) string {
 	if layout.ColCount == 1 {
-		return m.renderColumn(m.FocusedColumn, layout.ColWidths[0])
+		return m.renderColumn(m.FocusedColumn, layout.ColWidths[0], layout.ContentHeight)
 	}
 	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])
+		rendered[i] = m.renderColumn(col, layout.ColWidths[i], layout.ContentHeight)
 	}
 	return lipgloss.JoinHorizontal(lipgloss.Top, rendered...)
 }
 
-func (m Model) renderEpicPanel(w int) string {
-	return RenderEpicSidebar(m.Epics, m.SelectedEpic, w)
+func (m Model) renderEpicPanel(w int, maxHeight int) string {
+	return RenderEpicSidebar(m.Epics, m.SelectedEpic, w, m.EpicPanelFocus, m.EpicPanelCursor, m.EpicStatus, maxHeight)
+}
+
+func (m Model) renderColumn(col data.ColumnType, colW, maxHeight int) string {
+	focused := !m.EpicPanelFocus && m.FocusedColumn == col
+	return RenderColumn(m.Tasks[col], col, colW, maxHeight, m.ColumnOffsets[col], m.FocusedTask, focused, m.RouterState)
 }
 
-func (m Model) renderColumn(col data.ColumnType, colW int) string {
-	focused := m.FocusedColumn == col
-	return RenderColumn(m.Tasks[col], col, colW, m.FocusedTask, focused, m.RouterTask)
+func detailMaxHeight(termH int) int {
+	if termH <= 0 {
+		termH = defaultTermH
+	}
+	h := termH * 7 / 10
+	if h < 6 {
+		h = 6
+	}
+	return h
 }
 
 func (m Model) renderFooter(termW int) string {
@@ -177,9 +290,13 @@ func (m Model) renderFooter(termW int) string {
 			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)
+	hints := footerLine(termW, styles.FooterHints.Render("←/→:nav  p: Priority  R:release  ?:help  q:quit"))
+	status := ""
+	if m.StatusMessage != "" {
+		status = styles.StatusBar.Render(m.StatusMessage)
+	}
+	statusLine := footerLine(termW, status)
+	return lipgloss.JoinVertical(lipgloss.Center, phase, statusLine, hints)
 }
 
 func dividerLine(termW int) string {
@@ -196,5 +313,5 @@ func footerLine(termW int, content string) string {
 	if lipgloss.Width(content) > termW {
 		content = xansi.Truncate(content, termW, "")
 	}
-	return lipgloss.NewStyle().Width(termW).Align(lipgloss.Center).Render(content)
+	return styles.RootLine.Width(termW).Align(lipgloss.Center).Render(content)
 }

package/internal/board/view_test.go

@@ -66,7 +66,7 @@ func TestView_containsFooterHints(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	footer := m.renderFooter(80)
 
-	if !strings.Contains(footer, "←/→:nav  E:epic  R:release  ?:help  q:quit") {
+	if !strings.Contains(footer, "←/→:nav  p: Priority  R:release  ?:help  q:quit") {
 		t.Fatal("renderFooter() missing navigation hints")
 	}
 
@@ -74,8 +74,8 @@ func TestView_containsFooterHints(t *testing.T) {
 	if len(lines) != 3 {
 		t.Fatalf("renderFooter() returned %d lines, want 3", len(lines))
 	}
-	if strings.TrimSpace(lines[1]) != "" {
-		t.Fatalf("renderFooter() spacer line = %q, want blank", lines[1])
+	if strings.TrimSpace(plainTerminal(lines[1])) != "" {
+		t.Fatalf("renderFooter() status line = %q, want blank", lines[1])
 	}
 	for i, line := range lines {
 		if got := lipgloss.Width(line); got > 80 {
@@ -84,6 +84,16 @@ func TestView_containsFooterHints(t *testing.T) {
 	}
 }
 
+func TestView_footerRendersStatusMessage(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.StatusMessage = "Router set to v1.1 E05-tasking-permissions/T004"
+	footer := plainTerminal(m.renderFooter(80))
+
+	if !strings.Contains(footer, "Router set to v1.1 E05-tasking-permissions/T004") {
+		t.Fatal("renderFooter() missing status message")
+	}
+}
+
 func TestView_containsBottomDivider(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	m.Width = 120
@@ -133,6 +143,164 @@ func TestView_wideShowsEpicPanel(t *testing.T) {
 	}
 }
 
+func TestFormatNextActivity_nil(t *testing.T) {
+	if got := FormatNextActivity(nil); got != "" {
+		t.Errorf("FormatNextActivity(nil) = %q, want empty", got)
+	}
+}
+
+func TestFormatNextActivity_states(t *testing.T) {
+	cases := []struct {
+		state *data.RouterState
+		want  string
+	}{
+		{&data.RouterState{State: "task-building", Task: "T010", Epic: "E06", Release: "v1"}, "Build v1 E06/T010"},
+		{&data.RouterState{State: "audit-pending", Epic: "E06"}, "Audit E06"},
+		{&data.RouterState{State: "epic-design", Epic: "E06"}, "Design E06"},
+		{&data.RouterState{State: "epic-task-breakdown", Epic: "E06"}, "Plan E06"},
+		{&data.RouterState{State: "pre-implementation", Release: "v1"}, "Planning v1"},
+	}
+	for _, c := range cases {
+		got := FormatNextActivity(c.state)
+		if got != c.want {
+			t.Errorf("FormatNextActivity(%q) = %q, want %q", c.state.State, got, c.want)
+		}
+	}
+}
+
+func TestFormatNextActivity_truncation(t *testing.T) {
+	state := &data.RouterState{State: "task-building", Task: "T001", Epic: "E01-very-long-epic-name", Release: "v1.1"}
+	got := FormatNextActivity(state)
+	if lipgloss.Width(got) > 20 {
+		t.Errorf("FormatNextActivity truncation: width %d > 20, got %q", lipgloss.Width(got), got)
+	}
+}
+
+func TestFormatNextActivity_taskBuildingKeepsMinorReleaseVisible(t *testing.T) {
+	state := &data.RouterState{State: "task-building", Task: "T001", Epic: "E03", Release: "v1.1"}
+	got := FormatNextActivity(state)
+	if got != "Build v1.1 E03/T001" {
+		t.Errorf("FormatNextActivity() = %q, want Build v1.1 E03/T001", got)
+	}
+}
+
+func TestView_headerShowsNextActivity(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.RouterState = &data.RouterState{State: "audit-pending", NextAction: "Audit E06"}
+	got := m.View()
+	if !strings.Contains(got, "AUDIT:") {
+		t.Error("View() missing Next Activity phase tag")
+	}
+	if !strings.Contains(got, "Audit E06") {
+		t.Error("View() missing activity text below header")
+	}
+	if strings.Contains(got, "Next Activity:") {
+		t.Error("View() should not render Next Activity inside the header")
+	}
+}
+
+func TestView_nextActivityLineImmediatelyBelowHeader(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.RouterState = &data.RouterState{State: "task-building", NextAction: "Build T010 (E06) v1"}
+	got := m.View()
+
+	lines := strings.Split(got, "\n")
+	headerIndex := -1
+	activityIndex := -1
+	dividerIndex := -1
+	for i, line := range lines {
+		if strings.Contains(line, "S A V E P O I N T") {
+			headerIndex = i
+		}
+		if strings.Contains(line, "BUILD:") && strings.Contains(line, "Build T010 (E06) v1") {
+			activityIndex = i
+		}
+		if dividerIndex == -1 && strings.Contains(line, strings.Repeat("─", 120)) {
+			dividerIndex = i
+		}
+	}
+	if headerIndex == -1 || activityIndex == -1 || dividerIndex == -1 {
+		t.Fatalf("View() missing expected header/activity/divider lines: header=%d activity=%d divider=%d", headerIndex, activityIndex, dividerIndex)
+	}
+	if !(headerIndex < activityIndex && activityIndex < dividerIndex) {
+		t.Fatalf("Next Activity line order invalid: header=%d activity=%d divider=%d", headerIndex, activityIndex, dividerIndex)
+	}
+}
+
+func TestView_headerNoActivityWhenNilState(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.RouterState = nil
+	got := m.View()
+	if strings.Contains(got, "Next Activity:") || strings.Contains(got, "BUILD:") || strings.Contains(got, "PLAN:") || strings.Contains(got, "AUDIT:") {
+		t.Error("View() should not show Next Activity line when RouterState is nil")
+	}
+}
+
+func TestView_headerNarrowWidth(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 40
+	m.RouterState = &data.RouterState{State: "audit-pending", NextAction: "Audit E06"}
+	got := m.View()
+	// Should not panic and header text should still be present
+	if !strings.Contains(got, "S A V E P O I N T") {
+		t.Error("View() at narrow width missing header text")
+	}
+}
+
+func TestRenderNextActivityLine_phaseMapping(t *testing.T) {
+	cases := []struct {
+		name  string
+		state *data.RouterState
+		tag   string
+	}{
+		{"build", &data.RouterState{State: "task-building", NextAction: "Build T010 (E06) v1"}, "BUILD:"},
+		{"audit", &data.RouterState{State: "audit-pending", NextAction: "Audit E03"}, "AUDIT:"},
+		{"pre implementation", &data.RouterState{State: "pre-implementation", NextAction: "Plan v1.1"}, "PLAN:"},
+		{"epic design", &data.RouterState{State: "epic-design", NextAction: "Design E03"}, "PLAN:"},
+		{"task breakdown", &data.RouterState{State: "epic-task-breakdown", NextAction: "Break down E03"}, "PLAN:"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := renderNextActivityLine(tc.state, 80)
+			if !strings.Contains(got, tc.tag) {
+				t.Fatalf("renderNextActivityLine() missing phase tag %q in %q", tc.tag, got)
+			}
+			if !strings.Contains(got, tc.state.NextAction) {
+				t.Fatalf("renderNextActivityLine() missing next_action %q in %q", tc.state.NextAction, got)
+			}
+		})
+	}
+}
+
+func TestRenderNextActivityLine_hiddenStates(t *testing.T) {
+	cases := []*data.RouterState{
+		nil,
+		{State: "idle", NextAction: "Wait"},
+		{State: "task-building", NextAction: ""},
+	}
+	for _, state := range cases {
+		if got := renderNextActivityLine(state, 80); got != "" {
+			t.Fatalf("renderNextActivityLine(%v) = %q, want empty", state, got)
+		}
+	}
+}
+
+func TestRenderNextActivityLine_truncatesAtNarrowWidth(t *testing.T) {
+	got := renderNextActivityLine(&data.RouterState{
+		State:      "pre-implementation",
+		NextAction: "Build T010 (E06) v1 with a very long follow-up activity",
+	}, 18)
+	if lipgloss.Width(got) > 18 {
+		t.Fatalf("renderNextActivityLine() width = %d, want <= 18; got %q", lipgloss.Width(got), got)
+	}
+	if !strings.Contains(got, "PLAN:") || !strings.Contains(got, "…") {
+		t.Fatalf("renderNextActivityLine() = %q, want PLAN tag and ellipsis", got)
+	}
+}
+
 func TestView_narrowShowsSingleColumn(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	m.Width = 60

package/internal/board/watch.go

@@ -11,26 +11,58 @@ import (
 )
 
 type fileChangeMsg struct{}
-type reloadMsg struct{ tasks []data.Task }
+type reloadMsg struct {
+	tasks        []data.Task
+	releases     []string
+	releaseEpics map[string][]string
+	epicStatuses map[string]string
+	routerState  *data.RouterState
+}
+
+type routerWriteMsg struct {
+	message string
+	state   *data.RouterState
+	taskID  string
+}
+
+type taskWriteMsg struct {
+	prefix string
+	next   data.Task
+	err    error
+}
+
+type epicDetailMsg struct {
+	content string
+}
+
+type auditContentMsg struct {
+	content string
+}
+
+type errorMsg struct {
+	message string
+}
 
 // watchFiles blocks until a file event arrives, debounces for 100ms, emits fileChangeMsg.
 func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 	return func() tea.Msg {
 		for {
 			select {
-			case _, ok := <-w.Events:
+			case event, ok := <-w.Events:
 				if !ok {
 					return nil
 				}
+				watchCreatedDir(w, event)
 				timer := time.NewTimer(100 * time.Millisecond)
 			drain:
 				for {
 					select {
-					case _, ok := <-w.Events:
+					case event, ok := <-w.Events:
 						if !ok {
 							timer.Stop()
 							return nil
 						}
+						watchCreatedDir(w, event)
 					case <-timer.C:
 						break drain
 					}
@@ -45,23 +77,28 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 	}
 }
 
-func reloadTasks(root string) tea.Cmd {
+func reloadTasks(root string, deps ModelDependencies) tea.Cmd {
 	return func() tea.Msg {
-		tasks, err := loadAllTasks(root)
+		tasks, releases, releaseEpics, epicStatuses, err := loadBoardData(root, deps.Discoverer, deps.Parser)
 		if err != nil {
-			return nil
+			return errorMsg{message: "reload failed: " + err.Error()}
 		}
-		return reloadMsg{tasks: tasks}
+		routerState, _ := readRouterState(root, deps.RouterReader)
+		return reloadMsg{tasks: tasks, releases: releases, releaseEpics: releaseEpics, epicStatuses: epicStatuses, routerState: routerState}
 	}
 }
 
-// newWatcher watches the releases directory by walking all subdirs (fsnotify v1.10 has no recursive opt).
+// newWatcher watches the savepoint root (for router.md) and all releases subdirs.
 func newWatcher(root string) (*fsnotify.Watcher, error) {
 	w, err := fsnotify.NewWatcher()
 	if err != nil {
 		return nil, err
 	}
-	releasesPath := filepath.Join(root, ".savepoint", "releases")
+	if err := w.Add(root); err != nil {
+		w.Close()
+		return nil, err
+	}
+	releasesPath := filepath.Join(root, "releases")
 	if err := addDirsRecursive(w, releasesPath); err != nil {
 		w.Close()
 		return nil, err
@@ -69,6 +106,17 @@ func newWatcher(root string) (*fsnotify.Watcher, error) {
 	return w, nil
 }
 
+func watchCreatedDir(w *fsnotify.Watcher, event fsnotify.Event) {
+	if !event.Has(fsnotify.Create) {
+		return
+	}
+	info, err := os.Stat(event.Name)
+	if err != nil || !info.IsDir() {
+		return
+	}
+	_ = addDirsRecursive(w, event.Name)
+}
+
 func addDirsRecursive(w *fsnotify.Watcher, root string) error {
 	return filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
 		if err != nil {