savepoint 1.0.2 → 1.0.3

package/internal/doctor/gates.go

@@ -0,0 +1,193 @@
+package doctor
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// GateResult holds the outcome of a single quality gate.
+type GateResult struct {
+	Name     string
+	Command  string
+	Passed   bool
+	ExitCode int
+	Output   string
+}
+
+// RunQualityGates executes configured quality gates (lint, typecheck, test).
+func RunQualityGates(root string, overrides ...DoctorDependencies) []GateResult {
+	deps := doctorDependencies(overrides)
+	configPath := filepath.Join(root, "config.yml")
+	cfg, err := deps.ConfigReader.Read(configPath)
+	if err != nil {
+		return []GateResult{{
+			Name:    "config",
+			Command: "",
+			Passed:  false,
+			Output:  fmt.Sprintf("cannot read config: %v", err),
+		}}
+	}
+
+	timeout := 60 * time.Second
+	if cfg.QualityGates.Timeout != "" {
+		if d, err := time.ParseDuration(cfg.QualityGates.Timeout); err == nil {
+			timeout = d
+		}
+	}
+
+	var results []GateResult
+
+	if cfg.QualityGates.Lint != nil && *cfg.QualityGates.Lint != "" {
+		results = append(results, runGate("lint", *cfg.QualityGates.Lint, root, timeout))
+	}
+	if cfg.QualityGates.Typecheck != nil && *cfg.QualityGates.Typecheck != "" {
+		results = append(results, runGate("typecheck", *cfg.QualityGates.Typecheck, root, timeout))
+	}
+	if cfg.QualityGates.Test != nil && *cfg.QualityGates.Test != "" {
+		results = append(results, runGate("test", *cfg.QualityGates.Test, root, timeout))
+	}
+
+	if len(results) == 0 {
+		results = append(results, GateResult{
+			Name:    "quality_gates",
+			Command: "",
+			Passed:  true,
+			Output:  "no quality gates configured",
+		})
+	}
+
+	return results
+}
+
+func runGate(name, command string, root string, timeout time.Duration) GateResult {
+	parts := splitCommand(command)
+	if len(parts) == 0 {
+		return GateResult{
+			Name:    name,
+			Command: command,
+			Passed:  false,
+			Output:  "empty command",
+		}
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, parts[0], parts[1:]...)
+	cmd.Dir = root
+	cmd.Env = os.Environ()
+
+	output, err := cmd.CombinedOutput()
+	outStr := strings.TrimSpace(string(output))
+
+	switch {
+	case err != nil && ctx.Err() == context.DeadlineExceeded:
+		return GateResult{
+			Name:    name,
+			Command: command,
+			Passed:  false,
+			Output:  fmt.Sprintf("timed out after %v", timeout),
+		}
+	case err != nil:
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			return GateResult{
+				Name:     name,
+				Command:  command,
+				Passed:   false,
+				ExitCode: exitErr.ExitCode(),
+				Output:   outStr,
+			}
+		}
+		return GateResult{
+			Name:    name,
+			Command: command,
+			Passed:  false,
+			Output:  fmt.Sprintf("failed to execute: %v", err),
+		}
+	default:
+		return GateResult{
+			Name:     name,
+			Command:  command,
+			Passed:   true,
+			ExitCode: 0,
+			Output:   outStr,
+		}
+	}
+}
+
+func splitCommand(command string) []string {
+	var parts []string
+	current := strings.Builder{}
+	inDoubleQuote := false
+	inSingleQuote := false
+	tokenStarted := false
+
+	flush := func() {
+		if tokenStarted || current.Len() > 0 {
+			parts = append(parts, current.String())
+			current.Reset()
+			tokenStarted = false
+		}
+	}
+
+	for i := 0; i < len(command); i++ {
+		c := command[i]
+
+		if inSingleQuote {
+			tokenStarted = true
+			if c == '\'' {
+				inSingleQuote = false
+			} else {
+				current.WriteByte(c)
+			}
+			continue
+		}
+
+		if inDoubleQuote {
+			tokenStarted = true
+			if c == '\\' && i+1 < len(command) {
+				next := command[i+1]
+				if next == '"' || next == '\\' || next == '$' || next == '`' {
+					i++
+					current.WriteByte(command[i])
+					continue
+				}
+			}
+			if c == '"' {
+				inDoubleQuote = false
+				continue
+			}
+			current.WriteByte(c)
+			continue
+		}
+
+		switch c {
+		case '\\':
+			tokenStarted = true
+			if i+1 < len(command) {
+				i++
+				current.WriteByte(command[i])
+			} else {
+				current.WriteByte(c)
+			}
+		case '"':
+			tokenStarted = true
+			inDoubleQuote = true
+		case '\'':
+			tokenStarted = true
+			inSingleQuote = true
+		case ' ', '\t', '\n', '\r':
+			flush()
+		default:
+			tokenStarted = true
+			current.WriteByte(c)
+		}
+	}
+	flush()
+	return parts
+}

