savepoint 1.0.4 → 1.0.7

package/internal/board/card_test.go

@@ -1,287 +0,0 @@
-package board
-
-import (
-	"strings"
-	"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, nil)
-	if !strings.Contains(got, "T002") {
-		t.Error("RenderCard missing short task ID")
-	}
-}
-
-func TestRenderCard_containsTitle(t *testing.T) {
-	task := data.Task{ID: "T1", Title: "My title", Stage: data.StageBuild}
-	got := RenderCard(task, 30, false, nil)
-	if !strings.Contains(got, "My title") {
-		t.Error("RenderCard missing task title")
-	}
-}
-
-func TestRenderCard_containsBuildGlyph(t *testing.T) {
-	task := data.Task{ID: "T1", Stage: data.StageBuild}
-	got := RenderCard(task, 30, false, nil)
-	if !strings.Contains(got, glyphBuild) {
-		t.Errorf("RenderCard missing build glyph %q", glyphBuild)
-	}
-}
-
-func TestRenderCard_containsTestGlyph(t *testing.T) {
-	task := data.Task{ID: "T1", Stage: data.StageTest}
-	got := RenderCard(task, 30, false, nil)
-	if !strings.Contains(got, glyphTest) {
-		t.Errorf("RenderCard missing test glyph %q", glyphTest)
-	}
-}
-
-func TestRenderCard_containsAuditGlyph(t *testing.T) {
-	task := data.Task{ID: "T1", Stage: data.StageAudit}
-	got := RenderCard(task, 30, false, nil)
-	if !strings.Contains(got, glyphAudit) {
-		t.Errorf("RenderCard missing audit glyph %q", glyphAudit)
-	}
-}
-
-func TestRenderCard_focusedDoesNotPanic(t *testing.T) {
-	task := data.Task{ID: "T1", Title: "hello", Stage: data.StageBuild}
-	got := RenderCard(task, 30, true, nil)
-	if got == "" {
-		t.Error("RenderCard focused returned empty string")
-	}
-}
-
-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, 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")
-	}
-	// 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, nil)
-	if strings.Contains(got, long) {
-		t.Error("RenderCard should truncate long ID")
-	}
-}
-
-func TestTruncate_shortString(t *testing.T) {
-	if truncate("hi", 10) != "hi" {
-		t.Error("truncate should not clip short string")
-	}
-}
-
-func TestTruncate_exactLength(t *testing.T) {
-	if truncate("hello", 5) != "hello" {
-		t.Error("truncate should not clip string at exact max")
-	}
-}
-
-func TestTruncate_clipsWithEllipsis(t *testing.T) {
-	got := truncate("hello", 4)
-	if got != "hel…" {
-		t.Errorf("truncate got %q, want %q", got, "hel…")
-	}
-}
-
-func TestTruncate_maxOne(t *testing.T) {
-	got := truncate("hello", 1)
-	if got != "…" {
-		t.Errorf("truncate(max=1) got %q, want %q", got, "…")
-	}
-}
-
-func TestRenderCard_defaultStageUsesBuildGlyph(t *testing.T) {
-	task := data.Task{ID: "T1", Stage: ""}
-	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 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")
-	}
-}
-
-func BenchmarkRenderCard_narrow(b *testing.B) {
-	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout", Stage: data.StageBuild}
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderCard(task, 24, false, nil)
-	}
-}
-
-func BenchmarkRenderCard_standard(b *testing.B) {
-	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout for the board view", Stage: data.StageTest}
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderCard(task, 40, false, nil)
-	}
-}
-
-func BenchmarkRenderCard_wide(b *testing.B) {
-	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout for the board view with extra details", Stage: data.StageAudit}
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderCard(task, 60, false, nil)
-	}
-}
-
-func BenchmarkRenderCard_focused(b *testing.B) {
-	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout", Stage: data.StageBuild}
-	router := &data.RouterState{Release: "v1", Epic: "E06", Task: "T004"}
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderCard(task, 40, true, router)
-	}
-}

package/internal/board/column.go

