savepoint 1.0.2 → 1.0.4

package/internal/board/epic_panel_test.go

@@ -1,6 +1,8 @@
 package board
 
 import (
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -9,21 +11,21 @@ import (
 )
 
 func TestRenderEpicSidebar_containsEpicsHeader(t *testing.T) {
-	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28, false, 0, nil)
+	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28, false, 0, nil, 999)
 	if !strings.Contains(got, "EPICS") {
 		t.Error("RenderEpicSidebar missing EPICS header")
 	}
 }
 
 func TestRenderEpicSidebar_activeEpicMarked(t *testing.T) {
-	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28, false, 0, nil)
+	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28, false, 0, nil, 999)
 	if !strings.Contains(got, epicActiveMarker) {
 		t.Errorf("RenderEpicSidebar missing active marker %q", epicActiveMarker)
 	}
 }
 
 func TestRenderEpicSidebar_focusedCursorMarked(t *testing.T) {
-	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28, true, 1, nil)
+	got := RenderEpicSidebar([]string{"E01", "E02"}, "E01", 28, true, 1, nil, 999)
 	if !strings.Contains(got, epicActiveMarker+"   E02") {
 		t.Errorf("RenderEpicSidebar focused cursor missing marker, got %q", got)
 	}
@@ -31,7 +33,7 @@ func TestRenderEpicSidebar_focusedCursorMarked(t *testing.T) {
 
 func TestRenderEpicSidebar_allEpicsPresent(t *testing.T) {
 	epics := []string{"E01-foo", "E02-bar", "E03-baz"}
-	got := RenderEpicSidebar(epics, "E01-foo", 32, false, 0, nil)
+	got := RenderEpicSidebar(epics, "E01-foo", 32, false, 0, nil, 999)
 	for _, e := range epics {
 		if !strings.Contains(got, e) {
 			t.Errorf("RenderEpicSidebar missing epic %q", e)
@@ -40,14 +42,14 @@ func TestRenderEpicSidebar_allEpicsPresent(t *testing.T) {
 }
 
 func TestRenderEpicSidebar_emptyEpicsFallback(t *testing.T) {
-	got := RenderEpicSidebar(nil, "E03", 28, false, 0, nil)
+	got := RenderEpicSidebar(nil, "E03", 28, false, 0, nil, 999)
 	if !strings.Contains(got, "E03") {
 		t.Error("RenderEpicSidebar with empty list should show selected epic")
 	}
 }
 
 func TestRenderEpicSidebar_emptyBothShowsNone(t *testing.T) {
-	got := RenderEpicSidebar(nil, "", 28, false, 0, nil)
+	got := RenderEpicSidebar(nil, "", 28, false, 0, nil, 999)
 	if !strings.Contains(got, "(none)") {
 		t.Error("RenderEpicSidebar with no epics and no selected should show (none)")
 	}
@@ -81,22 +83,22 @@ func TestRenderEpicDropdown_emptyShowsNone(t *testing.T) {
 	}
 }
 
-func TestEpicIndex_found(t *testing.T) {
+func TestSliceIndex_found(t *testing.T) {
 	epics := []string{"E01", "E02", "E03"}
-	if got := epicIndex(epics, "E02"); got != 1 {
-		t.Errorf("epicIndex = %d, want 1", got)
+	if got := sliceIndex(epics, "E02"); got != 1 {
+		t.Errorf("sliceIndex = %d, want 1", got)
 	}
 }
 
-func TestEpicIndex_notFound(t *testing.T) {
-	if got := epicIndex([]string{"E01"}, "E99"); got != 0 {
-		t.Errorf("epicIndex not-found = %d, want 0", got)
+func TestSliceIndex_notFound(t *testing.T) {
+	if got := sliceIndex([]string{"E01"}, "E99"); got != 0 {
+		t.Errorf("sliceIndex not-found = %d, want 0", got)
 	}
 }
 
-func TestEpicIndex_empty(t *testing.T) {
-	if got := epicIndex(nil, "E01"); got != 0 {
-		t.Errorf("epicIndex empty = %d, want 0", got)
+func TestSliceIndex_empty(t *testing.T) {
+	if got := sliceIndex(nil, "E01"); got != 0 {
+		t.Errorf("sliceIndex empty = %d, want 0", got)
 	}
 }
 
@@ -567,7 +569,7 @@ func TestView_epicDetailOverlayNoContent(t *testing.T) {
 
 func TestRenderEpicDetail_stripsMarkdownHeadings(t *testing.T) {
 	content := "---\ntype: epic-design\n---\n# Epic E01\n\n## Purpose\nDoes things."
-	got := RenderEpicDetail("E01-test", content, 60, 40, 0)
+	got := RenderEpicDetail("E01-test", content, 60, 40, 0, 0)
 	if !strings.Contains(got, "EPIC DETAIL") {
 		t.Error("RenderEpicDetail missing EPIC DETAIL header")
 	}
@@ -577,8 +579,291 @@ func TestRenderEpicDetail_stripsMarkdownHeadings(t *testing.T) {
 }
 
 func TestRenderEpicDetail_noDetailFallback(t *testing.T) {
-	got := RenderEpicDetail("E01-test", "(no detail available)", 60, 40, 0)
+	got := RenderEpicDetail("E01-test", "(no detail available)", 60, 40, 0, 0)
 	if !strings.Contains(got, "no detail available") {
 		t.Error("RenderEpicDetail fallback message missing")
 	}
 }
+
+func TestRenderEpicDetail_tabIndicatorDetailActive(t *testing.T) {
+	got := RenderEpicDetail("E01-test", "content", 60, 40, 0, 0)
+	if !strings.Contains(got, "DETAIL [1]") {
+		t.Error("RenderEpicDetail tab=0: missing DETAIL [1] indicator")
+	}
+	if !strings.Contains(got, "AUDIT [2]") {
+		t.Error("RenderEpicDetail tab=0: missing AUDIT [2] indicator")
+	}
+}
+
+func TestRenderEpicDetail_tabIndicatorAuditActive(t *testing.T) {
+	got := RenderEpicDetail("E01-test", "content", 60, 40, 0, 1)
+	if !strings.Contains(got, "DETAIL [1]") {
+		t.Error("RenderEpicDetail tab=1: missing DETAIL [1] indicator")
+	}
+	if !strings.Contains(got, "AUDIT [2]") {
+		t.Error("RenderEpicDetail tab=1: missing AUDIT [2] indicator")
+	}
+}
+
+func TestRenderEpicAuditTab_header(t *testing.T) {
+	got := RenderEpicAuditTab("E06-test", "# Audit\n\n## Main Findings\nAll good.", 60, 40, 0, 1)
+	if !strings.Contains(got, "EPIC AUDIT") {
+		t.Error("RenderEpicAuditTab missing EPIC AUDIT header")
+	}
+}
+
+func TestRenderEpicAuditTab_noContent(t *testing.T) {
+	got := RenderEpicAuditTab("E06-test", "(no audit available)", 60, 40, 0, 1)
+	if !strings.Contains(got, "no audit available") {
+		t.Error("RenderEpicAuditTab fallback message missing")
+	}
+}
+
+func TestRenderEpicAuditTab_emptyContent(t *testing.T) {
+	got := RenderEpicAuditTab("E06-test", "", 60, 40, 0, 1)
+	if !strings.Contains(got, "no audit available") {
+		t.Error("RenderEpicAuditTab empty content should show fallback")
+	}
+}
+
+func TestRenderEpicAuditTab_stripsFrontmatter(t *testing.T) {
+	content := "---\ntype: audit\n---\n# E06 Audit\n\n## Main Findings\nLooks good."
+	got := RenderEpicAuditTab("E06-test", content, 60, 40, 0, 1)
+	if strings.Contains(got, "type: audit") {
+		t.Error("RenderEpicAuditTab should strip frontmatter")
+	}
+	if !strings.Contains(got, "EPIC AUDIT") {
+		t.Error("RenderEpicAuditTab missing header after frontmatter strip")
+	}
+}
+
+func TestRenderEpicAuditTab_checkboxDonePresent(t *testing.T) {
+	content := "## Code Style Review\n- [x] One job per file\n- [ ] One-sentence functions"
+	got := RenderEpicAuditTab("E06-test", content, 60, 40, 0, 1)
+	if !strings.Contains(got, "One job per file") {
+		t.Error("RenderEpicAuditTab missing done checkbox text")
+	}
+	if !strings.Contains(got, "One-sentence functions") {
+		t.Error("RenderEpicAuditTab missing undone checkbox text")
+	}
+}
+
+func TestRenderEpicAuditTab_scrollFooter(t *testing.T) {
+	got := RenderEpicAuditTab("E06-test", "# Audit", 60, 40, 0, 1)
+	if !strings.Contains(got, "esc:close") {
+		t.Error("RenderEpicAuditTab missing esc:close footer")
+	}
+}
+
+func TestRenderEpicAuditTab_tabIndicator(t *testing.T) {
+	got := RenderEpicAuditTab("E06-test", "# Audit", 60, 40, 0, 1)
+	if !strings.Contains(got, "DETAIL [1]") {
+		t.Error("RenderEpicAuditTab missing DETAIL [1] indicator")
+	}
+	if !strings.Contains(got, "AUDIT [2]") {
+		t.Error("RenderEpicAuditTab missing AUDIT [2] indicator")
+	}
+}
+
+func TestRenderEpicAuditTab_mainFindingsVisible(t *testing.T) {
+	content := "## Main Findings\nAudit summary is visible.\n\n## Proposed Changes\n### Target File\nAGENTS.md\n"
+	got := RenderEpicAuditTab("E06-test", content, 80, 50, 0, 1)
+	if !strings.Contains(got, "Audit summary is visible") {
+		t.Error("RenderEpicAuditTab should render Main Findings body")
+	}
+	if strings.Contains(got, "Target File") || strings.Contains(got, "AGENTS.md") {
+		t.Error("RenderEpicAuditTab should not render Proposed Changes admin blocks")
+	}
+}
+
+func TestRenderEpicAuditTab_qualityReviewHidden(t *testing.T) {
+	content := "## Quality Review\nOld quality section.\n\n## Code Style Review\n- [ ] One job per file\n"
+	got := RenderEpicAuditTab("E06-test", content, 80, 50, 0, 1)
+	if strings.Contains(got, "Old quality section") {
+		t.Error("RenderEpicAuditTab should not render superseded Quality Review section")
+	}
+	if !strings.Contains(got, "One job per file") {
+		t.Error("RenderEpicAuditTab should render Code Style Review")
+	}
+}
+
+func TestRenderEpicAuditTab_hiddenHeadingsRequireExactMatch(t *testing.T) {
+	content := "## Proposed Changes Appendix\nNear-match section is visible.\n\n## Proposed Changes\nHidden admin section.\n"
+	got := RenderEpicAuditTab("E06-test", content, 80, 50, 0, 1)
+	if !strings.Contains(got, "Near-match section is visible") {
+		t.Error("RenderEpicAuditTab should render headings that only partially match hidden headings")
+	}
+	if strings.Contains(got, "Hidden admin section") {
+		t.Error("RenderEpicAuditTab should hide exact Proposed Changes section")
+	}
+}
+
+func TestRenderEpicAuditTab_allCodeStyleRules(t *testing.T) {
+	rules := []string{
+		"One job per file",
+		"One-sentence functions",
+		"Test branches",
+		"Types are documentation",
+		"Build, don't speculate",
+		"Errors at boundaries",
+		"One source of truth",
+		"Comments explain WHY",
+		"Content in data files",
+		"Small diffs",
+	}
+	content := "## Code Style Review\n"
+	for _, r := range rules {
+		content += "- [ ] " + r + "\n"
+	}
+	got := RenderEpicAuditTab("E06-test", content, 80, 50, 0, 1)
+	for _, r := range rules {
+		if !strings.Contains(got, r) {
+			t.Errorf("RenderEpicAuditTab missing code style rule %q", r)
+		}
+	}
+}
+
+// TestView_epicAuditTabRendered verifies View() uses RenderEpicAuditTab when EpicDetailTab=1.
+func TestView_epicAuditTabRendered(t *testing.T) {
+	m := NewModel(nil, "v1.1", "E06-audit-command")
+	m.Width = 120
+	m.Height = 30
+	m.Epics = []string{"E06-audit-command"}
+	m.Overlay = OverlayEpicDetail
+	m.EpicDetailTab = 1
+	m.EpicAuditContent = "# Audit Findings: E06\n\n## Main Findings\nAll good.\n\n## Code Style Review\n- [x] One job per file\n"
+
+	got := m.View()
+	if !strings.Contains(got, "EPIC AUDIT") {
+		t.Error("View() with EpicDetailTab=1 missing EPIC AUDIT header")
+	}
+	if strings.Contains(got, "EPIC DETAIL") {
+		t.Error("View() with EpicDetailTab=1 should not render EPIC DETAIL header")
+	}
+}
+
+// TestAuditWorkflow_fullEndToEnd exercises the full audit workflow:
+// create E##-Audit.md on disk, open overlay, press 2, verify content loads and renders.
+func TestAuditWorkflow_fullEndToEnd(t *testing.T) {
+	root := t.TempDir()
+	epicSlug := "E06-audit-command"
+	epicDir := filepath.Join(root, "releases", "v1.1", "epics", epicSlug)
+	if err := os.MkdirAll(epicDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	auditContent := `---
+type: audit-findings
+audited: 2026-05-03
+---
+# Audit Findings: E06 Agent Audit + Audit Tab
+
+## Main Findings
+All acceptance criteria met.
+
+## Code Style Review
+- [x] One job per file
+- [x] One-sentence functions
+- [x] Test branches
+- [x] Types are documentation
+- [x] Build, don't speculate
+- [x] Errors at boundaries
+- [x] One source of truth
+- [x] Comments explain WHY
+- [x] Content in data files
+- [x] Small diffs
+`
+	if err := os.WriteFile(filepath.Join(epicDir, "E06-Audit.md"), []byte(auditContent), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	tasks := []data.Task{
+		{ID: "E06-audit-command/T009-integration", Release: "v1.1", Epic: epicSlug, Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1.1", epicSlug)
+	m.Root = root
+	m.Epics = []string{epicSlug}
+	m.EpicPanelCursor = 0
+	m.Width = 120
+	m.Height = 40
+
+	// Open detail overlay (tab=0)
+	m.openEpicDetailOverlay()
+	if m.Overlay != OverlayEpicDetail {
+		t.Fatal("overlay not opened")
+	}
+	if m.EpicDetailTab != 0 {
+		t.Errorf("EpicDetailTab = %d, want 0 on open", m.EpicDetailTab)
+	}
+
+	// Press 2 → switch to audit tab, load content
+	got, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("2")})
+	updated := requireModel(t, got)
+
+	if updated.EpicDetailTab != 1 {
+		t.Errorf("EpicDetailTab = %d, want 1 after pressing 2", updated.EpicDetailTab)
+	}
+
+	msg := cmd()
+	got2, _ := updated.Update(msg)
+	updated2 := requireModel(t, got2)
+	if updated2.EpicAuditContent == "" || updated2.EpicAuditContent == "(no audit available)" {
+		t.Errorf("EpicAuditContent not loaded: %q", updated2.EpicAuditContent)
+	}
+
+	// Verify View() renders audit content
+	view := updated2.View()
+	if !strings.Contains(view, "EPIC AUDIT") {
+		t.Error("View() after tab switch missing EPIC AUDIT")
+	}
+	if !strings.Contains(view, "One job per file") {
+		t.Error("View() after tab switch missing code style rule")
+	}
+
+	// Press 1 → switch back to detail tab
+	got, _ = updated2.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("1")})
+	updated = requireModel(t, got)
+	if updated.EpicDetailTab != 0 {
+		t.Errorf("EpicDetailTab = %d, want 0 after pressing 1", updated.EpicDetailTab)
+	}
+
+	// Press esc → overlay closes
+	got, _ = updated.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	updated = requireModel(t, got)
+	if updated.Overlay != OverlayNone {
+		t.Errorf("Overlay = %q, want none after esc", updated.Overlay)
+	}
+}
+
+func TestRenderEpicAuditTab_v11AuditFiles(t *testing.T) {
+	files := []struct {
+		path string
+		want string
+	}{
+		{filepath.Join("..", "..", ".savepoint", "releases", "v1.1", "epics", "E02-cross-platform-compatibility", "E02-Audit.md"), "cross-platform build work"},
+		{filepath.Join("..", "..", ".savepoint", "releases", "v1.1", "epics", "E03-ui-visual-refinement", "E03-Audit.md"), "visual refinement work"},
+		{filepath.Join("..", "..", ".savepoint", "releases", "v1.1", "epics", "E04-epic-navigation", "E04-Audit.md"), "wide-screen epic navigation"},
+		{filepath.Join("..", "..", ".savepoint", "releases", "v1.1", "epics", "E05-tasking-permissions", "E05-Audit.md"), "tasking-permissions shift"},
+		{filepath.Join("..", "..", ".savepoint", "releases", "v1.1", "epics", "E06-audit-command", "E06-Audit.md"), "agent-led"},
+	}
+
+	for _, tt := range files {
+		content, err := os.ReadFile(tt.path)
+		if err != nil {
+			t.Fatalf("read %s: %v", tt.path, err)
+		}
+		if !strings.Contains(string(content), tt.want) {
+			t.Fatalf("fixture %s missing %q", tt.path, tt.want)
+		}
+		got := RenderEpicAuditTab(filepath.Base(filepath.Dir(tt.path)), string(content), 80, 40, 0, 1)
+		if !strings.Contains(got, tt.want) {
+			t.Errorf("RenderEpicAuditTab(%s) missing %q", tt.path, tt.want)
+		}
+		if strings.Contains(got, "Target File") {
+			t.Errorf("RenderEpicAuditTab(%s) should not render Proposed Changes", tt.path)
+		}
+		if strings.Contains(got, "Boundaries") || strings.Contains(got, "Implemented as") || strings.Contains(got, "Implemented As") {
+			t.Errorf("RenderEpicAuditTab(%s) should only render visible audit sections", tt.path)
+		}
+	}
+}

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)
+	}
+}