savepoint 1.0.2 → 1.0.3

package/internal/buildtool/main.go

@@ -9,6 +9,7 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"strings"
 	"path/filepath"
 	"runtime"
 )
@@ -196,7 +197,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"
 }
@@ -208,12 +209,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,46 @@
+package main
+
+import (
+	"os"
+	"runtime"
+	"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 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)

package/internal/data/discover_test.go

@@ -1,18 +1,17 @@
 package data
 
 import (
-	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/opencode/savepoint/internal/testutil"
 )
 
 func TestFindSavepointRoot(t *testing.T) {
 	d := NewDiscover()
 	savepointRoot := createDiscoveryFixture(t)
 	start := filepath.Join(filepath.Dir(savepointRoot), "nested", "child")
-	if err := os.MkdirAll(start, 0755); err != nil {
-		t.Fatal(err)
-	}
+	testutil.MkdirAll(t, start)
 
 	root, err := d.FindSavepointRoot(start)
 	if err != nil {
@@ -40,6 +39,35 @@ func TestListReleases(t *testing.T) {
 	}
 }
 
+func TestListRootDirs(t *testing.T) {
+	d := NewDiscover()
+	root := t.TempDir()
+	testutil.MkdirAll(t, filepath.Join(root, "beta"))
+	testutil.MkdirAll(t, filepath.Join(root, "alpha"))
+	testutil.WriteFile(t, filepath.Join(root, "notes.txt"), "test")
+
+	dirs, err := d.ListRootDirs(root)
+	if err != nil {
+		t.Fatalf("ListRootDirs() error = %v", err)
+	}
+
+	if len(dirs) != 2 || dirs[0] != "alpha" || dirs[1] != "beta" {
+		t.Fatalf("ListRootDirs() = %v, want [alpha beta]", dirs)
+	}
+}
+
+func TestListRootDirsRejectsFile(t *testing.T) {
+	d := NewDiscover()
+	root := t.TempDir()
+	path := filepath.Join(root, "not-dir")
+	testutil.WriteFile(t, path, "test")
+
+	_, err := d.ListRootDirs(path)
+	if err == nil {
+		t.Fatal("ListRootDirs() error = nil, want not directory error")
+	}
+}
+
 func TestListEpics(t *testing.T) {
 	d := NewDiscover()
 	root := createDiscoveryFixture(t)
@@ -86,9 +114,7 @@ func createDiscoveryFixture(t *testing.T) string {
 		filepath.Join(savepointRoot, "releases", "v2", "epics"),
 	}
 	for _, path := range paths {
-		if err := os.MkdirAll(path, 0755); err != nil {
-			t.Fatal(err)
-		}
+		testutil.MkdirAll(t, path)
 	}
 
 	files := []string{
@@ -97,9 +123,7 @@ func createDiscoveryFixture(t *testing.T) string {
 		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks", "notes.txt"),
 	}
 	for _, file := range files {
-		if err := os.WriteFile(file, []byte("test"), 0644); err != nil {
-			t.Fatal(err)
-		}
+		testutil.WriteFile(t, file, "test")
 	}
 
 	return savepointRoot

package/internal/data/errors.go

@@ -6,4 +6,8 @@ var (
 	ErrNoFrontmatter             = errors.New("no frontmatter found")
 	ErrNoClosingFrontmatter      = errors.New("no closing frontmatter delimiter found")
 	ErrSavepointDirectoryMissing = errors.New(".savepoint directory not found")
+	ErrInvalidStatus             = errors.New("invalid router state")
+	ErrMissingFrontmatter        = errors.New("missing or invalid frontmatter")
+	ErrConfigNotFound            = errors.New("configuration file not found")
+	ErrStructureProblem          = errors.New("project structure problem")
 )

package/internal/data/lifecycle.go

@@ -2,17 +2,24 @@ package data
 
 import "fmt"
 
-func ValidateTaskLifecycle(task Task) error {
+func ValidateTaskLifecycle(task *Task) error {
 	if !IsCanonicalColumn(task.Column) {
-		return fmt.Errorf("invalid task status %q: use planned, in_progress, or done", task.Column)
+		return fmt.Errorf("invalid status %q: use planned, in_progress, or done. Add 'status: planned' or 'status: in_progress' to task frontmatter", task.Column)
 	}
 
-	if task.Column != ColumnInProgress && task.Stage != "" {
-		return fmt.Errorf("phase %q is only valid when status is in_progress", task.Stage)
+	if task.Column == ColumnInProgress {
+		if task.Stage == "" {
+			task.Stage = StageBuild
+			return nil
+		}
+		if !IsCanonicalStage(task.Stage) {
+			return fmt.Errorf("invalid phase %q: use build, test, or audit. Add 'phase: build' to task frontmatter", task.Stage)
+		}
+		return nil
 	}
 
-	if task.Column == ColumnInProgress && !IsCanonicalStage(task.Stage) {
-		return fmt.Errorf("invalid in_progress phase %q: use build, test, or audit", task.Stage)
+	if task.Stage != "" {
+		return fmt.Errorf("phase field %q is only valid when status is in_progress. Remove 'phase' or change status to in_progress", task.Stage)
 	}
 
 	return nil

package/internal/data/lifecycle_test.go

@@ -4,35 +4,38 @@ import "testing"
 
 func TestValidateTaskLifecycle_allowsPlannedWithoutPhase(t *testing.T) {
 	task := Task{Column: ColumnPlanned}
-	if err := ValidateTaskLifecycle(task); err != nil {
+	if err := ValidateTaskLifecycle(&task); err != nil {
 		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
 	}
 }
 
+func TestValidateTaskLifecycle_defaultsInProgressWithoutPhase(t *testing.T) {
+	task := Task{Column: ColumnInProgress}
+	if err := ValidateTaskLifecycle(&task); err != nil {
+		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
+	}
+	if task.Stage != StageBuild {
+		t.Fatalf("Task.Stage = %q, want %q", task.Stage, StageBuild)
+	}
+}
+
 func TestValidateTaskLifecycle_allowsInProgressWithPhase(t *testing.T) {
 	task := Task{Column: ColumnInProgress, Stage: StageAudit}
-	if err := ValidateTaskLifecycle(task); err != nil {
+	if err := ValidateTaskLifecycle(&task); err != nil {
 		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
 	}
 }
 
 func TestValidateTaskLifecycle_rejectsUnknownStatus(t *testing.T) {
 	task := Task{Column: "review"}
-	if err := ValidateTaskLifecycle(task); err == nil {
+	if err := ValidateTaskLifecycle(&task); err == nil {
 		t.Fatal("ValidateTaskLifecycle() expected unknown status error")
 	}
 }
 
 func TestValidateTaskLifecycle_rejectsPhaseOutsideInProgress(t *testing.T) {
 	task := Task{Column: ColumnPlanned, Stage: StageBuild}
-	if err := ValidateTaskLifecycle(task); err == nil {
+	if err := ValidateTaskLifecycle(&task); err == nil {
 		t.Fatal("ValidateTaskLifecycle() expected phase/status error")
 	}
 }
-
-func TestValidateTaskLifecycle_rejectsInProgressWithoutCanonicalPhase(t *testing.T) {
-	task := Task{Column: ColumnInProgress}
-	if err := ValidateTaskLifecycle(task); err == nil {
-		t.Fatal("ValidateTaskLifecycle() expected missing phase error")
-	}
-}

package/internal/data/parser.go

@@ -46,7 +46,7 @@ func (p *Parser) ParseTaskFile(path string, content string) (*Task, error) {
 		Epic:        firstNonEmpty(fields.Epic, extractEpicFromID(fields.ID)),
 		Release:     firstNonEmpty(fields.Release, "v1"),
 		Column:      normalizeColumn(rawColumn),
-		Stage:       firstStage(fields.Stage, fields.Phase),
+		Stage:       firstStage(fields.Phase, fields.Stage),
 		Priority:    fields.Priority,
 		Points:      fields.Points,
 		Tags:        fields.Tags,
@@ -61,6 +61,10 @@ func (p *Parser) ParseTaskFile(path string, content string) (*Task, error) {
 		return nil, fmt.Errorf("parse error for %s: %w", path, err)
 	}
 
+	if task.Column == ColumnInProgress && task.Stage == "" {
+		task.Stage = StageBuild
+	}
+
 	return task, nil
 }
 
@@ -84,8 +88,13 @@ type taskFrontmatter struct {
 	Progress    Progress      `yaml:"progress"`
 }
 
+// normalizeLineEndings replaces Windows line endings with Unix line endings.
+func normalizeLineEndings(s string) string {
+	return strings.ReplaceAll(s, "\r\n", "\n")
+}
+
 func extractFrontmatter(content string) (string, error) {
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	normalized := normalizeLineEndings(content)
 	if !strings.HasPrefix(normalized, "---\n") {
 		return "", ErrNoFrontmatter
 	}
@@ -139,9 +148,15 @@ const legacyTodoColumn ColumnType = "todo"
 
 func validateParsedTaskLifecycle(rawColumn ColumnType, task Task) error {
 	if rawColumn != "" && rawColumn != legacyTodoColumn && !IsCanonicalColumn(rawColumn) {
-		return fmt.Errorf("invalid task status %q: use planned, in_progress, or done", rawColumn)
+		return fmt.Errorf("invalid task status %q: use planned, in_progress, or done. Add 'status: planned' or 'status: in_progress' to task frontmatter", rawColumn)
 	}
-	return ValidateTaskLifecycle(task)
+	if task.Column == ColumnInProgress && !IsCanonicalStage(task.Stage) && task.Stage != "" {
+		return fmt.Errorf("invalid phase %q: use build, test, or audit. Add 'phase: build' to task frontmatter", task.Stage)
+	}
+	if task.Column != ColumnInProgress && task.Stage != "" {
+		return nil
+	}
+	return nil
 }
 
 func firstStage(values ...ProgressStage) ProgressStage {
@@ -163,7 +178,7 @@ func firstList(values ...[]string) []string {
 }
 
 func extractChecklistItems(content, heading string) []CheckItem {
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	normalized := normalizeLineEndings(content)
 	start := strings.Index(normalized, heading)
 	if start == -1 {
 		return nil
@@ -201,7 +216,7 @@ func extractChecklistItems(content, heading string) []CheckItem {
 }
 
 func extractChecklistSection(content, heading string) []string {
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	normalized := normalizeLineEndings(content)
 	start := strings.Index(normalized, heading)
 	if start == -1 {
 		return nil

package/internal/data/parser_test.go

@@ -146,7 +146,7 @@ objective: "Style the board"
 	}
 }
 
-func TestParseTaskFile_rejectsPhaseOutsideInProgress(t *testing.T) {
+func TestParseTaskFile_allowsPhaseOutsideInProgress(t *testing.T) {
 	p := NewParser()
 	content := `---
 id: E06/T001
@@ -158,12 +158,12 @@ objective: "Style the board"
 # Task`
 
 	_, err := p.ParseTaskFile("test.md", content)
-	if err == nil {
-		t.Fatal("ParseTaskFile() expected invalid phase/status error")
+	if err != nil {
+		t.Fatalf("ParseTaskFile() error = %v, want no error for legacy phase field", err)
 	}
 }
 
-func TestParseTaskFile_rejectsInProgressWithoutPhase(t *testing.T) {
+func TestParseTaskFile_includesDefaultBuildForInProgress(t *testing.T) {
 	p := NewParser()
 	content := `---
 id: E06/T001
@@ -173,9 +173,33 @@ objective: "Style the board"
 
 # Task`
 
-	_, err := p.ParseTaskFile("test.md", content)
-	if err == nil {
-		t.Fatal("ParseTaskFile() expected missing phase error")
+	task, err := p.ParseTaskFile("test.md", content)
+	if err != nil {
+		t.Fatalf("ParseTaskFile() error = %v", err)
+	}
+	if task.Stage != StageBuild {
+		t.Fatalf("ParseTaskFile() expected StageBuild default, got %q", task.Stage)
+	}
+}
+
+func TestParseTaskFile_prefersPhaseOverLegacyStage(t *testing.T) {
+	p := NewParser()
+	content := `---
+id: E06/T001
+status: in_progress
+stage: build
+phase: test
+objective: "Style the board"
+---
+
+# Task`
+
+	task, err := p.ParseTaskFile("test.md", content)
+	if err != nil {
+		t.Fatalf("ParseTaskFile() error = %v", err)
+	}
+	if task.Stage != StageTest {
+		t.Fatalf("Task.Stage = %q, want test from phase", task.Stage)
 	}
 }
 

package/internal/data/task.go

@@ -26,15 +26,6 @@ const (
 	StageAudit ProgressStage = "audit"
 )
 
-type TaskStatus string
-
-const (
-	StatusPlanned    TaskStatus = "planned"
-	StatusInProgress TaskStatus = "in_progress"
-	StatusDone       TaskStatus = "done"
-	StatusAudited    TaskStatus = "audited"
-)
-
 type Progress struct {
 	Stage   ProgressStage `yaml:"stage"`
 	Started bool          `yaml:"started"`

package/internal/data/write.go

@@ -11,9 +11,88 @@ import (
 )
 
 var ErrMtimeConflict = fmt.Errorf("file modified since last read")
+var ErrProposalNotFound = fmt.Errorf("target text not found in file")
+
+// ApplyProposal replaces the first occurrence of old with newText in the file at path.
+func ApplyProposal(path, old, newText string) error {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("read %s: %w", path, err)
+	}
+	normalized := normalizeLineEndings(string(content))
+	if !strings.Contains(normalized, old) {
+		return fmt.Errorf("%w: %s", ErrProposalNotFound, path)
+	}
+	updated := strings.Replace(normalized, old, newText, 1)
+	return os.WriteFile(path, []byte(updated), 0644)
+}
+
+// UpdateEpicStatus sets the status field in the frontmatter of an E##-Detail.md file.
+func UpdateEpicStatus(path, status string) error {
+	return updateFrontmatterField(path, "status", status)
+}
+
+// UpdateLastAudited sets the last_audited field in the frontmatter of Design.md.
+func UpdateLastAudited(path, value string) error {
+	return updateFrontmatterField(path, "last_audited", value)
+}
+
+// SplitFrontmatterBody splits content into frontmatter YAML and body.
+func SplitFrontmatterBody(content string) (yamlStr string, body string, err error) {
+	normalized := normalizeLineEndings(content)
+	raw, err := extractFrontmatter(normalized)
+	if err != nil {
+		return "", "", err
+	}
+	delimLen := 4
+	bodyStart := delimLen + len(raw) + delimLen
+	body = ""
+	if bodyStart < len(normalized) {
+		body = normalized[bodyStart:]
+	}
+	return raw, body, nil
+}
+
+func updateFrontmatterField(path, key, value string) error {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("read %s: %w", path, err)
+	}
+
+	normalized := normalizeLineEndings(string(content))
+
+	raw, body, err := SplitFrontmatterBody(normalized)
+	if err != nil {
+		return fmt.Errorf("extract frontmatter: %w", err)
+	}
+
+	var doc yaml.Node
+	if err := yaml.Unmarshal([]byte(raw), &doc); err != nil {
+		return fmt.Errorf("parse yaml: %w", err)
+	}
+
+	if doc.Kind != yaml.DocumentNode || len(doc.Content) == 0 {
+		return fmt.Errorf("unexpected yaml structure")
+	}
+
+	mapping := doc.Content[0]
+	if mapping.Kind != yaml.MappingNode {
+		return fmt.Errorf("frontmatter is not a mapping")
+	}
+
+	setMappingField(mapping, key, value)
+
+	out, err := yaml.Marshal(&doc)
+	if err != nil {
+		return fmt.Errorf("marshal yaml: %w", err)
+	}
+
+	newContent := "---\n" + strings.TrimSpace(string(out)) + "\n---" + body
+	return os.WriteFile(path, []byte(newContent), 0644)
+}
 
 func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
-	if err := ValidateTaskLifecycle(*task); err != nil {
+	if err := ValidateTaskLifecycle(task); err != nil {
 		return err
 	}
 
@@ -31,9 +110,9 @@ func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
 		return fmt.Errorf("read %s: %w", path, err)
 	}
 
-	normalized := strings.ReplaceAll(string(content), "\r\n", "\n")
+	normalized := normalizeLineEndings(string(content))
 
-	raw, err := extractFrontmatter(normalized)
+	raw, body, err := SplitFrontmatterBody(normalized)
 	if err != nil {
 		return fmt.Errorf("extract frontmatter: %w", err)
 	}
@@ -56,8 +135,10 @@ func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
 
 	if task.Stage == "" {
 		removeMappingField(mapping, "phase")
+		removeMappingField(mapping, "stage")
 	} else {
 		setMappingField(mapping, "phase", string(task.Stage))
+		removeMappingField(mapping, "stage")
 	}
 
 	out, err := yaml.Marshal(&doc)
@@ -65,13 +146,6 @@ func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
 		return fmt.Errorf("marshal yaml: %w", err)
 	}
 
-	delimLen := 4
-	bodyStart := delimLen + len(raw) + delimLen
-	body := ""
-	if bodyStart < len(normalized) {
-		body = normalized[bodyStart:]
-	}
-
 	newContent := "---\n" + strings.TrimSpace(string(out)) + "\n---" + body
 
 	return os.WriteFile(path, []byte(newContent), 0644)
@@ -115,7 +189,7 @@ func WriteRouterState(root string, state *RouterState, expectedMtime time.Time)
 		return fmt.Errorf("read %s: %w", path, err)
 	}
 
-	normalized := strings.ReplaceAll(string(content), "\r\n", "\n")
+	normalized := normalizeLineEndings(string(content))
 
 	startIdx := strings.Index(normalized, stateBlockStart)
 	if startIdx == -1 {