@@ -1,156 +0,0 @@
-package board
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/opencode/savepoint/internal/data"
-	"github.com/opencode/savepoint/internal/styles"
-)
-
-// 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))
-	if focused {
-		header = styles.ColumnTitleFocused.Render(header)
-	} else {
-		header = styles.ColumnTitle.Render(header)
-	}
-
-	lines := []string{header, strings.Repeat("─", inner)}
-	if len(tasks) == 0 {
-		lines = append(lines, styles.TaskItem.Render("(empty)"))
-	} else {
-		contentBudget := maxHeight - 2
-		if contentBudget < 1 {
-			contentBudget = 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})
-		}
-
-		// Standard window: fit as many cards as possible from the start of cardEntries.
-		reserveAbove := 0
-		if offset > 0 {
-			reserveAbove = 1
-		}
-		usedLines := reserveAbove
-		endIdx := 0
-		for endIdx < len(cardEntries) {
-			hasMore := (offset + endIdx + 1) < len(tasks)
-			bottomReserve := 0
-			if hasMore {
-				bottomReserve = 1
-			}
-			if usedLines+cardEntries[endIdx].lines+bottomReserve > contentBudget {
-				break
-			}
-			usedLines += cardEntries[endIdx].lines
-			endIdx++
-		}
-		if endIdx == 0 && len(cardEntries) > 0 {
-			endIdx = 1
-		}
-
-		// Determine what portion of cardEntries to render.
-		renderStart := 0
-		renderEnd := endIdx
-
-		focusedRelIdx := focusedTask - offset
-		if focused && focusedRelIdx >= 0 && focusedRelIdx < len(cardEntries) && focusedRelIdx >= endIdx {
-			// Focused task is beyond the standard window.
-			// Anchor viewport at focused task: fill backward to use remaining budget.
-			bottomCost := 0
-			if focusedTask+1 < len(tasks) {
-				bottomCost = 1
-			}
-			cardsLines := cardEntries[focusedRelIdx].lines
-			newStart := focusedRelIdx
-			for newStart > 0 {
-				prev := cardEntries[newStart-1]
-				topCost := 1
-				if offset+newStart-1 == 0 {
-					topCost = 0
-				}
-				if cardsLines+prev.lines+topCost+bottomCost > contentBudget {
-					break
-				}
-				cardsLines += prev.lines
-				newStart--
-			}
-			renderStart = newStart
-			renderEnd = focusedRelIdx + 1
-		}
-
-		effectiveOffset := offset + renderStart
-		if effectiveOffset > 0 {
-			lines = append(lines, renderScrollIndicator("↑", effectiveOffset, "above"))
-		}
-		for i := renderStart; i < renderEnd; i++ {
-			lines = append(lines, cardEntries[i].card)
-		}
-		if offset+renderEnd < len(tasks) {
-			remaining := len(tasks) - (offset + renderEnd)
-			lines = append(lines, renderScrollIndicator("↓", remaining, "more"))
-		}
-	}
-
-	content := strings.Join(lines, "\n")
-	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:
-		return "PLANNED"
-	case data.ColumnInProgress:
-		return "IN PROGRESS"
-	case data.ColumnDone:
-		return "DONE"
-	default:
-		return strings.ToUpper(string(col))
-	}
-}

package/internal/board/column_test.go