package/internal/doctor/gates_test.go

@@ -0,0 +1,166 @@
+package doctor
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func writeConfig(t *testing.T, root, content string) {
+	t.Helper()
+	if err := os.WriteFile(filepath.Join(root, "config.yml"), []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRunQualityGates_NoConfig(t *testing.T) {
+	root := t.TempDir()
+	results := RunQualityGates(root)
+	if len(results) != 1 {
+		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
+	}
+	if !results[0].Passed {
+		t.Fatalf("RunQualityGates() = %v, want passed (default config has no gates)", results[0])
+	}
+	if !strings.Contains(results[0].Output, "no quality gates configured") {
+		t.Fatalf("RunQualityGates() output = %q, want 'no quality gates configured'", results[0].Output)
+	}
+}
+
+func TestRunQualityGates_AllNull(t *testing.T) {
+	root := t.TempDir()
+	writeConfig(t, root, "quality_gates:\n  lint: null\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
+
+	results := RunQualityGates(root)
+	if len(results) != 1 {
+		t.Fatalf("RunQualityGates() = %d results, want 1 (no gates configured)", len(results))
+	}
+	if !results[0].Passed {
+		t.Fatalf("RunQualityGates() = %v, want passed with 'no gates configured'", results[0])
+	}
+	if !strings.Contains(results[0].Output, "no quality gates configured") {
+		t.Fatalf("RunQualityGates() output = %q, want 'no quality gates configured'", results[0].Output)
+	}
+}
+
+func TestRunQualityGates_LintOnly(t *testing.T) {
+	root := t.TempDir()
+	writeConfig(t, root, "quality_gates:\n  lint: \"go version\"\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
+
+	results := RunQualityGates(root)
+	if len(results) != 1 {
+		t.Fatalf("RunQualityGates() = %d results, want 1 (lint only)", len(results))
+	}
+	if !results[0].Passed {
+		t.Fatalf("RunQualityGates() lint should pass: %v", results[0])
+	}
+	if results[0].Name != "lint" {
+		t.Fatalf("RunQualityGates()[0].Name = %q, want \"lint\"", results[0].Name)
+	}
+}
+
+func TestRunQualityGates_AllThree(t *testing.T) {
+	root := t.TempDir()
+	writeConfig(t, root, "quality_gates:\n  lint: \"go version\"\n  typecheck: \"go version\"\n  test: \"go version\"\ntheme:\n  bg: \"#000\"\n")
+
+	results := RunQualityGates(root)
+	if len(results) != 3 {
+		t.Fatalf("RunQualityGates() = %d results, want 3", len(results))
+	}
+	for _, r := range results {
+		if !r.Passed {
+			t.Fatalf("RunQualityGates() %s should pass: %v", r.Name, r)
+		}
+	}
+}
+
+func TestRunQualityGates_FailingCommand(t *testing.T) {
+	root := t.TempDir()
+	writeConfig(t, root, "quality_gates:\n  lint: \"cmd-that-does-not-exist-12345\"\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
+
+	results := RunQualityGates(root)
+	if len(results) != 1 {
+		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
+	}
+	if results[0].Passed {
+		t.Fatal("RunQualityGates() should fail for non-existent command")
+	}
+}
+
+func TestRunQualityGates_ExitCodeNonZero(t *testing.T) {
+	root := t.TempDir()
+	writeConfig(t, root, "quality_gates:\n  lint: \"go vet\"\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
+	// Write a bad Go file so go vet fails
+	badPath := filepath.Join(root, "bad.go")
+	os.WriteFile(badPath, []byte("package x\n\nfunc f() { return 1 }\n"), 0644)
+
+	results := RunQualityGates(root)
+	if len(results) != 1 {
+		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
+	}
+	if results[0].Passed {
+		t.Fatal("RunQualityGates() should fail when go vet fails")
+	}
+}
+
+func TestRunQualityGates_Timeout(t *testing.T) {
+	root := t.TempDir()
+	writeConfig(t, root, "quality_gates:\n  lint: \"go test -test.run TestNonexistent -count=1 ./...\"\n  gate_timeout: \"1ns\"\ntheme:\n  bg: \"#000\"\n")
+
+	results := RunQualityGates(root)
+	if len(results) != 1 {
+		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
+	}
+	if results[0].Passed {
+		t.Fatal("RunQualityGates() should fail due to timeout")
+	}
+	if !strings.Contains(results[0].Output, "timed out") {
+		t.Fatalf("RunQualityGates() output = %q, want 'timed out'", results[0].Output)
+	}
+}
+
+func TestRunQualityGates_DefaultTimeout(t *testing.T) {
+	root := t.TempDir()
+	writeConfig(t, root, "quality_gates:\n  lint: \"go version\"\n  # no gate_timeout set — uses 60s default\ntheme:\n  bg: \"#000\"\n")
+
+	results := RunQualityGates(root)
+	if len(results) != 1 {
+		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
+	}
+	if !results[0].Passed {
+		t.Fatalf("RunQualityGates() lint should pass with default timeout: %v", results[0])
+	}
+}
+
+func TestSplitCommand(t *testing.T) {
+	tests := []struct {
+		input string
+		want  []string
+	}{
+		{"echo hello", []string{"echo", "hello"}},
+		{"go test ./...", []string{"go", "test", "./..."}},
+		{"\"c:\\program files\\go\\bin\\go\"", []string{"c:\\program files\\go\\bin\\go"}},
+		{"echo 'hello world'", []string{"echo", "hello world"}},
+		{"echo \"hello \\\"world\\\"\"", []string{"echo", "hello \"world\""}},
+		{"echo hello\\ world", []string{"echo", "hello world"}},
+		{"echo 'it''s'", []string{"echo", "its"}},
+		{"go test -run \"\" ./...", []string{"go", "test", "-run", "", "./..."}},
+		{"printf ''", []string{"printf", ""}},
+		{"echo trailing\\", []string{"echo", "trailing\\"}},
+		{"", nil},
+		{"   ", nil},
+	}
+	for _, tt := range tests {
+		got := splitCommand(tt.input)
+		if len(got) != len(tt.want) {
+			t.Errorf("splitCommand(%q) = %v, want %v", tt.input, got, tt.want)
+			continue
+		}
+		for i := range got {
+			if got[i] != tt.want[i] {
+				t.Errorf("splitCommand(%q)[%d] = %q, want %q", tt.input, i, got[i], tt.want[i])
+			}
+		}
+	}
+}

package/internal/doctor/interfaces.go

@@ -0,0 +1,64 @@
+package doctor
+
+import "github.com/opencode/savepoint/internal/data"
+
+// taskDiscoverer provides project traversal for doctor checks.
+type taskDiscoverer interface {
+	ListRootDirs(root 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 for doctor checks.
+type taskParser interface {
+	ParseFrontmatter(content string) (map[string]any, error)
+}
+
+// configReader reads quality gate 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)
+}
+
+// DoctorDependencies contains doctor data-access dependencies.
+type DoctorDependencies struct {
+	Discoverer   taskDiscoverer
+	Parser       taskParser
+	ConfigReader configReader
+	RouterReader routerReader
+}
+
+func defaultDoctorDependencies() DoctorDependencies {
+	return DoctorDependencies{
+		Discoverer:   data.NewDiscover(),
+		Parser:       data.NewParser(),
+		ConfigReader: data.NewConfigReader(),
+		RouterReader: data.NewRouterReader(),
+	}
+}
+
+func doctorDependencies(overrides []DoctorDependencies) DoctorDependencies {
+	deps := defaultDoctorDependencies()
+	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/doctor/interfaces_test.go

@@ -0,0 +1,104 @@
+package doctor
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/testutil"
+)
+
+type stubDoctorRouterReader struct {
+	state *data.RouterState
+	calls int
+}
+
+func (r *stubDoctorRouterReader) ReadState(content string) (*data.RouterState, error) {
+	r.calls++
+	return r.state, nil
+}
+
+type stubDoctorDiscoverer struct {
+	releases []data.ReleaseInfo
+	epics    map[string][]data.EpicInfo
+	tasks    map[string][]data.TaskInfo
+	calls    int
+}
+
+func (d *stubDoctorDiscoverer) ListRootDirs(root string) ([]string, error) {
+	d.calls++
+	return nil, nil
+}
+
+func (d *stubDoctorDiscoverer) ListReleases(root string) ([]data.ReleaseInfo, error) {
+	d.calls++
+	return d.releases, nil
+}
+
+func (d *stubDoctorDiscoverer) ListEpics(root, release string) ([]data.EpicInfo, error) {
+	d.calls++
+	return d.epics[release], nil
+}
+
+func (d *stubDoctorDiscoverer) ListTasks(root, release, epic string) ([]data.TaskInfo, error) {
+	d.calls++
+	return d.tasks[release+"/"+epic], nil
+}
+
+type countingDoctorParser struct {
+	parser *data.Parser
+	calls  int
+}
+
+func (p *countingDoctorParser) ParseFrontmatter(content string) (map[string]any, error) {
+	p.calls++
+	return p.parser.ParseFrontmatter(content)
+}
+
+func TestCheckRouterUsesInjectedRouterReader(t *testing.T) {
+	root := t.TempDir()
+	testutil.WriteFile(t, filepath.Join(root, "router.md"), "# intentionally not a router state block")
+	testutil.MkdirAll(t, filepath.Join(root, "releases", "v9", "epics", "E01-mock"))
+
+	reader := &stubDoctorRouterReader{state: &data.RouterState{
+		State:   "task-building",
+		Release: "v9",
+		Epic:    "E01-mock",
+	}}
+
+	if err := CheckRouter(root, "", DoctorDependencies{RouterReader: reader}); err != nil {
+		t.Fatalf("CheckRouter() with injected reader = %v, want nil", err)
+	}
+	if reader.calls != 1 {
+		t.Fatalf("ReadState calls = %d, want 1", reader.calls)
+	}
+}
+
+func TestCheckDependenciesUsesInjectedDiscovererAndParser(t *testing.T) {
+	root := t.TempDir()
+	taskPath := filepath.Join(root, "virtual", "T001-task.md")
+	testutil.MkdirAll(t, filepath.Dir(taskPath))
+	testutil.WriteFile(t, taskPath, "---\nid: E01-mock/T001-task\nstatus: planned\nobjective: Mock\ndepends_on: []\n---\n")
+
+	discoverer := &stubDoctorDiscoverer{
+		releases: []data.ReleaseInfo{{ID: "v9", Path: filepath.Join(root, "virtual-release")}},
+		epics: map[string][]data.EpicInfo{
+			"v9": {{ID: "E01-mock", Path: filepath.Join(root, "virtual-epic")}},
+		},
+		tasks: map[string][]data.TaskInfo{
+			"v9/E01-mock": {{ID: "T001-task", Path: taskPath}},
+		},
+	}
+	parser := &countingDoctorParser{parser: data.NewParser()}
+
+	problems := CheckDependencies(root, "", DoctorDependencies{Discoverer: discoverer, Parser: parser})
+	if len(problems) > 0 {
+		t.Fatalf("CheckDependencies() = %v, want no problems", problems)
+	}
+	if discoverer.calls == 0 {
+		t.Fatal("injected discoverer was not used")
+	}
+	if parser.calls != 1 {
+		t.Fatalf("ParseFrontmatter calls = %d, want 1", parser.calls)
+	}
+}

package/internal/doctor/repairs.go

@@ -0,0 +1,80 @@
+package doctor
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func SuggestRepair(err error) string {
+	switch {
+	case errors.Is(err, data.ErrConfigNotFound):
+		return "Run `savepoint init` to scaffold a new project"
+	case errors.Is(err, data.ErrInvalidStatus):
+		return "Set router state to a recognized workflow state (see router.md State → action section)"
+	case errors.Is(err, data.ErrMissingFrontmatter):
+		return "Fix the YAML frontmatter between the --- delimiters"
+	case errors.Is(err, data.ErrStructureProblem):
+		return "Review the file and fix the reported issue"
+	}
+
+	msg := err.Error()
+	switch {
+	case strings.Contains(msg, "config.yml not found"):
+		return "Run `savepoint init` to scaffold a new project"
+	case strings.Contains(msg, "config.yml missing required field"):
+		return "Add the missing field to config.yml — see the project template for reference"
+	case strings.Contains(msg, "invalid YAML"):
+		return "Fix the YAML syntax error at the indicated line"
+	case strings.Contains(msg, "router.md not found"):
+		return "Run `savepoint init` to scaffold a new project"
+	case strings.Contains(msg, "unknown state"):
+		return "Set router state to a recognized workflow state (see router.md State → action section)"
+	case strings.Contains(msg, "release PRD file not found"):
+		return "Create a {release}-PRD.md file with frontmatter for the release"
+	case strings.Contains(msg, "release"):
+		return "Create the release directory at releases/<release-id>/"
+	case strings.Contains(msg, "epic") && strings.Contains(msg, "directory not found"):
+		return "Create the epic directory at releases/<release>/epics/<epic-id>/"
+	case strings.Contains(msg, "epic detail file not found"):
+		return "Create an E##-Detail.md with frontmatter for the epic"
+	case strings.Contains(msg, "invalid frontmatter"):
+		return "Fix the YAML frontmatter between the --- delimiters"
+	case strings.Contains(msg, "task missing required frontmatter field"):
+		return "Add the missing field to the task frontmatter"
+	case strings.Contains(msg, "missing ## Acceptance Criteria"):
+		return "Add an ## Acceptance Criteria section with checkable items"
+	case strings.Contains(msg, "depends_on must be a list"):
+		return "Change depends_on to a YAML list format"
+	case strings.Contains(msg, "references non-existent"):
+		return "Create the referenced task or remove the dependency"
+	case strings.Contains(msg, "duplicate task ID"):
+		return "Rename one of the tasks to have a unique ID"
+	case strings.Contains(msg, "dependency cycle"):
+		return "Break the circular dependency chain between tasks"
+	case strings.Contains(msg, "audit proposal exists"):
+		return "Set router state to audit-pending for the matching epic, or remove stale audit files"
+	case strings.Contains(msg, "orphaned"):
+		return "Move the task directory to the correct epic or create the referenced epic"
+	case strings.Contains(msg, "quality gate"):
+		return "Fix the issue reported by the quality gate tool"
+	default:
+		return "Review the file and fix the reported issue"
+	}
+}
+
+// GateSuggestion returns a command-specific repair hint.
+func GateSuggestion(name string) string {
+	switch name {
+	case "lint":
+		return "Run `make lint` locally and fix reported issues"
+	case "typecheck":
+		return "Run `make typecheck` locally and fix type errors"
+	case "test":
+		return "Run `make test` locally and fix failing tests"
+	default:
+		return fmt.Sprintf("Run %q locally and fix reported issues", name)
+	}
+}

package/internal/doctor/repairs_test.go

@@ -0,0 +1,81 @@
+package doctor
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestSuggestRepair(t *testing.T) {
+	tests := []struct {
+		err      error
+		contains string
+	}{
+		{Problem{Message: "config.yml not found"}, "savepoint init"},
+		{Problem{Message: "config.yml missing required field: theme"}, "Add the missing field"},
+		{Problem{Message: "config.yml invalid YAML: yaml: line 3: could not find expected"}, "Fix the YAML syntax"},
+		{Problem{Message: "router.md not found"}, "savepoint init"},
+		{Problem{Message: "router.md unknown state \"bogus\""}, "Set router state to a recognized"},
+		{Problem{Message: "router.md release \"v99\" directory not found"}, "Create the release directory"},
+		{Problem{Message: "router.md epic \"E99-foo\" directory not found"}, "Create the epic directory"},
+		{Problem{Message: "release PRD file not found"}, "Create a {release}-PRD.md"},
+		{Problem{Message: "epic detail file not found"}, "Create an E##-Detail.md"},
+		{Problem{Message: "invalid frontmatter: yaml: line 5:"}, "Fix the YAML frontmatter"},
+		{Problem{Message: "task missing required frontmatter field: status"}, "Add the missing field"},
+		{Problem{Message: "task missing ## Acceptance Criteria section"}, "Add an ## Acceptance Criteria section"},
+		{Problem{Message: "task frontmatter field depends_on must be a list"}, "Change depends_on to a YAML list"},
+		{Problem{Message: "depends_on references non-existent task \"E99/T999\""}, "Create the referenced task"},
+		{Problem{Message: "duplicate task ID \"E01-foo/T001-task\" (first seen in"}, "Rename one of the tasks"},
+		{Problem{Message: "dependency cycle detected:"}, "Break the circular dependency chain"},
+		{Problem{Message: "audit proposal exists but router state is"}, "Set router state to audit-pending"},
+		{Problem{Message: "orphaned task: epic \"E99-ghost\" does not exist"}, "Move the task directory"},
+		{Problem{Message: "quality gate \"lint\" failed"}, "Fix the issue reported by the quality gate"},
+		{Problem{Message: "some random unknown problem"}, "Review the file and fix"},
+	}
+	for _, tt := range tests {
+		got := SuggestRepair(tt.err)
+		if !strings.Contains(got, tt.contains) {
+			t.Errorf("SuggestRepair(%q) = %q, want containing %q", tt.err.Error(), got, tt.contains)
+		}
+	}
+}
+
+func TestGateSuggestion(t *testing.T) {
+	tests := []struct {
+		name     string
+		contains string
+	}{
+		{"lint", "make lint"},
+		{"typecheck", "make typecheck"},
+		{"test", "make test"},
+		{"custom", "Run \"custom\" locally"},
+	}
+	for _, tt := range tests {
+		got := GateSuggestion(tt.name)
+		if !strings.Contains(got, tt.contains) {
+			t.Errorf("GateSuggestion(%q) = %q, want containing %q", tt.name, got, tt.contains)
+		}
+	}
+}
+
+func TestSuggestRepair_typedErrors(t *testing.T) {
+	tests := []struct {
+		err      error
+		contains string
+	}{
+		{fmt.Errorf("config.yml not found: %w", data.ErrConfigNotFound), "savepoint init"},
+		{fmt.Errorf("router.md not found: %w", data.ErrConfigNotFound), "savepoint init"},
+	}
+	for _, tt := range tests {
+		if !errors.Is(tt.err, data.ErrConfigNotFound) {
+			t.Fatalf("test error should wrap %v", data.ErrConfigNotFound)
+		}
+		got := SuggestRepair(tt.err)
+		if !strings.Contains(got, tt.contains) {
+			t.Errorf("SuggestRepair(%q) = %q, want containing %q", tt.err.Error(), got, tt.contains)
+		}
+	}
+}