savepoint 1.0.1 → 1.0.3

package/internal/board/card_test.go

@@ -5,11 +5,12 @@ import (
 	"testing"
 
 	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/styles"
 )
 
 func TestRenderCard_containsID(t *testing.T) {
 	task := data.Task{ID: "E04/T002", Title: "Build card", Stage: data.StageBuild}
-	got := RenderCard(task, 30, false, "")
+	got := RenderCard(task, 30, false, nil)
 	if !strings.Contains(got, "T002") {
 		t.Error("RenderCard missing short task ID")
 	}
@@ -17,7 +18,7 @@ func TestRenderCard_containsID(t *testing.T) {
 
 func TestRenderCard_containsTitle(t *testing.T) {
 	task := data.Task{ID: "T1", Title: "My title", Stage: data.StageBuild}
-	got := RenderCard(task, 30, false, "")
+	got := RenderCard(task, 30, false, nil)
 	if !strings.Contains(got, "My title") {
 		t.Error("RenderCard missing task title")
 	}
@@ -25,7 +26,7 @@ func TestRenderCard_containsTitle(t *testing.T) {
 
 func TestRenderCard_containsBuildGlyph(t *testing.T) {
 	task := data.Task{ID: "T1", Stage: data.StageBuild}
-	got := RenderCard(task, 30, false, "")
+	got := RenderCard(task, 30, false, nil)
 	if !strings.Contains(got, glyphBuild) {
 		t.Errorf("RenderCard missing build glyph %q", glyphBuild)
 	}
@@ -33,7 +34,7 @@ func TestRenderCard_containsBuildGlyph(t *testing.T) {
 
 func TestRenderCard_containsTestGlyph(t *testing.T) {
 	task := data.Task{ID: "T1", Stage: data.StageTest}
-	got := RenderCard(task, 30, false, "")
+	got := RenderCard(task, 30, false, nil)
 	if !strings.Contains(got, glyphTest) {
 		t.Errorf("RenderCard missing test glyph %q", glyphTest)
 	}
@@ -41,7 +42,7 @@ func TestRenderCard_containsTestGlyph(t *testing.T) {
 
 func TestRenderCard_containsAuditGlyph(t *testing.T) {
 	task := data.Task{ID: "T1", Stage: data.StageAudit}
-	got := RenderCard(task, 30, false, "")
+	got := RenderCard(task, 30, false, nil)
 	if !strings.Contains(got, glyphAudit) {
 		t.Errorf("RenderCard missing audit glyph %q", glyphAudit)
 	}
@@ -49,7 +50,7 @@ func TestRenderCard_containsAuditGlyph(t *testing.T) {
 
 func TestRenderCard_focusedDoesNotPanic(t *testing.T) {
 	task := data.Task{ID: "T1", Title: "hello", Stage: data.StageBuild}
-	got := RenderCard(task, 30, true, "")
+	got := RenderCard(task, 30, true, nil)
 	if got == "" {
 		t.Error("RenderCard focused returned empty string")
 	}
@@ -58,7 +59,7 @@ func TestRenderCard_focusedDoesNotPanic(t *testing.T) {
 func TestRenderCard_titleWraps(t *testing.T) {
 	long := "This is a very long title that should be wrapped for sure"
 	task := data.Task{ID: "T1", Title: long, Stage: data.StageBuild}
-	got := RenderCard(task, 20, false, "")
+	got := RenderCard(task, 20, false, nil)
 	// full title as one line does not fit; it must be broken up
 	if strings.Contains(got, long) {
 		t.Error("RenderCard should wrap long title, not render it as one line")
@@ -72,7 +73,7 @@ func TestRenderCard_titleWraps(t *testing.T) {
 func TestRenderCard_idTruncated(t *testing.T) {
 	long := "E04-board-components/T999-very-long-id"
 	task := data.Task{ID: long, Stage: data.StageBuild}
-	got := RenderCard(task, 20, false, "")
+	got := RenderCard(task, 20, false, nil)
 	if strings.Contains(got, long) {
 		t.Error("RenderCard should truncate long ID")
 	}
@@ -106,20 +107,148 @@ func TestTruncate_maxOne(t *testing.T) {
 
 func TestRenderCard_defaultStageUsesBuildGlyph(t *testing.T) {
 	task := data.Task{ID: "T1", Stage: ""}
-	got := RenderCard(task, 30, false, "")
+	got := RenderCard(task, 30, false, nil)
 	if !strings.Contains(got, glyphBuild) {
 		t.Error("RenderCard with empty stage should use build glyph")
 	}
 }
 
 func TestRenderCard_routerPriorityUsesGreenGlyph(t *testing.T) {
-	task := data.Task{ID: "E06/T009", Stage: data.StageTest}
-	got := RenderCard(task, 30, false, "E06/T009")
+	task := data.Task{ID: "E06/T009", Release: "v1", Epic: "E06", Stage: data.StageTest}
+	router := &data.RouterState{Release: "v1", Epic: "E06", Task: "E06/T009"}
+	got := RenderCard(task, 30, false, router)
+	if !isRouterPriority(task, router) {
+		t.Error("router priority should match release, epic, and task")
+	}
 	if !strings.Contains(got, glyphBuild) {
 		t.Error("router priority card should use build glyph")
 	}
-	nonPriority := RenderCard(task, 30, false, "")
+	nonPriority := RenderCard(task, 30, false, nil)
 	if !strings.Contains(nonPriority, glyphTest) {
 		t.Error("non-priority test card should use test glyph")
 	}
 }
+
+func TestRenderCard_noBackgroundFillEscapes(t *testing.T) {
+	task := data.Task{ID: "E06/T009", Title: "Router priority", Release: "v1", Epic: "E06", Stage: data.StageTest}
+	router := &data.RouterState{Release: "v1", Epic: "E06", Task: "E06/T009"}
+	got := RenderCard(task, 30, false, router)
+	if strings.Contains(got, "\x1b[48;") || strings.Contains(got, "\x1b[40m") {
+		t.Fatalf("RenderCard should not emit background fills; got %q", got)
+	}
+}
+
+func TestRenderCard_routerPriorityMatchesShortID(t *testing.T) {
+	// Router stores short IDs ("T009"); task ID is full slug — must still match.
+	task := data.Task{ID: "E06-atari-noir-layout/T009-router-priority", Release: "v1", Epic: "E06-atari-noir-layout", Stage: data.StageTest}
+	router := &data.RouterState{Release: "v1", Epic: "E06", Task: "T009"}
+	got := RenderCard(task, 30, false, router)
+	if !isRouterPriority(task, router) {
+		t.Error("short router task ID should match full task ID slug")
+	}
+	if !strings.Contains(got, glyphBuild) {
+		t.Error("router priority card should use build glyph")
+	}
+}
+
+func TestRenderCard_staleRouterTaskNoMatch(t *testing.T) {
+	// Task moved to a new epic; router still has old epic path — should NOT match a different task number.
+	task := data.Task{ID: "E03-header-activity/T001-border-resize-fix", Release: "v1", Epic: "E03-header-activity", Stage: data.StageBuild}
+	router := &data.RouterState{Release: "v1", Epic: "E03", Task: "T002"}
+	got := RenderCard(task, 30, false, router)
+	if isRouterPriority(task, router) {
+		t.Error("stale router pointing to different task number should not show green glyph")
+	}
+	if !strings.Contains(got, styles.GlyphBuild.Render(glyphBuild)) {
+		t.Error("non-priority build task should use orange build glyph")
+	}
+}
+
+func TestRenderCard_routerSameTaskNumberDifferentEpicNoMatch(t *testing.T) {
+	task := data.Task{ID: "E03-header-activity/T001-border-resize-fix", Release: "v1", Epic: "E03-header-activity", Stage: data.StageTest}
+	router := &data.RouterState{Release: "v1", Epic: "E01", Task: "T001"}
+	got := RenderCard(task, 30, false, router)
+	if isRouterPriority(task, router) {
+		t.Error("router priority should not match same task number in a different epic")
+	}
+	if !strings.Contains(got, styles.GlyphTest.Render(glyphTest)) {
+		t.Error("non-priority test task should keep test glyph")
+	}
+}
+
+func TestRenderCard_doneTaskUsesOrangeBuildGlyph(t *testing.T) {
+	task := data.Task{ID: "E03/T001", Release: "v1", Epic: "E03", Column: data.ColumnDone, Stage: data.StageTest}
+	router := &data.RouterState{Release: "v1", Epic: "E03", Task: "T001"}
+	got := RenderCard(task, 30, false, router)
+	if !isRouterPriority(task, router) {
+		t.Error("router state should still identify the matching done task")
+	}
+	if !strings.Contains(got, styles.GlyphBuild.Render(glyphBuild)) {
+		t.Error("done task should use orange build glyph")
+	}
+	if strings.Contains(got, glyphTest) {
+		t.Error("done task should not use test glyph")
+	}
+}
+
+func TestRenderCard_explicitStatusUsesUnifiedGlyph(t *testing.T) {
+	tests := []struct {
+		name   string
+		status string
+		glyph  string
+	}{
+		{"planned", string(data.ColumnPlanned), "○"},
+		{"done", string(data.ColumnDone), "◉"},
+		{"audited", "audited", "✓"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := data.Task{ID: "T1", Status: string(tt.status), Stage: data.StageAudit}
+			got := RenderCard(task, 30, false, nil)
+			if !strings.Contains(got, tt.glyph) {
+				t.Errorf("RenderCard with status %q missing glyph %q", tt.status, tt.glyph)
+			}
+			if strings.Contains(got, glyphAudit) {
+				t.Errorf("RenderCard with status %q should not fall back to audit glyph", tt.status)
+			}
+		})
+	}
+}
+
+func TestRenderCard_inProgressShowsPhaseText(t *testing.T) {
+	tests := []struct {
+		name  string
+		stage data.ProgressStage
+		label string
+		glyph string
+	}{
+		{"build", data.StageBuild, "BUILD", glyphBuild},
+		{"test", data.StageTest, "TEST", glyphTest},
+		{"audit", data.StageAudit, "AUDIT", glyphAudit},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := data.Task{ID: "T1", Column: data.ColumnInProgress, Status: string(data.ColumnInProgress), Stage: tt.stage}
+			got := RenderCard(task, 30, false, nil)
+			if !strings.Contains(got, tt.label) {
+				t.Errorf("RenderCard missing phase label %q", tt.label)
+			}
+			if !strings.Contains(got, tt.glyph) {
+				t.Errorf("RenderCard missing phase glyph %q", tt.glyph)
+			}
+			if strings.Contains(got, "▶") {
+				t.Error("RenderCard should not use generic in_progress glyph when phase is available")
+			}
+		})
+	}
+}
+
+func TestRenderCard_doneShowsDoneText(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnDone, Status: string(data.ColumnDone)}
+	got := RenderCard(task, 30, false, nil)
+	if !strings.Contains(got, "DONE") {
+		t.Error("RenderCard missing DONE phase label")
+	}
+}

package/internal/board/column.go

@@ -8,12 +8,13 @@ import (
 	"github.com/opencode/savepoint/internal/styles"
 )
 
-// RenderColumn renders a board column: header with label+count, task list, bordered container.
-func RenderColumn(tasks []data.Task, col data.ColumnType, width, focusedTask int, focused bool, routerTaskID string) string {
+// RenderColumn renders a board column: header with label+count, task viewport, bordered container.
+func RenderColumn(tasks []data.Task, col data.ColumnType, width, maxHeight, offset, focusedTask int, focused bool, routerState *data.RouterState) string {
 	inner := width - colOverhead
 	if inner < minColWidth {
 		inner = minColWidth
 	}
+	offset = clampViewportOffset(offset, len(tasks))
 
 	title := columnTitle(col)
 	header := fmt.Sprintf("%s (%d)", title, len(tasks))
@@ -27,19 +28,90 @@ func RenderColumn(tasks []data.Task, col data.ColumnType, width, focusedTask int
 	if len(tasks) == 0 {
 		lines = append(lines, styles.TaskItem.Render("(empty)"))
 	} else {
-		for i, t := range tasks {
-			lines = append(lines, RenderCard(t, inner, focused && i == focusedTask, routerTaskID))
+		contentBudget := maxHeight - 2
+		if contentBudget < 1 {
+			contentBudget = 1
+		}
+
+		reserveAbove := 0
+		if offset > 0 {
+			reserveAbove = 1
+		}
+
+		type cardEntry struct {
+			card  string
+			lines int
+		}
+		cardEntries := make([]cardEntry, 0, len(tasks)-offset)
+		for i := offset; i < len(tasks); i++ {
+			c := RenderCard(tasks[i], inner, focused && i == focusedTask, routerState)
+			cardEntries = append(cardEntries, cardEntry{card: c, lines: strings.Count(c, "\n") + 1})
+		}
+
+		usedLines := reserveAbove
+		endIdx := 0
+		for endIdx < len(cardEntries) {
+			needsMore := endIdx < len(cardEntries)-1
+			bottomReserve := 0
+			if needsMore {
+				bottomReserve = 1
+			}
+			if usedLines+cardEntries[endIdx].lines+bottomReserve > contentBudget {
+				break
+			}
+			usedLines += cardEntries[endIdx].lines
+			endIdx++
+		}
+
+		if endIdx == 0 && len(cardEntries) > 0 {
+			endIdx = 1
+		}
+
+		if offset > 0 {
+			lines = append(lines, renderScrollIndicator("↑", offset, "above"))
+		}
+		for i := 0; i < endIdx; i++ {
+			lines = append(lines, cardEntries[i].card)
+		}
+		if endIdx < len(cardEntries) {
+			remaining := len(tasks) - (offset + endIdx)
+			lines = append(lines, renderScrollIndicator("↓", remaining, "more"))
 		}
 	}
 
 	content := strings.Join(lines, "\n")
-	st := styles.Column.Width(width)
+	st := styles.ColumnUnfocused.Width(width)
 	if focused {
 		st = styles.ColumnFocused.Width(width)
 	}
 	return st.Render(content)
 }
 
+func visibleColumnTaskLimit(maxHeight int) int {
+	if maxHeight <= 0 {
+		return 999999
+	}
+	limit := (maxHeight - 2) / 3
+	if limit < 1 {
+		return 1
+	}
+	return limit
+}
+
+func clampViewportOffset(offset, total int) int {
+	if offset < 0 || total <= 0 {
+		return 0
+	}
+	if offset >= total {
+		return total - 1
+	}
+	return offset
+}
+
+func renderScrollIndicator(arrow string, count int, suffix string) string {
+	return styles.ScrollIndicator.Render(fmt.Sprintf("%s %d %s", arrow, count, suffix))
+}
+
 func columnTitle(col data.ColumnType) string {
 	switch col {
 	case data.ColumnPlanned:
@@ -53,9 +125,3 @@ func columnTitle(col data.ColumnType) string {
 	}
 }
 
-func taskLabel(t data.Task) string {
-	if t.Title == "" {
-		return t.ID
-	}
-	return fmt.Sprintf("%s  %s", t.ID, t.Title)
-}

package/internal/board/column_test.go

@@ -4,11 +4,12 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/charmbracelet/lipgloss"
 	"github.com/opencode/savepoint/internal/data"
 )
 
 func TestRenderColumn_headerContainsLabel(t *testing.T) {
-	got := RenderColumn(nil, data.ColumnPlanned, 30, 0, false, "")
+	got := RenderColumn(nil, data.ColumnPlanned, 30, 0, 0, 0, false, nil)
 	if !strings.Contains(got, "PLANNED") {
 		t.Error("RenderColumn missing PLANNED label")
 	}
@@ -16,14 +17,14 @@ func TestRenderColumn_headerContainsLabel(t *testing.T) {
 
 func TestRenderColumn_headerContainsCount(t *testing.T) {
 	tasks := []data.Task{{ID: "T1", Title: "Task one", Column: data.ColumnPlanned}}
-	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, false, "")
+	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, 0, 0, false, nil)
 	if !strings.Contains(got, "(1)") {
 		t.Error("RenderColumn missing task count")
 	}
 }
 
 func TestRenderColumn_emptyShowsPlaceholder(t *testing.T) {
-	got := RenderColumn(nil, data.ColumnDone, 30, 0, false, "")
+	got := RenderColumn(nil, data.ColumnDone, 30, 0, 0, 0, false, nil)
 	if !strings.Contains(got, "(empty)") {
 		t.Error("RenderColumn missing (empty) for empty column")
 	}
@@ -31,7 +32,7 @@ func TestRenderColumn_emptyShowsPlaceholder(t *testing.T) {
 
 func TestRenderColumn_focusedDoesNotPanic(t *testing.T) {
 	tasks := []data.Task{{ID: "T1", Column: data.ColumnInProgress}}
-	got := RenderColumn(tasks, data.ColumnInProgress, 30, 0, true, "")
+	got := RenderColumn(tasks, data.ColumnInProgress, 30, 0, 0, 0, true, nil)
 	if got == "" {
 		t.Error("RenderColumn returned empty string for focused column")
 	}
@@ -47,7 +48,7 @@ func TestRenderColumn_allColumnTitles(t *testing.T) {
 		{data.ColumnDone, "DONE"},
 	}
 	for _, tc := range cases {
-		got := RenderColumn(nil, tc.col, 30, 0, false, "")
+		got := RenderColumn(nil, tc.col, 30, 0, 0, 0, false, nil)
 		if !strings.Contains(got, tc.label) {
 			t.Errorf("RenderColumn missing label %q for col %q", tc.label, tc.col)
 		}
@@ -56,7 +57,7 @@ func TestRenderColumn_allColumnTitles(t *testing.T) {
 
 func TestRenderColumn_taskTitleRendered(t *testing.T) {
 	tasks := []data.Task{{ID: "T2", Title: "Build it", Column: data.ColumnPlanned}}
-	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, false, "")
+	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, 0, 0, false, nil)
 	if !strings.Contains(got, "Build it") {
 		t.Error("RenderColumn missing task title")
 	}
@@ -64,26 +65,75 @@ func TestRenderColumn_taskTitleRendered(t *testing.T) {
 
 func TestRenderColumn_rendersTaskCards(t *testing.T) {
 	tasks := []data.Task{{ID: "T2", Title: "Build it", Column: data.ColumnPlanned, Stage: data.StageAudit}}
-	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, true, "")
+	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, 0, 0, true, nil)
 	if !strings.Contains(got, glyphAudit) {
 		t.Error("RenderColumn should render task phase glyph from card")
 	}
-	if !strings.Contains(got, "╭") {
+	if !strings.Contains(got, "┌") {
 		t.Error("RenderColumn should render focused card border")
 	}
 }
 
-func TestRenderColumn_unfocusedUsesSurfaceWithoutBorder(t *testing.T) {
+func TestRenderColumn_focusStatesUseStableBorderDimensions(t *testing.T) {
 	tasks := []data.Task{{ID: "T2", Title: "Build it", Column: data.ColumnPlanned, Stage: data.StageAudit}}
-	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, false, "")
-	if strings.Contains(got, "╭") {
-		t.Error("unfocused column/card should not render rounded borders")
+	unfocused := RenderColumn(tasks, data.ColumnPlanned, 30, 0, 0, -1, false, nil)
+	focused := RenderColumn(tasks, data.ColumnPlanned, 30, 0, 0, -1, true, nil)
+
+	if !strings.Contains(unfocused, "┌") {
+		t.Error("unfocused column should render a single-line border")
+	}
+	if !strings.Contains(focused, "┌") {
+		t.Error("focused column should render a single-line border")
+	}
+
+	unfocusedLines := strings.Split(unfocused, "\n")
+	focusedLines := strings.Split(focused, "\n")
+	if len(unfocusedLines) != len(focusedLines) {
+		t.Fatalf("line count changed between focus states: unfocused=%d focused=%d", len(unfocusedLines), len(focusedLines))
+	}
+	for i := range unfocusedLines {
+		if lipgloss.Width(unfocusedLines[i]) != lipgloss.Width(focusedLines[i]) {
+			t.Fatalf("line %d width changed between focus states: unfocused=%d focused=%d", i, lipgloss.Width(unfocusedLines[i]), lipgloss.Width(focusedLines[i]))
+		}
 	}
 }
 
 func TestRenderColumn_emptyCountIsZero(t *testing.T) {
-	got := RenderColumn(nil, data.ColumnPlanned, 30, 0, false, "")
+	got := RenderColumn(nil, data.ColumnPlanned, 30, 0, 0, 0, false, nil)
 	if !strings.Contains(got, "(0)") {
 		t.Error("RenderColumn missing (0) count for empty column")
 	}
 }
+
+func TestRenderColumn_viewportShowsScrollIndicators(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Title: "Task one", Column: data.ColumnPlanned},
+		{ID: "T2", Title: "Task two", Column: data.ColumnPlanned},
+		{ID: "T3", Title: "Task three", Column: data.ColumnPlanned},
+		{ID: "T4", Title: "Task four", Column: data.ColumnPlanned},
+	}
+
+	got := RenderColumn(tasks, data.ColumnPlanned, 30, 8, 1, 1, true, nil)
+
+	if !strings.Contains(got, "↑ 1 above") {
+		t.Error("RenderColumn missing above indicator")
+	}
+	if !strings.Contains(got, "↓ 2 more") {
+		t.Errorf("RenderColumn missing more indicator, got:\n%s", got)
+	}
+	if strings.Contains(got, "Task one") {
+		t.Error("RenderColumn should not render tasks above viewport")
+	}
+	if strings.Contains(got, "Task three") {
+		t.Error("RenderColumn should not render tasks that don't fit budget")
+	}
+	if strings.Contains(got, "Task four") {
+		t.Error("RenderColumn should not render tasks below viewport")
+	}
+}
+
+func TestVisibleColumnTaskLimitDefaultsToFourAtStandardHeight(t *testing.T) {
+	if got := visibleColumnTaskLimit(CalculateLayout(100, 24).ContentHeight); got != 4 {
+		t.Errorf("visibleColumnTaskLimit(standard height) = %d, want 4", got)
+	}
+}