devrites 3.0.6 → 3.1.0

package/engine/internal/state/state_test.go

@@ -6,7 +6,9 @@ package state
 
 import (
 	"os"
+	"os/exec"
 	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 )
@@ -34,8 +36,17 @@ func TestLifecycleRegistryOwnsOrderAndResumeCommands(t *testing.T) {
 	if len(phases) == 0 || phases[0] != PhaseFrame || phases[len(phases)-1] != PhaseDone {
 		t.Fatalf("LifecyclePhases()=%v, want frame...done", phases)
 	}
-	if got := ResumeVerb(PhasePlan); got != "define" {
-		t.Fatalf("ResumeVerb(plan)=%q, want define", got)
+	wantPrefix := []Phase{PhaseFrame, PhaseSpec, PhaseClarify, PhaseTemper, PhaseDefine}
+	if len(phases) < len(wantPrefix) {
+		t.Fatalf("LifecyclePhases()=%v, want prefix %v", phases, wantPrefix)
+	}
+	for i, want := range wantPrefix {
+		if phases[i] != want {
+			t.Fatalf("LifecyclePhases()[%d]=%q, want %q (full=%v)", i, phases[i], want, phases)
+		}
+	}
+	if got := ResumeVerb(PhasePlan); got != "vet" {
+		t.Fatalf("ResumeVerb(plan)=%q, want vet", got)
 	}
 	if got := ResumeVerb(PhaseDone); got != "" {
 		t.Fatalf("ResumeVerb(done)=%q, want empty", got)
@@ -47,14 +58,99 @@ func TestLifecycleRegistryOwnsOrderAndResumeCommands(t *testing.T) {
 	}
 }
 
+func TestPrebuildWorkspaceRequirementsAreEnforcedByPhase(t *testing.T) {
+	requireFiles := func(phase Phase, names ...string) {
+		t.Helper()
+		definition, ok := definitionFor(phase)
+		if !ok {
+			t.Fatalf("missing phase definition for %q", phase)
+		}
+		got := make(map[string]bool, len(definition.workspaceRequired))
+		for _, name := range definition.workspaceRequired {
+			got[name] = true
+		}
+		for _, name := range names {
+			if !got[name] {
+				t.Errorf("phase %q does not require %s: %v", phase, name, definition.workspaceRequired)
+			}
+		}
+	}
+
+	requireFiles(PhaseClarify, "decision-coverage.md")
+	requireFiles(PhaseTemper, "decision-coverage.md")
+	requireFiles(PhasePlan, "decision-coverage.md")
+	requireFiles(PhaseVet, "decision-coverage.md", "eng-review.md", "test-plan.md")
+	requireFiles(PhaseBuild, "decision-coverage.md", "eng-review.md", "test-plan.md")
+}
+
+func TestRuntimeCompletenessUsesWorkspaceRequiredFiles(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	for name, body := range map[string]string{
+		"state.md":     "| Key | Value |\n| --- | --- |\n| phase | vet |\n",
+		"spec.md":      "# Spec\n\nreal\n",
+		"plan.md":      "# Plan\n\nreal\n",
+		"decisions.md": "# Decisions\n\nreal\n",
+		"tasks.md":     "# Tasks\n\nreal\n",
+	} {
+		writeWorkSection(t, root, "missing-vet", name, body)
+	}
+
+	report, err := Status(root, "missing-vet")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if report.Complete() {
+		t.Fatal("legacy sections made a vet workspace complete without workspaceRequired artifacts")
+	}
+	got := strings.Join(report.MissingFiles, ",")
+	for _, want := range []string{"brief.md", "decision-coverage.md", "eng-review.md", "test-plan.md"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("MissingFiles=%v, want %s", report.MissingFiles, want)
+		}
+	}
+
+	snap, err := Snapshot(root, "missing-vet")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if snap.Complete || len(snap.MissingFiles) == 0 {
+		t.Fatalf("snapshot complete=%v missingFiles=%v, want incomplete", snap.Complete, snap.MissingFiles)
+	}
+}
+
+func TestRuntimeCompletenessRejectsEmptyRequiredFile(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	for _, name := range RequiredWorkspaceFiles(PhaseClarify) {
+		body := "# " + name + "\n\nreal\n"
+		if name == "decision-coverage.md" {
+			body = ""
+		}
+		writeWorkSection(t, root, "empty-coverage", name, body)
+	}
+	writeWorkSection(t, root, "empty-coverage", "state.md", "| phase | clarify |\n")
+
+	report, err := Status(root, "empty-coverage")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if report.Complete() || !slices.Contains(report.MissingFiles, "decision-coverage.md") {
+		t.Fatalf("complete=%v missing=%v, want empty coverage missing", report.Complete(), report.MissingFiles)
+	}
+}
+
 func TestLifecycleRegistryInvariants(t *testing.T) {
 	phaseNames := map[Phase]bool{}
 	aliases := map[string]Phase{}
+	transitionRights := map[string]Phase{}
 	for i, definition := range phaseDefinitions {
 		if definition.phase == "" || phaseNames[definition.phase] {
 			t.Fatalf("phase definition %d has empty or duplicate ID %q", i, definition.phase)
 		}
 		phaseNames[definition.phase] = true
+		if definition.transitionRight == "" || transitionRights[definition.transitionRight] != "" {
+			t.Fatalf("phase %q has empty or duplicate transition right %q", definition.phase, definition.transitionRight)
+		}
+		transitionRights[definition.transitionRight] = definition.phase
 		if len(definition.workspaceRequired) == 0 {
 			t.Fatalf("phase %q has no workspace requirements", definition.phase)
 		}
@@ -106,7 +202,29 @@ func TestStatusFixtureSpecComplete(t *testing.T) {
 		t.Fatal(err)
 	}
 	if !rep.Complete() {
-		t.Errorf("Complete() = false, want true (missing: %v)", rep.Missing)
+		t.Errorf("Complete() = false, want true (missing sections: %v, files: %v)", rep.Missing, rep.MissingFiles)
+	}
+}
+
+func TestCanonicalWorkspaceCompletenessUsesConcretePhaseFiles(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	writeWorkSection(t, root, "live", "state.md", "| Key | Value |\n| --- | --- |\n| phase | vet |\n")
+	writeWorkSection(t, root, "live", "spec.md", "# Spec\n\nReady.\n")
+	writeWorkSection(t, root, "live", "plan.md", "# Plan\n\nReady.\n")
+	writeWorkSection(t, root, "live", "decisions.md", "# Decisions\n\nReady.\n")
+	writeWorkSection(t, root, "live", "tasks.md", "# Tasks\n\nReady.\n")
+
+	rep, err := Status(root, "live")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rep.Complete() {
+		t.Fatal("canonical vet workspace without decision/readiness artifacts reported complete")
+	}
+	for _, name := range []string{"decision-coverage.md", "eng-review.md", "test-plan.md"} {
+		if !slices.Contains(rep.MissingFiles, name) {
+			t.Errorf("MissingFiles = %v, want %s", rep.MissingFiles, name)
+		}
 	}
 }
 
@@ -306,9 +424,17 @@ func TestLoadFeatureRejectsBadFrontmatter(t *testing.T) {
 
 func TestLoadFeatureAcceptsSupportedSchemaVersion(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
-	writeFeatureMD(t, root, "ok", "---\nphase: spec\nschemaVersion: 1\n---\n")
+	writeFeatureMD(t, root, "ok", "---\nphase: spec\nschemaVersion: 2\n---\n")
 	if _, err := Status(root, "ok"); err != nil {
-		t.Errorf("Status on schemaVersion 1 = %v, want nil", err)
+		t.Errorf("Status on schemaVersion 2 = %v, want nil", err)
+	}
+}
+
+func TestLoadFeatureAcceptsOlderSchemaUntilMigration(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	writeFeatureMD(t, root, "old", "---\nphase: spec\nschemaVersion: 1\n---\n")
+	if _, err := Status(root, "old"); err != nil {
+		t.Errorf("Status on additive schemaVersion 1 = %v, want nil", err)
 	}
 }
 
@@ -351,12 +477,66 @@ func TestResolveRootAcceptsProjectRootOrDevritesRoot(t *testing.T) {
 		if err != nil {
 			t.Fatalf("ResolveRoot(%q): %v", in, err)
 		}
-		if got != root {
-			t.Fatalf("ResolveRoot(%q) = %q, want %q", in, got, root)
+		want, err := filepath.EvalSymlinks(root)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got != want {
+			t.Fatalf("ResolveRoot(%q) = %q, want canonical %q", in, got, want)
 		}
 	}
 }
 
+func TestResolveRootUsesExplicitOverrideBeforeGitBoundedImplicitRoot(t *testing.T) {
+	base := t.TempDir()
+	implicitProject := filepath.Join(base, "implicit")
+	explicitProject := filepath.Join(base, "explicit")
+	for _, project := range []string{implicitProject, explicitProject} {
+		if err := os.MkdirAll(filepath.Join(project, ".devrites"), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		cmd := exec.Command("git", "-C", project, "init", "-q")
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git init: %v\n%s", err, out)
+		}
+	}
+	old, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chdir(implicitProject); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = os.Chdir(old) })
+
+	implicit, err := ResolveRoot("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	explicit, err := ResolveRoot(explicitProject)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if implicit == explicit {
+		t.Fatalf("explicit override %q did not replace implicit root %q", explicit, implicit)
+	}
+	if want, _ := filepath.EvalSymlinks(filepath.Join(explicitProject, ".devrites")); explicit != want {
+		t.Fatalf("explicit root = %q, want %q", explicit, want)
+	}
+}
+
+func TestResolveRootRejectsExternalWorkspaceOverride(t *testing.T) {
+	project := t.TempDir()
+	root := filepath.Join(project, ".devrites")
+	if err := os.MkdirAll(root, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("DEVRITES_WORKSPACE", filepath.Join(t.TempDir(), "feature"))
+	if _, err := ResolveRoot(project); err == nil || !strings.Contains(err.Error(), "unsafe DevRites root") {
+		t.Fatalf("ResolveRoot error = %v, want unsafe external workspace refusal", err)
+	}
+}
+
 func TestDevritesWorkspaceOverridesActiveFeature(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
 	writeWorkSection(t, root, "explicit", "state.md", "- Phase: spec\n")

package/engine/internal/state/status.go

@@ -10,8 +10,10 @@ import (
 // required set and the missing sections.
 type Report struct {
 	*Feature
-	Required map[Section]bool
-	Missing  []Section // required-but-empty sections, in Sections order
+	Required      map[Section]bool
+	Missing       []Section // legacy required-but-empty sections, in Sections order
+	RequiredFiles map[string]bool
+	MissingFiles  []string // required-but-empty workspace files, in lifecycle order
 }
 
 // Status computes the status report for feature <slug> under root by reading
@@ -32,7 +34,21 @@ func NewReport(f *Feature) *Report {
 	for _, s := range RequiredSections(f.Phase) {
 		required[s] = true
 	}
-	return &Report{Feature: f, Required: required, Missing: MissingFor(f, f.Phase)}
+	requiredFiles := make(map[string]bool)
+	var missingFiles []string
+	if !f.LegacyLayout {
+		for _, name := range RequiredWorkspaceFiles(f.Phase) {
+			requiredFiles[name] = true
+		}
+		missingFiles = MissingWorkspaceFiles(f, f.Phase)
+	}
+	return &Report{
+		Feature:       f,
+		Required:      required,
+		Missing:       MissingFor(f, f.Phase),
+		RequiredFiles: requiredFiles,
+		MissingFiles:  missingFiles,
+	}
 }
 
 // MissingFor returns the sections required to complete phase p that the feature
@@ -54,9 +70,28 @@ func MissingFor(f *Feature, p Phase) []Section {
 	return missing
 }
 
-// Complete reports whether every section required by the current phase has
-// real content.
-func (r *Report) Complete() bool { return len(r.Missing) == 0 }
+// MissingWorkspaceFiles returns the concrete lifecycle artifacts required for
+// p that do not contain real content. It is the authoritative runtime
+// completeness view; Section completeness remains only a compact legacy view.
+func MissingWorkspaceFiles(f *Feature, p Phase) []string {
+	var missing []string
+	for _, name := range RequiredWorkspaceFiles(p) {
+		if !f.PresentFiles[name] {
+			missing = append(missing, name)
+		}
+	}
+	return missing
+}
+
+// Complete reports whether every concrete canonical-workspace file required by
+// the current phase has real content. Compatibility features/ workspaces keep
+// their legacy section-based contract until migration moves them to work/.
+func (r *Report) Complete() bool {
+	if r.LegacyLayout {
+		return len(r.Missing) == 0
+	}
+	return len(r.MissingFiles) == 0
+}
 
 // Render produces the deterministic, greppable status text, including a
 // trailing newline. Each section line reads "<name> <present|empty> [required]".
@@ -79,12 +114,14 @@ func (r *Report) Render() string {
 	}
 	if r.Complete() {
 		b.WriteString("result: complete\n")
-	} else {
-		names := make([]string, len(r.Missing))
-		for i, s := range r.Missing {
-			names[i] = string(s)
+	} else if r.LegacyLayout {
+		missing := make([]string, len(r.Missing))
+		for i, section := range r.Missing {
+			missing[i] = string(section)
 		}
-		fmt.Fprintf(&b, "result: incomplete (missing: %s)\n", strings.Join(names, ", "))
+		fmt.Fprintf(&b, "result: incomplete (missing: %s)\n", strings.Join(missing, ", "))
+	} else {
+		fmt.Fprintf(&b, "result: incomplete (missing files: %s)\n", strings.Join(r.MissingFiles, ", "))
 	}
 	return b.String()
 }