savepoint 1.0.0 → 1.0.2

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,28 +50,30 @@ 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")
 	}
 }
 
-func TestRenderCard_titleTruncated(t *testing.T) {
-	long := "This is a very long title that should be truncated for sure"
+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 truncate long title")
+		t.Error("RenderCard should wrap long title, not render it as one line")
 	}
-	if !strings.Contains(got, "…") {
-		t.Error("RenderCard should include ellipsis when title truncated")
+	// words from the title must still appear somewhere in the output
+	if !strings.Contains(got, "This") {
+		t.Error("RenderCard wrapped title missing expected content")
 	}
 }
 
 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")
 	}
@@ -104,8 +107,112 @@ 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", 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, 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 data.TaskStatus
+		glyph  string
+	}{
+		{"planned", data.StatusPlanned, "○"},
+		{"in progress", data.StatusInProgress, "▶"},
+		{"done", data.StatusDone, "◉"},
+		{"audited", data.StatusAudited, "✓"},
+	}
+
+	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)
+			}
+		})
+	}
+}

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) 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,53 @@ 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))
+		limit := visibleColumnTaskLimit(maxHeight)
+		end := min(offset+limit, len(tasks))
+		if offset > 0 {
+			lines = append(lines, renderScrollIndicator("↑", offset, "above"))
+		}
+		for i, t := range tasks[offset:end] {
+			taskIndex := offset + i
+			lines = append(lines, RenderCard(t, inner, focused && taskIndex == focusedTask, routerState))
+		}
+		if end < len(tasks) {
+			lines = append(lines, renderScrollIndicator("↓", len(tasks)-end, "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:

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,18 +65,72 @@ 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, "╭") {
-		t.Error("RenderColumn should render bordered card")
+	if !strings.Contains(got, "┌") {
+		t.Error("RenderColumn should render focused card border")
+	}
+}
+
+func TestRenderColumn_focusStatesUseStableBorderDimensions(t *testing.T) {
+	tasks := []data.Task{{ID: "T2", Title: "Build it", Column: data.ColumnPlanned, Stage: data.StageAudit}}
+	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, "↓ 1 more") {
+		t.Error("RenderColumn missing more indicator")
+	}
+	if strings.Contains(got, "Task one") {
+		t.Error("RenderColumn should not render tasks above viewport")
+	}
+	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)
+	}
+}

package/internal/board/detail.go

@@ -3,14 +3,17 @@ package board
 import (
 	"strings"
 
+	"github.com/charmbracelet/lipgloss"
 	"github.com/opencode/savepoint/internal/data"
 	"github.com/opencode/savepoint/internal/styles"
 )
 
-const detailBorderPad = 4 // rounded border (2) + padding (2×1)
+const detailBorderPad = 4        // rounded border (2) + padding (2×1)
+const detailVerticalOverhead = 4 // overlay border (2) + fixed title/header rows (2)
 
 // RenderDetail renders a task detail overlay panel at the given display width.
