savepoint 1.0.1 → 1.0.2

package/internal/board/update_test.go

@@ -1,6 +1,9 @@
 package board
 
 import (
+	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -90,6 +93,54 @@ func TestUpdate_downMovesTaskFocus(t *testing.T) {
 	}
 }
 
+func TestUpdate_downAutoScrollsFocusedTaskIntoViewport(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned},
+		{ID: "T2", Column: data.ColumnPlanned},
+		{ID: "T3", Column: data.ColumnPlanned},
+		{ID: "T4", Column: data.ColumnPlanned},
+		{ID: "T5", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+	m.Width = 100
+	m.Height = 24
+	m.FocusedTask = 3
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyDown})
+	updated := requireModel(t, got)
+
+	if updated.FocusedTask != 4 {
+		t.Errorf("FocusedTask = %d, want 4", updated.FocusedTask)
+	}
+	if updated.ColumnOffsets[data.ColumnPlanned] != 1 {
+		t.Errorf("ColumnOffsets[planned] = %d, want 1", updated.ColumnOffsets[data.ColumnPlanned])
+	}
+}
+
+func TestUpdate_pageDownScrollsFocusedColumnByPage(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned},
+		{ID: "T2", Column: data.ColumnPlanned},
+		{ID: "T3", Column: data.ColumnPlanned},
+		{ID: "T4", Column: data.ColumnPlanned},
+		{ID: "T5", Column: data.ColumnPlanned},
+		{ID: "T6", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+	m.Width = 100
+	m.Height = 24
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyPgDown})
+	updated := requireModel(t, got)
+
+	if updated.ColumnOffsets[data.ColumnPlanned] != 2 {
+		t.Errorf("ColumnOffsets[planned] = %d, want 2", updated.ColumnOffsets[data.ColumnPlanned])
+	}
+	if updated.FocusedTask != 2 {
+		t.Errorf("FocusedTask = %d, want 2", updated.FocusedTask)
+	}
+}
+
 func TestUpdate_upMovesTaskFocus(t *testing.T) {
 	tasks := []data.Task{
 		{ID: "T1", Column: data.ColumnPlanned},
@@ -126,3 +177,118 @@ func TestUpdate_unknownMsgNoOp(t *testing.T) {
 		t.Errorf("Width changed unexpectedly: %d", updated.Width)
 	}
 }
+
+func TestUpdate_mSetsRouterToFocusedTask(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{
+		{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned},
+		{ID: "E05-tasking-permissions/T005-update-help-overlay", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if !strings.Contains(updated.StatusMessage, "Router set to v1.1 E05-tasking-permissions/T004") {
+		t.Fatalf("StatusMessage = %q", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.State != "task-building" {
+		t.Errorf("router state = %q, want task-building", state.State)
+	}
+	if state.Release != "v1.1" {
+		t.Errorf("router release = %q, want v1.1", state.Release)
+	}
+	if state.Epic != "E05-tasking-permissions" {
+		t.Errorf("router epic = %q, want E05-tasking-permissions", state.Epic)
+	}
+	if state.Task != "E05-tasking-permissions/T004-implement-m-hotkey" {
+		t.Errorf("router task = %q, want focused task", state.Task)
+	}
+}
+
+func TestUpdate_mSetsAuditPendingForLastUncompletedTask(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{
+		{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned},
+		{ID: "E05-tasking-permissions/T003-update-design-md", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnDone},
+	}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if updated.StatusMessage != "Audit pending for E05-tasking-permissions" {
+		t.Fatalf("StatusMessage = %q", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.State != "audit-pending" {
+		t.Errorf("router state = %q, want audit-pending", state.State)
+	}
+	if state.Task != "" {
+		t.Errorf("router task = %q, want empty", state.Task)
+	}
+}
+
+func TestUpdate_mDoesNothingWhenOverlayOpen(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned}}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+	m.Overlay = OverlayHelp
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if updated.StatusMessage != "" {
+		t.Fatalf("StatusMessage = %q, want empty", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.Task != "T001" {
+		t.Errorf("router task = %q, want unchanged T001", state.Task)
+	}
+}
+
+func TestUpdate_mDoesNotSetDoneTask(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnDone}}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+	m.FocusedColumn = data.ColumnDone
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if updated.StatusMessage != "Router not updated: focused task is done" {
+		t.Fatalf("StatusMessage = %q", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.Task != "T001" {
+		t.Errorf("router task = %q, want unchanged T001", state.Task)
+	}
+}
+
+func writeRouterFixture(t *testing.T) string {
+	t.Helper()
+	root := t.TempDir()
+	content := "# Agent State Machine\n\n## Current state\n\n```yaml\nstate: task-building\nrelease: v1.1\nepic: E05\ntask: T001\nnext_action: Build T001.\n```\n"
+	if err := os.WriteFile(filepath.Join(root, "router.md"), []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+	return root
+}
+
+func readRouterFixture(t *testing.T, root string) *data.RouterState {
+	t.Helper()
+	content, err := os.ReadFile(filepath.Join(root, "router.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	state, err := data.NewRouterReader().ReadState(string(content))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return state
+}

package/internal/board/view.go

@@ -1,6 +1,7 @@
 package board
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
@@ -19,21 +20,25 @@ 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)
+	layout := CalculateLayoutWithChrome(w, h, extraHeaderLines(nextActivity))
 	topDivider := dividerLine(w)
 	board := m.renderBoard(layout)
 	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 +61,111 @@ 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 := ""
+		if m.EpicPanelCursor >= 0 && m.EpicPanelCursor < len(m.Epics) {
+			epicSlug = m.Epics[m.EpicPanelCursor]
+		}
+		detail := RenderEpicDetail(epicSlug, m.EpicDetailContent, ow, detailMaxHeight(h), m.EpicDetailOffset)
 		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, shortRouterID(state.Epic), shortRouterID(state.Task))
+	case "audit-pending":
+		s = fmt.Sprintf("Audit %s", shortRouterID(state.Epic))
+	case "epic-design":
+		s = fmt.Sprintf("Design %s", shortRouterID(state.Epic))
+	case "epic-task-breakdown":
+		s = fmt.Sprintf("Plan %s", shortRouterID(state.Epic))
+	case "pre-implementation":
+		s = fmt.Sprintf("Planning %s", state.Release)
+	default:
+		s = state.State
+	}
+	return xansi.Truncate(s, 20, "…")
+}
+
+// shortRouterID extracts the compact prefix from a full router slug.
+// "E01-tui-optimisation/T001-border-resize-fix" → "T001"
+// "E01-tui-optimisation" → "E01"
+func shortRouterID(full string) string {
+	part := full
+	if i := strings.LastIndex(full, "/"); i >= 0 {
+		part = full[i+1:]
+	}
+	if i := strings.Index(part, "-"); i >= 0 {
+		return part[:i]
+	}
+	return part
+}
+
 func (m Model) focusedTask() (data.Task, bool) {
 	tasks := m.Tasks[m.FocusedColumn]
 	if len(tasks) == 0 || m.FocusedTask >= len(tasks) {
@@ -150,23 +253,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)
+	return RenderEpicSidebar(m.Epics, m.SelectedEpic, w, m.EpicPanelFocus, m.EpicPanelCursor, m.EpicStatus)
+}
+
+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 {
@@ -196,5 +310,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

@@ -74,7 +74,7 @@ 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]) != "" {
+	if strings.TrimSpace(plainTerminal(lines[1])) != "" {
 		t.Fatalf("renderFooter() spacer line = %q, want blank", lines[1])
 	}
 	for i, line := range lines {
@@ -133,6 +133,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,33 @@ 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
+}
 
 // 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
 					}
@@ -47,11 +54,11 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 
 func reloadTasks(root string) tea.Cmd {
 	return func() tea.Msg {
-		tasks, err := loadAllTasks(root)
+		tasks, releases, releaseEpics, epicStatuses, err := loadBoardData(root)
 		if err != nil {
 			return nil
 		}
-		return reloadMsg{tasks: tasks}
+		return reloadMsg{tasks: tasks, releases: releases, releaseEpics: releaseEpics, epicStatuses: epicStatuses}
 	}
 }
 
@@ -61,7 +68,7 @@ func newWatcher(root string) (*fsnotify.Watcher, error) {
 	if err != nil {
 		return nil, err
 	}
-	releasesPath := filepath.Join(root, ".savepoint", "releases")
+	releasesPath := filepath.Join(root, "releases")
 	if err := addDirsRecursive(w, releasesPath); err != nil {
 		w.Close()
 		return nil, err
@@ -69,6 +76,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 {