savepoint 1.0.2 → 1.0.4

package/internal/board/view_test.go

@@ -1,6 +1,7 @@
 package board
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
@@ -66,7 +67,7 @@ func TestView_containsFooterHints(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	footer := m.renderFooter(80)
 
-	if !strings.Contains(footer, "←/→:nav  E:epic  R:release  ?:help  q:quit") {
+	if !strings.Contains(footer, "←/→:nav  p: Priority  R:release  ?:help  q:quit") {
 		t.Fatal("renderFooter() missing navigation hints")
 	}
 
@@ -75,7 +76,7 @@ func TestView_containsFooterHints(t *testing.T) {
 		t.Fatalf("renderFooter() returned %d lines, want 3", len(lines))
 	}
 	if strings.TrimSpace(plainTerminal(lines[1])) != "" {
-		t.Fatalf("renderFooter() spacer line = %q, want blank", lines[1])
+		t.Fatalf("renderFooter() status line = %q, want blank", lines[1])
 	}
 	for i, line := range lines {
 		if got := lipgloss.Width(line); got > 80 {
@@ -84,6 +85,16 @@ func TestView_containsFooterHints(t *testing.T) {
 	}
 }
 
+func TestView_footerRendersStatusMessage(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.StatusMessage = "Router set to v1.1 E05-tasking-permissions/T004"
+	footer := plainTerminal(m.renderFooter(80))
+
+	if !strings.Contains(footer, "Router set to v1.1 E05-tasking-permissions/T004") {
+		t.Fatal("renderFooter() missing status message")
+	}
+}
+
 func TestView_containsBottomDivider(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	m.Width = 120
@@ -291,6 +302,67 @@ func TestRenderNextActivityLine_truncatesAtNarrowWidth(t *testing.T) {
 	}
 }
 
+func BenchmarkCalculateLayout_narrow(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(60, 24)
+	}
+}
+
+func BenchmarkCalculateLayout_standard(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(80, 24)
+	}
+}
+
+func BenchmarkCalculateLayout_wide(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(120, 24)
+	}
+}
+
+func BenchmarkCalculateLayout_extraWide(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(220, 50)
+	}
+}
+
+func BenchmarkView_empty(b *testing.B) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.Height = 40
+	b.ReportAllocs()
+	for b.Loop() {
+		m.View()
+	}
+}
+
+func BenchmarkView_withTasks(b *testing.B) {
+	tasks := make([]data.Task, 15)
+	stages := []data.ProgressStage{data.StageBuild, data.StageTest, data.StageAudit}
+	cols := []data.ColumnType{data.ColumnPlanned, data.ColumnInProgress, data.ColumnDone}
+	for i := range tasks {
+		tasks[i] = data.Task{
+			ID:      fmt.Sprintf("E06-layout/T%03d-task-slug", i+1),
+			Title:   fmt.Sprintf("Task %d with a reasonable title length", i+1),
+			Column:  cols[i%3],
+			Stage:   stages[i%3],
+			Release: "v1.1",
+			Epic:    "E06-layout",
+		}
+	}
+	m := NewModel(tasks, "v1.1", "E06")
+	m.Width = 120
+	m.Height = 40
+	b.ReportAllocs()
+	for b.Loop() {
+		m.View()
+	}
+}
+
 func TestView_narrowShowsSingleColumn(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	m.Width = 60

package/internal/board/watch.go

@@ -16,6 +16,31 @@ type reloadMsg struct {
 	releases     []string
 	releaseEpics map[string][]string
 	epicStatuses map[string]string
+	routerState  *data.RouterState
+}
+
+type routerWriteMsg struct {
+	message string
+	state   *data.RouterState
+	taskID  string
+}
+
+type taskWriteMsg struct {
+	prefix string
+	next   data.Task
+	err    error
+}
+
+type epicDetailMsg struct {
+	content string
+}
+
+type auditContentMsg struct {
+	content string
+}
+
+type errorMsg struct {
+	message string
 }
 
 // watchFiles blocks until a file event arrives, debounces for 100ms, emits fileChangeMsg.
@@ -27,6 +52,7 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 				if !ok {
 					return nil
 				}
+				debugf("watcher: event %s", event)
 				watchCreatedDir(w, event)
 				timer := time.NewTimer(100 * time.Millisecond)
 			drain:
@@ -37,11 +63,13 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 							timer.Stop()
 							return nil
 						}