-func RenderDetail(t data.Task, overlayW int) string {
+// When router state matches t's release/epic/task, a "(router priority)" label is shown.
+func RenderDetail(t data.Task, overlayW int, routerState *data.RouterState, maxHeight, offset int) string {
 	inner := overlayW - detailBorderPad
 	if inner < 4 {
 		inner = 4
@@ -20,51 +23,140 @@ func RenderDetail(t data.Task, overlayW int) string {
 		styles.ColumnTitleFocused.Render("TASK DETAIL"),
 		strings.Repeat("─", inner),
 	}
-	lines = append(lines,
+	body := []string{
 		detailRow("ID", t.ID, inner),
 		detailRow("Title", t.Title, inner),
 		detailRow("Epic", t.Epic, inner),
 		detailRow("Release", t.Release, inner),
 		detailRow("Status", string(t.Column), inner),
 		detailRow("Phase", phaseLabel(t.Stage), inner),
-	)
+	}
 
 	if t.Description != "" {
-		lines = append(lines,
+		body = append(body,
 			"",
 			styles.ColumnTitle.Render("Description:"),
 		)
-		for _, line := range wrapText(t.Description, inner) {
-			lines = append(lines, styles.CardMeta.Render(line))
+		for _, line := range WrapText(t.Description, inner) {
+			body = append(body, styles.CardMeta.Render(line))
 		}
 	}
 
-	if len(t.Acceptance) > 0 {
-		lines = append(lines, "", styles.ColumnTitle.Render("Acceptance Criteria:"))
-		for _, a := range t.Acceptance {
-			for _, line := range wrapText(a, inner-2) {
-				lines = append(lines, styles.CardMeta.Render("  • "+line))
+	if len(t.Checklist) > 0 {
+		body = append(body, "", styles.ColumnTitle.Render("Implementation Plan:"), "")
+		for _, item := range t.Checklist {
+			glyph := "[ ] "
+			style := styles.CardMeta
+			if item.Done {
+				glyph = "[x] "
+				style = styles.TagDone
 			}
+			body = append(body, renderChecklistSentences(item.Text, glyph, inner, style)...)
 		}
 	}
 
-	if len(t.Checklist) > 0 {
-		lines = append(lines, "", styles.ColumnTitle.Render("Implementation Plan:"))
-		for _, item := range t.Checklist {
-			for _, line := range wrapText(item, inner-2) {
-				lines = append(lines, styles.CardMeta.Render("  □ "+line))
+	if t.Column != data.ColumnDone && isRouterPriority(t, routerState) {
+		body = append(body, "", styles.TagDone.Render("(router priority)"))
+	}
+	body = append(body, "", styles.CardMeta.Render("esc:close"))
+	lines = append(lines, visibleDetailLines(body, maxHeight-detailVerticalOverhead, offset)...)
+
+	return styles.DetailOverlay.Width(overlayW).Render(strings.Join(lines, "\n"))
+}
+
+func renderChecklistSentences(text, glyph string, width int, style lipgloss.Style) []string {
+	textWidth := width - len(glyph)
+	if textWidth < 4 {
+		textWidth = 4
+	}
+
+	lines := []string{}
+	continuationIndent := strings.Repeat(" ", len(glyph))
+	for _, sentence := range splitChecklistSentences(text) {
+		wrapped := WrapText(sentence, textWidth)
+		for i, line := range wrapped {
+			if i == 0 {
+				lines = append(lines, style.Render(glyph+line))
+				continue
 			}
+			lines = append(lines, style.Render(continuationIndent+line))
 		}
 	}
+	return lines
+}
 
-	lines = append(lines, "", styles.CardMeta.Render("esc:close"))
+func splitChecklistSentences(text string) []string {
+	fields := strings.Fields(text)
+	if len(fields) == 0 {
+		return nil
+	}
+	normalized := strings.Join(fields, " ")
 
-	return styles.DetailOverlay.Width(overlayW).Render(strings.Join(lines, "\n"))
+	sentences := []string{}
+	start := 0
+	for i, r := range normalized {
+		if r != '.' && r != '!' && r != '?' {
+			continue
+		}
+		end := i + len(string(r))
+		if end < len(normalized) && normalized[end] != ' ' {
+			continue
+		}
+		sentence := strings.TrimSpace(normalized[start:end])
+		if sentence != "" {
+			sentences = append(sentences, sentence)
+		}
+		start = end
+	}
+	if tail := strings.TrimSpace(normalized[start:]); tail != "" {
+		sentences = append(sentences, tail)
+	}
+	return sentences
+}
+
+func visibleDetailLines(lines []string, maxBodyHeight, offset int) []string {
+	total := len(lines)
+	if maxBodyHeight <= 0 || total <= maxBodyHeight {
+		return lines
+	}
+	offset = clampDetailOffset(offset, total)
+	available := maxBodyHeight
+	if offset > 0 {
+		available--
+	}
+	if available < 1 {
+		available = 1
+	}
+	end := min(offset+available, total)
+	if end < total && available > 1 {
+		available--
+		end = min(offset+available, total)
+	}
+
+	visible := make([]string, 0, available+2)
+	if offset > 0 {
+		visible = append(visible, renderScrollIndicator("↑", offset, "above"))
+	}
+	visible = append(visible, lines[offset:end]...)
+	if end < total {
+		visible = append(visible, renderScrollIndicator("↓", total-end, "more"))
+	}
+	return visible
+}
+
+func clampDetailOffset(offset, total int) int {
+	if offset < 0 || total <= 0 {
+		return 0
+	}
+	if offset >= total {
+		return total - 1
+	}
+	return offset
 }
 
 func detailRow(label, value string, width int) string {
 	prefix := label + ": "
-	wrapped := wrapText(value, width-len(prefix))
+	wrapped := WrapText(value, width-len(prefix))
 	if len(wrapped) == 0 {
 		wrapped = []string{""}
 	}
@@ -90,7 +182,7 @@ func phaseLabel(s data.ProgressStage) string {
 	}
 }
 
-func wrapText(s string, width int) []string {
+func WrapText(s string, width int) []string {
 	if width < 4 {
 		width = 4
 	}
@@ -106,7 +198,7 @@ func wrapText(s string, width int) []string {
 				lines = append(lines, current)
 				current = ""
 			}
-			lines = append(lines, splitLongWord(word, width)...)
+			lines = append(lines, SplitLongWord(word, width)...)
 			continue
 		}
 		if current == "" {
@@ -126,7 +218,7 @@ func wrapText(s string, width int) []string {
 	return lines
 }
 
-func splitLongWord(word string, width int) []string {
+func SplitLongWord(word string, width int) []string {
 	runes := []rune(word)
 	lines := []string{}
 	for len(runes) > width {