@@ -1,210 +0,0 @@
-package board
-
-import (
-	"fmt"
-	"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, 0, 0, false, nil)
-	if !strings.Contains(got, "PLANNED") {
-		t.Error("RenderColumn missing PLANNED label")
-	}
-}
-
-func TestRenderColumn_headerContainsCount(t *testing.T) {
-	tasks := []data.Task{{ID: "T1", Title: "Task one", Column: data.ColumnPlanned}}
-	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, 0, 0, false, nil)
-	if !strings.Contains(got, "(empty)") {
-		t.Error("RenderColumn missing (empty) for empty column")
-	}
-}
-
-func TestRenderColumn_focusedDoesNotPanic(t *testing.T) {
-	tasks := []data.Task{{ID: "T1", Column: data.ColumnInProgress}}
-	got := RenderColumn(tasks, data.ColumnInProgress, 30, 0, 0, 0, true, nil)
-	if got == "" {
-		t.Error("RenderColumn returned empty string for focused column")
-	}
-}
-
-func TestRenderColumn_allColumnTitles(t *testing.T) {
-	cases := []struct {
-		col   data.ColumnType
-		label string
-	}{
-		{data.ColumnPlanned, "PLANNED"},
-		{data.ColumnInProgress, "IN PROGRESS"},
-		{data.ColumnDone, "DONE"},
-	}
-	for _, tc := range cases {
-		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)
-		}
-	}
-}
-
-func TestRenderColumn_taskTitleRendered(t *testing.T) {
-	tasks := []data.Task{{ID: "T2", Title: "Build it", Column: data.ColumnPlanned}}
-	got := RenderColumn(tasks, data.ColumnPlanned, 30, 0, 0, 0, false, nil)
-	if !strings.Contains(got, "Build it") {
-		t.Error("RenderColumn missing task title")
-	}
-}
-
-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, 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 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, 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)
-	}
-}
-
-func BenchmarkRenderColumn_empty(b *testing.B) {
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderColumn(nil, data.ColumnPlanned, 30, 20, 0, 0, false, nil)
-	}
-}
-
-func BenchmarkRenderColumn_fewTasks(b *testing.B) {
-	tasks := []data.Task{
-		{ID: "E06/T001", Title: "First task", Column: data.ColumnPlanned, Stage: data.StageBuild},
-		{ID: "E06/T002", Title: "Second task", Column: data.ColumnPlanned, Stage: data.StageTest},
-		{ID: "E06/T003", Title: "Third task", Column: data.ColumnPlanned, Stage: data.StageAudit},
-	}
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderColumn(tasks, data.ColumnPlanned, 30, 20, 0, 0, false, nil)
-	}
-}
-
-func BenchmarkRenderColumn_manyTasks(b *testing.B) {
-	tasks := make([]data.Task, 20)
-	stages := []data.ProgressStage{data.StageBuild, data.StageTest, data.StageAudit}
-	for i := range tasks {
-		tasks[i] = data.Task{
-			ID:      fmt.Sprintf("E06/T%03d", i+1),
-			Title:   fmt.Sprintf("Task number %d with a reasonable length title", i+1),
-			Column:  data.ColumnPlanned,
-			Stage:   stages[i%3],
-			Release: "v1.1",
-		}
-	}
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderColumn(tasks, data.ColumnPlanned, 40, 24, 0, 0, false, nil)
-	}
-}
-
-func BenchmarkRenderColumn_focused(b *testing.B) {
-	tasks := []data.Task{
-		{ID: "E06/T001", Title: "First task", Column: data.ColumnInProgress, Stage: data.StageBuild},
-		{ID: "E06/T002", Title: "Second task", Column: data.ColumnInProgress, Stage: data.StageTest},
-		{ID: "E06/T003", Title: "Third task", Column: data.ColumnInProgress, Stage: data.StageAudit},
-	}
-	router := &data.RouterState{Release: "v1", Epic: "E06", Task: "T001"}
-	b.ReportAllocs()
-	for b.Loop() {
-		RenderColumn(tasks, data.ColumnInProgress, 40, 20, 0, 0, true, router)
-	}
-}
-
-func TestRenderColumn_focusedLastTaskVisibleWhenScrolled(t *testing.T) {
-	// When scrolled (offset > 0) the top scroll indicator steals 1 line.
-	// The focused last-in-page task must still appear, not be cut off.
-	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},
-		{ID: "T5", Title: "Task five", Column: data.ColumnPlanned},
-	}
-	// offset=2, focusedTask=4 (last task), maxHeight=14 (24-line terminal)
-	got := RenderColumn(tasks, data.ColumnPlanned, 30, 14, 2, 4, true, nil)
-	if !strings.Contains(got, "Task five") {
-		t.Errorf("focused last task must be visible when scrolled, got:\n%s", got)
-	}
-	if !strings.Contains(got, "↑") {
-		t.Error("scroll indicator above must appear when offset > 0")
-	}
-}

package/internal/board/debug.go

@@ -1,26 +0,0 @@
-package board
-
-import (
-	"fmt"
-	"os"
-	"sync/atomic"
-)
-
-var debugEnabled atomic.Bool
-
-// SetDebug enables or disables debug logging for the board package.
-func SetDebug(enabled bool) {
-	debugEnabled.Store(enabled)
-}
-
-// DebugEnabled reports whether debug logging is active.
-func DebugEnabled() bool {
-	return debugEnabled.Load()
-}
-
-func debugf(format string, args ...any) {
-	if !debugEnabled.Load() {
-		return
-	}
-	fmt.Fprintf(os.Stderr, "[savepoint debug] "+format+"\n", args...)
-}