savepoint 1.0.1 → 1.0.3

package/internal/board/help.go

@@ -23,6 +23,7 @@ func RenderHelp(width int) string {
 		helpRow("enter", "open task detail / select item"),
 		helpRow("e", "open epic selector on narrow screens"),
 		helpRow("r", "open release selector"),
+		helpRow("p", "mark focused task as priority"),
 		helpRow("up / k", "move selector up"),
 		helpRow("down / j", "move selector down"),
 		helpRow("?", "open help"),

package/internal/board/help_test.go

@@ -22,6 +22,7 @@ func TestRenderHelp_containsShortcuts(t *testing.T) {
 		"enter",
 		"e",
 		"r",
+		"p",
 		"up / k",
 		"down / j",
 		"?",

package/internal/board/integration_test.go

@@ -0,0 +1,266 @@
+package board
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/testutil"
+)
+
+// writeTaskWithBody creates a task file with a body section to verify content preservation.
+func writeTaskWithBody(t *testing.T, root, release, epic, taskSlug string, column data.ColumnType, body string) string {
+	t.Helper()
+	tf := testutil.TaskFixture{
+		Slug:      taskSlug,
+		Release:   release,
+		Status:    string(column),
+		Objective: "Test task",
+		Body:      body,
+	}
+	if column == data.ColumnInProgress {
+		tf.Phase = "build"
+	}
+	testutil.WriteTask(t, root, release, epic, tf)
+	return filepath.Join(root, "releases", release, "epics", epic, "tasks", taskSlug+".md")
+}
+
+// TestBoardPipeline_endToEnd loads a real project from disk and renders the full board view.
+func TestBoardPipeline_endToEnd(t *testing.T) {
+	projectRoot := t.TempDir()
+	savepointRoot := filepath.Join(projectRoot, ".savepoint")
+	testutil.WriteRouter(t, savepointRoot, "task-building", "v1", "E01-init", "", "test")
+	writeTask(t, savepointRoot, "v1", "E01-init", "T001-scaffold", data.ColumnPlanned)
+	writeTask(t, savepointRoot, "v1", "E01-init", "T002-validate", data.ColumnInProgress)
+	writeTask(t, savepointRoot, "v1", "E01-init", "T003-done-task", data.ColumnDone)
+
+	model, err := newProjectModel(projectRoot, "", "")
+	if err != nil {
+		t.Fatalf("newProjectModel: %v", err)
+	}
+	if model.Watcher != nil {
+		t.Cleanup(func() { model.Watcher.Close() })
+	}
+
+	model.Width = 120
+	model.Height = 40
+	view := model.View()
+
+	for _, want := range []string{"PLANNED", "IN PROGRESS", "DONE", "T001", "T002", "T003"} {
+		if !strings.Contains(view, want) {
+			t.Errorf("board view missing %q", want)
+		}
+	}
+}
+
+// TestRunPlainOutput_endToEnd calls runPlainOutput against a real temp project root.
+func TestRunPlainOutput_endToEnd(t *testing.T) {
+	projectRoot := t.TempDir()
+	savepointRoot := filepath.Join(projectRoot, ".savepoint")
+	testutil.WriteRouter(t, savepointRoot, "task-building", "v1", "E01-init", "", "test")
+	writeTask(t, savepointRoot, "v1", "E01-init", "T001-scaffold", data.ColumnPlanned)
+	writeTask(t, savepointRoot, "v1", "E01-init", "T002-validate", data.ColumnDone)
+
+	model, err := newProjectModel(projectRoot, "", "")
+	if err != nil {
+		t.Fatalf("newProjectModel: %v", err)
+	}
+	if model.Watcher != nil {
+		t.Cleanup(func() { model.Watcher.Close() })
+	}
+
+	out := RenderPlainTable(model)
+
+	if !strings.Contains(out, plainNonTTYWarning) {
+		t.Error("plain output missing non-TTY warning")
+	}
+	for _, want := range []string{"PLANNED", "DONE", "T001-scaffold", "T002-validate"} {
+		if !strings.Contains(out, want) {
+			t.Errorf("plain output missing %q", want)
+		}
+	}
+}
+
+// TestStatusWrite_preservesTaskBody advances a task via space key and verifies the body text is unchanged.
+func TestStatusWrite_preservesTaskBody(t *testing.T) {
+	root := t.TempDir()
+	body := "## Acceptance Criteria\n\n- [ ] thing one\n- [ ] thing two\n"
+	path := writeTaskWithBody(t, root, "v1", "E01-init", "T001-scaffold", data.ColumnPlanned, body)
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	task := data.Task{
+		ID:     "E01-init/T001-scaffold",
+		Column: data.ColumnPlanned,
+		Path:   path,
+		Mtime:  fi.ModTime(),
+	}
+
+	m := NewModel([]data.Task{task}, "v1", "E01-init")
+	m.FocusedColumn = data.ColumnPlanned
+
+	got, cmd := m.Update(tea.KeyMsg{Type: tea.KeySpace})
+	msg := cmd()
+	got2, _ := got.Update(msg)
+	updated := requireModel(t, got2)
+
+	if updated.AllTasks[0].Column != data.ColumnInProgress {
+		t.Errorf("Column = %q, want in_progress", updated.AllTasks[0].Column)
+	}
+
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(raw), body) {
+		t.Errorf("task body was altered after status write; got:\n%s", raw)
+	}
+}
+
+// TestMtimeConflict_directDetection verifies WriteTaskStatus returns ErrMtimeConflict on mtime mismatch.
+func TestMtimeConflict_directDetection(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "T001.md")
+	content := "---\nid: E01/T001\nstatus: planned\nphase: build\n---\n\n# Task\n"
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	task := &data.Task{
+		ID:     "E01/T001",
+		Column: data.ColumnInProgress,
+		Stage:  data.StageBuild,
+	}
+	staleTime := time.Now().Add(-time.Hour)
+	err := data.WriteTaskStatus(path, task, staleTime)
+	if err != data.ErrMtimeConflict {
+		t.Errorf("WriteTaskStatus with stale mtime = %v, want ErrMtimeConflict", err)
+	}
+}
+
+// TestMtimeConflict_boardWarns verifies the board surfaces an mtime conflict instead of overwriting external edits.
+func TestMtimeConflict_boardWarns(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "T001.md")
+	content := "---\nid: E01/T001\nstatus: in_progress\nphase: build\n---\n\n# Task\n"
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+	fi, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	task := data.Task{
+		ID:     "E01/T001",
+		Column: data.ColumnInProgress,
+		Stage:  data.StageBuild,
+		Path:   path,
+		Mtime:  fi.ModTime().Add(-time.Minute), // intentionally stale
+	}
+	m := NewModel([]data.Task{task}, "v1", "E01")
+	m.FocusedColumn = data.ColumnInProgress
+
+	got, cmd := m.Update(tea.KeyMsg{Type: tea.KeySpace})
+	msg := cmd()
+	got2, _ := got.Update(msg)
+	updated := requireModel(t, got2)
+
+	if !strings.Contains(updated.StatusMessage, "mtime conflict") {
+		t.Errorf("StatusMessage = %q, want mtime conflict warning", updated.StatusMessage)
+	}
+
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(raw), "phase: build") {
+		t.Errorf("task file was overwritten despite mtime conflict:\n%s", raw)
+	}
+}
+
+// TestReleaseFilter_showsOnlyMatchingRelease verifies the --release flag filters tasks.
+func TestReleaseFilter_showsOnlyMatchingRelease(t *testing.T) {
+	projectRoot := t.TempDir()
+	savepointRoot := filepath.Join(projectRoot, ".savepoint")
+	testutil.WriteRouter(t, savepointRoot, "task-building", "v1", "E01-init", "", "test")
+	writeTask(t, savepointRoot, "v1", "E01-init", "T001-v1-task", data.ColumnPlanned)
+	writeTask(t, savepointRoot, "v2", "E01-init", "T001-v2-task", data.ColumnPlanned)
+
+	model, err := newProjectModel(projectRoot, "v2", "")
+	if err != nil {
+		t.Fatalf("newProjectModel: %v", err)
+	}
+	if model.Watcher != nil {
+		t.Cleanup(func() { model.Watcher.Close() })
+	}
+
+	if model.SelectedRelease != "v2" {
+		t.Errorf("SelectedRelease = %q, want v2", model.SelectedRelease)
+	}
+	planned := model.Tasks[data.ColumnPlanned]
+	for _, task := range planned {
+		if task.Release != "v2" {
+			t.Errorf("task %q has release %q, want v2 only", task.ID, task.Release)
+		}
+	}
+}
+
+// TestEpicFilter_showsOnlyMatchingEpic verifies the --epic flag filters tasks.
+func TestEpicFilter_showsOnlyMatchingEpic(t *testing.T) {
+	projectRoot := t.TempDir()
+	savepointRoot := filepath.Join(projectRoot, ".savepoint")
+	testutil.WriteRouter(t, savepointRoot, "task-building", "v1", "E01-init", "", "test")
+	writeTask(t, savepointRoot, "v1", "E01-init", "T001-alpha", data.ColumnPlanned)
+	writeTask(t, savepointRoot, "v1", "E02-build", "T001-beta", data.ColumnPlanned)
+
+	model, err := newProjectModel(projectRoot, "v1", "E02-build")
+	if err != nil {
+		t.Fatalf("newProjectModel: %v", err)
+	}
+	if model.Watcher != nil {
+		t.Cleanup(func() { model.Watcher.Close() })
+	}
+
+	if model.SelectedEpic != "E02-build" {
+		t.Errorf("SelectedEpic = %q, want E02-build", model.SelectedEpic)
+	}
+	planned := model.Tasks[data.ColumnPlanned]
+	for _, task := range planned {
+		if task.Epic != "E02-build" {
+			t.Errorf("task %q has epic %q, want E02-build only", task.ID, task.Epic)
+		}
+	}
+}
+
+// TestDetailPane_opensOnEnter verifies enter key opens the detail overlay.
+func TestDetailPane_opensOnEnter(t *testing.T) {
+	tasks := []data.Task{{ID: "E01/T001", Title: "Scaffold init", Column: data.ColumnPlanned}}
+	m := NewModel(tasks, "v1", "E01")
+	m.FocusedColumn = data.ColumnPlanned
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	updated := requireModel(t, got)
+
+	if updated.Overlay != OverlayDetail {
+		t.Errorf("Overlay = %q, want %q", updated.Overlay, OverlayDetail)
+	}
+}
+
+// TestDetailPane_escClosesOverlay verifies esc dismisses the detail overlay.
+func TestDetailPane_escClosesOverlay(t *testing.T) {
+	m := NewModel(nil, "v1", "E01")
+	m.Overlay = OverlayDetail
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	updated := requireModel(t, got)
+
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q after esc, want none", updated.Overlay)
+	}
+}