+						debugf("watcher: event %s", event)
 						watchCreatedDir(w, event)
 					case <-timer.C:
 						break drain
 					}
 				}
+				debugf("watcher: emitting fileChangeMsg")
 				return fileChangeMsg{}
 			case _, ok := <-w.Errors:
 				if !ok {
@@ -52,22 +80,30 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 	}
 }
 
-func reloadTasks(root string) tea.Cmd {
+func reloadTasks(root string, deps ModelDependencies) tea.Cmd {
 	return func() tea.Msg {
-		tasks, releases, releaseEpics, epicStatuses, err := loadBoardData(root)
+		debugf("reload: starting task reload from %q", root)
+		tasks, releases, releaseEpics, epicStatuses, err := loadBoardData(root, deps.Discoverer, deps.Parser)
 		if err != nil {
-			return nil
+			debugf("reload: error: %v", err)
+			return errorMsg{message: "reload failed: " + err.Error()}
 		}
-		return reloadMsg{tasks: tasks, releases: releases, releaseEpics: releaseEpics, epicStatuses: epicStatuses}
+		debugf("reload: loaded %d tasks", len(tasks))
+		routerState, _ := readRouterState(root, deps.RouterReader)
+		return reloadMsg{tasks: tasks, releases: releases, releaseEpics: releaseEpics, epicStatuses: epicStatuses, routerState: routerState}
 	}
 }
 
-// newWatcher watches the releases directory by walking all subdirs (fsnotify v1.10 has no recursive opt).
+// newWatcher watches the savepoint root (for router.md) and all releases subdirs.
 func newWatcher(root string) (*fsnotify.Watcher, error) {
 	w, err := fsnotify.NewWatcher()
 	if err != nil {
 		return nil, err
 	}
+	if err := w.Add(root); err != nil {
+		w.Close()
+		return nil, err
+	}
 	releasesPath := filepath.Join(root, "releases")
 	if err := addDirsRecursive(w, releasesPath); err != nil {
 		w.Close()

package/internal/buildtool/main.go

@@ -3,6 +3,8 @@ package main
 import (
 	"archive/tar"
 	"compress/gzip"
+	"crypto/sha256"
+	"encoding/hex"
 	"errors"
 	"flag"
 	"fmt"
@@ -11,6 +13,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"strings"
 )
 
 type target struct {
@@ -23,6 +26,8 @@ var targets = []target{
 	{os: "linux", arch: "arm64"},
 	{os: "darwin", arch: "amd64"},
 	{os: "darwin", arch: "arm64"},
+	{os: "windows", arch: "amd64"},
+	{os: "windows", arch: "arm64"},
 }
 
 var versionOverride string
@@ -41,7 +46,7 @@ func run(args []string) error {
 		return err
 	}
 	if flags.NArg() != 1 {
-		return errors.New("usage: go run ./internal/buildtool [-version vX.Y.Z] <build|clean|build-linux|build-darwin|build-all|dist|smoke-test>")
+		return errors.New("usage: go run ./internal/buildtool [-version vX.Y.Z] <build|clean|build-linux|build-darwin|build-windows|build-all|dist|smoke-test>")
 	}
 
 	switch flags.Arg(0) {
@@ -53,6 +58,8 @@ func run(args []string) error {
 		return buildMatching("linux")
 	case "build-darwin":
 		return buildMatching("darwin")
+	case "build-windows":
+		return buildMatching("windows")
 	case "build-all":
 		return buildAll()
 	case "dist":
@@ -98,8 +105,15 @@ func buildAll() error {
 	return nil
 }
 
+func executableName(goos string) string {
+	if goos == "windows" {
+		return "savepoint.exe"
+	}
+	return "savepoint"
+}
+
 func buildTarget(target target) error {
-	output := filepath.Join("dist", target.os+"-"+target.arch, "savepoint")
+	output := filepath.Join("dist", target.os+"-"+target.arch, executableName(target.os))
 	return runGoBuild(output, target.os, target.arch)
 }
 
@@ -122,13 +136,39 @@ func dist() error {
 	if err := buildAll(); err != nil {
 		return err
 	}
+	var archives []string
 	for _, target := range targets {
 		name := "savepoint-" + version() + "-" + target.os + "-" + target.arch + ".tar.gz"
-		source := filepath.Join("dist", target.os+"-"+target.arch, "savepoint")
+		source := filepath.Join("dist", target.os+"-"+target.arch, executableName(target.os))
 		archive := filepath.Join("dist", name)
-		if err := writeTarGz(archive, source, "savepoint"); err != nil {
+		if err := writeTarGz(archive, source, executableName(target.os)); err != nil {
 			return err
 		}
+		archives = append(archives, archive)
+	}
+	return writeChecksums(filepath.Join("dist", "checksums.txt"), archives)
+}
+
+func writeChecksums(dest string, archives []string) error {
+	var lines strings.Builder
+	for _, path := range archives {
+		f, err := os.Open(path)
+		if err != nil {
+			return fmt.Errorf("checksum open %s: %w", path, err)
+		}
+		h := sha256.New()
+		if _, err := io.Copy(h, f); err != nil {
+			f.Close()
+			return fmt.Errorf("checksum read %s: %w", path, err)
+		}
+		f.Close()
+		lines.WriteString(hex.EncodeToString(h.Sum(nil)))
+		lines.WriteString("  ")
+		lines.WriteString(filepath.Base(path))
+		lines.WriteString("\n")
+	}
+	if err := os.WriteFile(dest, []byte(lines.String()), 0o644); err != nil {
+		return fmt.Errorf("write checksums: %w", err)
 	}
 	return nil
 }
@@ -196,7 +236,7 @@ func version() string {
 	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
 	output, err := cmd.Output()
 	if err == nil && len(output) > 0 {
-		return string(trimSpace(output))
+		return strings.TrimSpace(string(output))
 	}
 	return "v0.0.0"
 }
@@ -207,13 +247,3 @@ func localExecutable() string {
 	}
 	return "savepoint"
 }
-
-func trimSpace(value []byte) []byte {
-	for len(value) > 0 && (value[len(value)-1] == '\n' || value[len(value)-1] == '\r' || value[len(value)-1] == '\t' || value[len(value)-1] == ' ') {
-		value = value[:len(value)-1]
-	}
-	for len(value) > 0 && (value[0] == '\n' || value[0] == '\r' || value[0] == '\t' || value[0] == ' ') {
-		value = value[1:]
-	}
-	return value
-}

package/internal/buildtool/main_test.go

@@ -0,0 +1,224 @@
+package main
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestVersion_override(t *testing.T) {
+	versionOverride = "v1.2.3"
+	defer func() { versionOverride = "" }()
+	if got := version(); got != "v1.2.3" {
+		t.Errorf("version() = %q, want %q", got, "v1.2.3")
+	}
+}
+
+func TestVersion_env(t *testing.T) {
+	versionOverride = ""
+	os.Setenv("VERSION", "v2.0.0-env")
+	defer os.Unsetenv("VERSION")
+	if got := version(); got != "v2.0.0-env" {
+		t.Errorf("version() = %q, want %q", got, "v2.0.0-env")
+	}
+}
+
+func TestVersion_fallback(t *testing.T) {
+	versionOverride = ""
+	os.Unsetenv("VERSION")
+	got := version()
+	if got == "" {
+		t.Error("version() returned empty string")
+	}
+}
+
+func TestWriteChecksums(t *testing.T) {
+	dir := t.TempDir()
+
+	content := []byte("fake archive content")
+	archive := filepath.Join(dir, "savepoint-v1.0.0-linux-amd64.tar.gz")
+	if err := os.WriteFile(archive, content, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	dest := filepath.Join(dir, "checksums.txt")
+	if err := writeChecksums(dest, []string{archive}); err != nil {
+		t.Fatalf("writeChecksums: %v", err)
+	}
+
+	got, err := os.ReadFile(dest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h := sha256.Sum256(content)
+	wantHash := hex.EncodeToString(h[:])
+	wantLine := wantHash + "  savepoint-v1.0.0-linux-amd64.tar.gz"
+
+	lines := strings.Split(strings.TrimSpace(string(got)), "\n")
+	if len(lines) != 1 {
+		t.Fatalf("expected 1 line, got %d", len(lines))
+	}
+	if lines[0] != wantLine {
+		t.Errorf("line = %q, want %q", lines[0], wantLine)
+	}
+}
+
+func TestWriteChecksums_multiple(t *testing.T) {
+	dir := t.TempDir()
+
+	names := []string{"a.tar.gz", "b.tar.gz"}
+	var paths []string
+	for _, name := range names {
+		p := filepath.Join(dir, name)
+		if err := os.WriteFile(p, []byte(name), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		paths = append(paths, p)
+	}
+
+	dest := filepath.Join(dir, "checksums.txt")
+	if err := writeChecksums(dest, paths); err != nil {
+		t.Fatalf("writeChecksums: %v", err)
+	}
+
+	got, err := os.ReadFile(dest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	lines := strings.Split(strings.TrimSpace(string(got)), "\n")
+	if len(lines) != 2 {
+		t.Fatalf("expected 2 lines, got %d: %s", len(lines), got)
+	}
+	for i, name := range names {
+		h := sha256.Sum256([]byte(name))
+		want := hex.EncodeToString(h[:]) + "  " + name
+		if lines[i] != want {
+			t.Errorf("line[%d] = %q, want %q", i, lines[i], want)
+		}
+	}
+}
+
+func TestWriteChecksums_missingFile(t *testing.T) {
+	dir := t.TempDir()
+	dest := filepath.Join(dir, "checksums.txt")
+	err := writeChecksums(dest, []string{filepath.Join(dir, "nonexistent.tar.gz")})
+	if err == nil {
+		t.Error("expected error for missing archive, got nil")
+	}
+}
+
+func TestTargets_includesWindows(t *testing.T) {
+	var gotAMD64, gotARM64 bool
+	for _, tgt := range targets {
+		if tgt.os != "windows" {
+			continue
+		}
+		switch tgt.arch {
+		case "amd64":
+			gotAMD64 = true
+		case "arm64":
+			gotARM64 = true
+		}
+	}
+	if !gotAMD64 {
+		t.Error("targets missing windows/amd64")
+	}
+	if !gotARM64 {
+		t.Error("targets missing windows/arm64")
+	}
+}
+
+func TestTargets_preservesLinuxDarwin(t *testing.T) {
+	want := map[string]bool{
+		"linux/amd64":  false,
+		"linux/arm64":  false,
+		"darwin/amd64": false,
+		"darwin/arm64": false,
+	}
+	for _, tgt := range targets {
+		key := tgt.os + "/" + tgt.arch
+		if _, ok := want[key]; ok {
+			want[key] = true
+		}
+	}
+	for key, found := range want {
+		if !found {
+			t.Errorf("targets missing %s", key)
+		}
+	}
+}
+
+func TestExecutableName(t *testing.T) {
+	if got := executableName("windows"); got != "savepoint.exe" {
+		t.Errorf("executableName(windows) = %q, want savepoint.exe", got)
+	}
+	if got := executableName("linux"); got != "savepoint" {
+		t.Errorf("executableName(linux) = %q, want savepoint", got)
+	}
+	if got := executableName("darwin"); got != "savepoint" {
+		t.Errorf("executableName(darwin) = %q, want savepoint", got)
+	}
+}
+
+func TestWriteTarGzPreservesWindowsExecutableName(t *testing.T) {
+	dir := t.TempDir()
+	source := filepath.Join(dir, "savepoint.exe")
+	if err := os.WriteFile(source, []byte("binary"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	archive := filepath.Join(dir, "savepoint-windows-amd64.tar.gz")
+	if err := writeTarGz(archive, source, executableName("windows")); err != nil {
+		t.Fatalf("writeTarGz: %v", err)
+	}
+
+	f, err := os.Open(archive)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+
+	gz, err := gzip.NewReader(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer gz.Close()
+
+	tr := tar.NewReader(gz)
+	header, err := tr.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if header.Name != "savepoint.exe" {
+		t.Fatalf("archive member = %q, want savepoint.exe", header.Name)
+	}
+
+	content, err := io.ReadAll(tr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "binary" {
+		t.Fatalf("archive content = %q, want binary", content)
+	}
+}
+
+func TestLocalExecutable(t *testing.T) {
+	got := localExecutable()
+	if runtime.GOOS == "windows" {
+		if got != "savepoint.exe" {
+			t.Errorf("localExecutable() = %q, want %q", got, "savepoint.exe")
+		}
+	} else {
+		if got != "savepoint" {
+			t.Errorf("localExecutable() = %q, want %q", got, "savepoint")
+		}
+	}
+}

package/internal/data/config.go

@@ -16,8 +16,17 @@ type Theme struct {
 	Accents  map[string]string `yaml:"accents"`
 }
 
+type QualityGates struct {
+	Lint           *string `yaml:"lint"`
+	Typecheck      *string `yaml:"typecheck"`
+	Test           *string `yaml:"test"`
+	BlockOnFailure bool    `yaml:"block_on_failure"`
+	Timeout        string  `yaml:"gate_timeout"`
+}
+
 type Config struct {
-	Theme Theme `yaml:"theme"`
+	Theme         Theme         `yaml:"theme"`
+	QualityGates  QualityGates  `yaml:"quality_gates"`
 }
 
 var defaultTheme = Theme{
@@ -80,8 +89,13 @@ func fillThemeDefaults(theme Theme) Theme {
 	if theme.Text == "" {
 		theme.Text = defaultTheme.Text
 	}
-	if len(theme.Accents) == 0 {
-		theme.Accents = defaultTheme.Accents
+	if theme.Accents == nil {
+		theme.Accents = make(map[string]string)
+	}
+	for k, v := range defaultTheme.Accents {
+		if _, ok := theme.Accents[k]; !ok {
+			theme.Accents[k] = v
+		}
 	}
 	return theme
 }

package/internal/data/config_test.go

@@ -53,6 +53,55 @@ func TestConfigReaderRead(t *testing.T) {
 	}
 }
 
+func TestFillThemeDefaults_PartialAccents(t *testing.T) {
+	theme := Theme{
+		BG:      "#000000",
+		Accents: map[string]string{"planned": "#ff0000"},
+	}
+	result := fillThemeDefaults(theme)
+	if result.Accents["planned"] != "#ff0000" {
+		t.Errorf("Accents[planned] = %v, want #ff0000 (user value preserved)", result.Accents["planned"])
+	}
+	if result.Accents["in_progress"] != defaultTheme.Accents["in_progress"] {
+		t.Errorf("Accents[in_progress] = %v, want default %v", result.Accents["in_progress"], defaultTheme.Accents["in_progress"])
+	}
+	if result.Accents["done"] != defaultTheme.Accents["done"] {
+		t.Errorf("Accents[done] = %v, want default %v", result.Accents["done"], defaultTheme.Accents["done"])
+	}
+	if result.Accents["blocked"] != defaultTheme.Accents["blocked"] {
+		t.Errorf("Accents[blocked] = %v, want default %v", result.Accents["blocked"], defaultTheme.Accents["blocked"])
+	}
+	if result.Accents["epic"] != defaultTheme.Accents["epic"] {
+		t.Errorf("Accents[epic] = %v, want default %v", result.Accents["epic"], defaultTheme.Accents["epic"])
+	}
+}
+
+func TestFillThemeDefaults_NilAccents(t *testing.T) {
+	theme := Theme{
+		BG:      "#000000",
+		Accents: nil,
+	}
+	result := fillThemeDefaults(theme)
+	for k, v := range defaultTheme.Accents {
+		if result.Accents[k] != v {
+			t.Errorf("Accents[%s] = %v, want default %v", k, result.Accents[k], v)
+		}
+	}
+}
+
+func TestFillThemeDefaults_EmptyAccents(t *testing.T) {
+	theme := Theme{
+		BG:      "#000000",
+		Accents: map[string]string{},
+	}
+	result := fillThemeDefaults(theme)
+	for k, v := range defaultTheme.Accents {
+		if result.Accents[k] != v {
+			t.Errorf("Accents[%s] = %v, want default %v", k, result.Accents[k], v)
+		}
+	}
+}
+
 func TestConfigReaderMalformedYAML(t *testing.T) {
 	tmpfile, err := os.CreateTemp("", "config-*.yml")
 	if err != nil {

package/internal/data/discover.go

@@ -85,6 +85,32 @@ func (d *Discover) ListReleases(root string) ([]ReleaseInfo, error) {
 	return releases, nil
 }
 
+// ListRootDirs returns sorted child directory names directly under root.
+func (d *Discover) ListRootDirs(root string) ([]string, error) {
+	info, err := os.Stat(root)
+	if err != nil {
+		return nil, err
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("%s is not a directory", root)
+	}
+
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		return nil, err
+	}
+
+	var dirs []string
+	for _, entry := range entries {
+		if entry.IsDir() {
+			dirs = append(dirs, entry.Name())
+		}
+	}
+
+	sort.Strings(dirs)
+	return dirs, nil
+}
+
 func (d *Discover) ListEpics(root, release string) ([]EpicInfo, error) {
 	epicsPath := filepath.Join(root, "releases", release, "epics")
 	info, err := os.Stat(epicsPath)