package/internal/board/interfaces.go

@@ -0,0 +1,65 @@
+package board
+
+import "github.com/opencode/savepoint/internal/data"
+
+// taskDiscoverer provides project traversal for board loading.
+type taskDiscoverer interface {
+	FindSavepointRoot(start string) (string, error)
+	ListReleases(root string) ([]data.ReleaseInfo, error)
+	ListEpics(root, release string) ([]data.EpicInfo, error)
+	ListTasks(root, release, epic string) ([]data.TaskInfo, error)
+}
+
+// taskParser parses Savepoint frontmatter and task files for board loading.
+type taskParser interface {
+	ParseFrontmatter(content string) (map[string]any, error)
+	ParseTaskFile(path string, content string) (*data.Task, error)
+}
+
+// configReader reads board display configuration.
+type configReader interface {
+	Read(path string) (*data.Config, error)
+}
+
+// routerReader parses router state from router.md content.
+type routerReader interface {
+	ReadState(content string) (*data.RouterState, error)
+}
+
+// ModelDependencies contains board data-access dependencies.
+type ModelDependencies struct {
+	Discoverer   taskDiscoverer
+	Parser       taskParser
+	ConfigReader configReader
+	RouterReader routerReader
+}
+
+func defaultModelDependencies() ModelDependencies {
+	return ModelDependencies{
+		Discoverer:   data.NewDiscover(),
+		Parser:       data.NewParser(),
+		ConfigReader: data.NewConfigReader(),
+		RouterReader: data.NewRouterReader(),
+	}
+}
+
+func modelDependencies(overrides []ModelDependencies) ModelDependencies {
+	deps := defaultModelDependencies()
+	if len(overrides) == 0 {
+		return deps
+	}
+	override := overrides[0]
+	if override.Discoverer != nil {
+		deps.Discoverer = override.Discoverer
+	}
+	if override.Parser != nil {
+		deps.Parser = override.Parser
+	}
+	if override.ConfigReader != nil {
+		deps.ConfigReader = override.ConfigReader
+	}
+	if override.RouterReader != nil {
+		deps.RouterReader = override.RouterReader
+	}
+	return deps
+}

package/internal/board/interfaces_test.go

@@ -0,0 +1,114 @@
+package board
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/testutil"
+)
+
+type stubBoardDiscoverer struct {
+	root      string
+	releases  []data.ReleaseInfo
+	epics     map[string][]data.EpicInfo
+	tasks     map[string][]data.TaskInfo
+	findCalls int
+}
+
+func (d *stubBoardDiscoverer) FindSavepointRoot(start string) (string, error) {
+	d.findCalls++
+	return d.root, nil
+}
+
+func (d *stubBoardDiscoverer) ListReleases(root string) ([]data.ReleaseInfo, error) {
+	return d.releases, nil
+}
+
+func (d *stubBoardDiscoverer) ListEpics(root, release string) ([]data.EpicInfo, error) {
+	return d.epics[release], nil
+}
+
+func (d *stubBoardDiscoverer) ListTasks(root, release, epic string) ([]data.TaskInfo, error) {
+	return d.tasks[release+"/"+epic], nil
+}
+
+type countingBoardParser struct {
+	parser           *data.Parser
+	frontmatterCalls int
+	taskFileCalls    int
+}
+
+func (p *countingBoardParser) ParseFrontmatter(content string) (map[string]any, error) {
+	p.frontmatterCalls++
+	return p.parser.ParseFrontmatter(content)
+}
+
+func (p *countingBoardParser) ParseTaskFile(path string, content string) (*data.Task, error) {
+	p.taskFileCalls++
+	return p.parser.ParseTaskFile(path, content)
+}
+
+type stubBoardRouterReader struct {
+	state *data.RouterState
+	calls int
+}
+
+func (r *stubBoardRouterReader) ReadState(content string) (*data.RouterState, error) {
+	r.calls++
+	return r.state, nil
+}
+
+func TestNewProjectModelUsesInjectedInterfaces(t *testing.T) {
+	projectRoot := t.TempDir()
+	savepointRoot := filepath.Join(projectRoot, ".savepoint")
+	epicPath := filepath.Join(savepointRoot, "releases", "v9", "epics", "E01-mock")
+	taskPath := filepath.Join(epicPath, "tasks", "T001-mock.md")
+
+	testutil.WriteFile(t, filepath.Join(savepointRoot, "router.md"), "# router")
+	testutil.WriteFile(t, filepath.Join(epicPath, "E01-Detail.md"), "---\ntype: epic-design\nstatus: planned\n---\n\n# Epic\n")
+	testutil.WriteFile(t, taskPath, "---\nid: E01-mock/T001-mock\nstatus: planned\nobjective: Mock task\ndepends_on: []\n---\n\n# Task\n")
+
+	discoverer := &stubBoardDiscoverer{
+		root: savepointRoot,
+		releases: []data.ReleaseInfo{{
+			ID:   "v9",
+			Path: filepath.Join(savepointRoot, "releases", "v9"),
+		}},
+		epics: map[string][]data.EpicInfo{
+			"v9": {{ID: "E01-mock", Path: epicPath}},
+		},
+		tasks: map[string][]data.TaskInfo{
+			"v9/E01-mock": {{ID: "T001-mock", Path: taskPath}},
+		},
+	}
+	parser := &countingBoardParser{parser: data.NewParser()}
+	router := &stubBoardRouterReader{state: &data.RouterState{
+		State:   "task-building",
+		Release: "v9",
+		Epic:    "E01-mock",
+		Task:    "E01-mock/T001-mock",
+	}}
+
+	model, err := newProjectModelWithDependencies(projectRoot, "", "", ModelDependencies{
+		Discoverer:   discoverer,
+		Parser:       parser,
+		RouterReader: router,
+	})
+	if err != nil {
+		t.Fatalf("newProjectModelWithDependencies() error = %v", err)
+	}
+
+	if discoverer.findCalls != 1 {
+		t.Fatalf("FindSavepointRoot calls = %d, want 1", discoverer.findCalls)
+	}
+	if router.calls != 1 {
+		t.Fatalf("ReadState calls = %d, want 1", router.calls)
+	}
+	if parser.frontmatterCalls != 1 || parser.taskFileCalls != 1 {
+		t.Fatalf("parser calls = frontmatter:%d task:%d, want 1 each", parser.frontmatterCalls, parser.taskFileCalls)
+	}
+	if got := model.Tasks[data.ColumnPlanned][0].ID; got != "E01-mock/T001-mock" {
+		t.Fatalf("loaded task = %q, want injected task", got)
+	}
+}

package/internal/board/io.go

@@ -0,0 +1,93 @@
+package board
+
+import (
+	"os"
+	"path/filepath"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func writeRouterTaskCmd(root string, task data.Task, reader routerReader) tea.Cmd {
+	return func() tea.Msg {
+		routerPath := filepath.Join(root, "router.md")
+		fi, err := os.Stat(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		content, err := os.ReadFile(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state, err := reader.ReadState(string(content))
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state.Release = task.Release
+		state.Epic = task.Epic
+		state.State = "task-building"
+		state.Task = task.ID
+		state.NextAction = "Build " + task.ID + "."
+		if err := data.WriteRouterState(root, state, fi.ModTime()); err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		message := "Router set to " + task.Release + " " + task.Epic + "/" + shortID(task.ID)
+		return routerWriteMsg{message: message, state: state, taskID: task.ID}
+	}
+}
+
+func writeRouterReleaseEpicCmd(root, selectedEpic, selectedRelease string, reader routerReader) tea.Cmd {
+	return func() tea.Msg {
+		routerPath := filepath.Join(root, "router.md")
+		fi, err := os.Stat(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		content, err := os.ReadFile(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state, err := reader.ReadState(string(content))
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state.Epic = shortID(selectedEpic)
+		state.Release = selectedRelease
+		if err := data.WriteRouterState(root, state, fi.ModTime()); err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		return routerWriteMsg{state: state}
+	}
+}
+
+func writeTaskStatusCmd(orig, next data.Task, expectedMtime time.Time, prefix string) tea.Cmd {
+	return func() tea.Msg {
+		if err := data.WriteTaskStatus(next.Path, &next, expectedMtime); err != nil {
+			return errorMsg{message: taskWriteErrorMessage(err)}
+		}
+		fi, err := os.Stat(next.Path)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		next.Mtime = fi.ModTime()
+		return taskWriteMsg{prefix: prefix, next: next}
+	}
+}
+
+func readEpicDetailCmd(epicDir, shortIDStr string) tea.Cmd {
+	return func() tea.Msg {
+		content := readEpicDetailFile(epicDir, shortIDStr)
+		return epicDetailMsg{content: content}
+	}
+}
+
+func readEpicAuditCmd(epicDir, shortIDStr string) tea.Cmd {
+	return func() tea.Msg {
+		raw, err := os.ReadFile(filepath.Join(epicDir, shortIDStr+"-Audit.md"))
+		if err != nil {
+			return auditContentMsg{content: "(no audit available)"}
+		}
+		return auditContentMsg{content: string(raw)}
+	}
+}

package/internal/board/layout.go

@@ -3,7 +3,8 @@ package board
 const (
 	colOverhead = 4 // rounded border (1) + padding (1) each side
 
-	minColWidth = 10
+	minColWidth      = 10
+	minContentHeight = 5
 
 	epicPanelWidth    = 28
 	epicPanelOverhead = 4
@@ -20,6 +21,7 @@ type Layout struct {
 	EpicPanelWidth   int
 	ColCount         int
 	ColWidths        []int
+	ContentHeight    int
 }
 
 // CalculateLayout returns the board layout for the given terminal dimensions.
@@ -27,7 +29,12 @@ type Layout struct {
 //   - >=120 cols: epic panel (28w) + 3 columns
 //   - 80–119 cols: 3 columns only
 //   - <80 cols: 1 column
-func CalculateLayout(width, _ int) Layout {
+func CalculateLayout(width, height int) Layout {
+	return CalculateLayoutWithChrome(width, height, 0)
+}
+
+func CalculateLayoutWithChrome(width, height, extraHeaderLines int) Layout {
+	contentHeight := max(height-10-extraHeaderLines, minContentHeight)
 	inner := width - boardFrameOverhead
 	switch {
 	case width >= breakpointWide:
@@ -38,6 +45,7 @@ func CalculateLayout(width, _ int) Layout {
 			EpicPanelWidth:   epicPanelWidth,
 			ColCount:         3,
 			ColWidths:        []int{cw, cw, cw},
+			ContentHeight:    contentHeight,
 		}
 	case width >= breakpointNarrow:
 		available := inner - 3*colOverhead
@@ -46,6 +54,7 @@ func CalculateLayout(width, _ int) Layout {
 			EpicPanelVisible: false,
 			ColCount:         3,
 			ColWidths:        []int{cw, cw, cw},
+			ContentHeight:    contentHeight,
 		}
 	default:
 		cw := max(inner-colOverhead, minColWidth)
@@ -53,6 +62,7 @@ func CalculateLayout(width, _ int) Layout {
 			EpicPanelVisible: false,
 			ColCount:         1,
 			ColWidths:        []int{cw},
+			ContentHeight:    contentHeight,
 		}
 	}
 }

package/internal/board/layout_test.go

@@ -22,6 +22,9 @@ func TestCalculateLayout_wide(t *testing.T) {
 			t.Errorf("ColWidths[%d] = %d, want 24", i, w)
 		}
 	}
+	if l.ContentHeight != 30 {
+		t.Errorf("ContentHeight = %d, want 30", l.ContentHeight)
+	}
 }
 
 func TestCalculateLayout_medium(t *testing.T) {
@@ -66,6 +69,20 @@ func TestCalculateLayout_tinyWidth_floorsAtMinColWidth(t *testing.T) {
 	}
 }
 
+func TestCalculateLayout_tinyHeight_floorsAtMinContentHeight(t *testing.T) {
+	l := CalculateLayout(100, 8)
+	if l.ContentHeight != minContentHeight {
+		t.Errorf("ContentHeight = %d, want %d", l.ContentHeight, minContentHeight)
+	}
+}
+
+func TestCalculateLayoutWithChrome_accountsForExtraHeaderLine(t *testing.T) {
+	l := CalculateLayoutWithChrome(120, 40, 1)
+	if l.ContentHeight != 29 {
+		t.Errorf("ContentHeight = %d, want 29", l.ContentHeight)
+	}
+}
+
 func TestCalculateLayout_breakpointBoundaries(t *testing.T) {
 	cases := []struct {
 		width        int