devrites 4.0.12 → 4.2.0

package/engine/internal/state/status.go

@@ -6,78 +6,94 @@ import (
 )
 
 // Report is the computed completeness status of a feature at its current phase.
-// It embeds the loaded Feature (Slug, Phase, Present) and adds the phase-relative
-// required set and the missing sections.
 type Report struct {
-	*Feature
+	Slug          string
+	Phase         Phase
 	Required      map[Section]bool
-	Missing       []Section // legacy required-but-empty sections, in Sections order
+	Missing       []Section // required-but-empty sections, in policy order
 	RequiredFiles map[string]bool
 	MissingFiles  []string // required-but-empty workspace files, in lifecycle order
+	present       map[Section]bool
+	diagnostics   []ArtifactDiagnostic
 }
 
-// Status computes the status report for feature <slug> under root by reading
-// the files directly. It reports completeness relative to the feature's current
-// phase only.
+// Status computes phase-relative completeness from one retained workspace observation.
 func Status(root, slug string) (*Report, error) {
-	f, err := LoadFeature(root, slug)
+	return statusWithCallback(root, slug, nil)
+}
+
+func statusWithCallback(root, slug string, callback observationCallback) (*Report, error) {
+	observation, err := observeWorkspace(root, slug, callback)
+	if err != nil {
+		return nil, err
+	}
+	phase, err := observation.DeclaredPhase()
 	if err != nil {
 		return nil, fmt.Errorf("compute status: %w", err)
 	}
-	return NewReport(f), nil
+	policy, _ := PolicyFor(phase)
+	return newObservationReport(observation, phase, policy), nil
 }
 
-// NewReport computes the phase-relative required set and missing sections for a
-// loaded Feature.
-func NewReport(f *Feature) *Report {
-	required := make(map[Section]bool)
-	for _, s := range RequiredSections(f.Phase) {
-		required[s] = true
+func newObservationReport(observation *WorkspaceObservation, phase Phase, policy PhasePolicy) *Report {
+	present := observationSectionPresence(observation)
+	required := requiredSections(policy)
+	requiredFiles := requiredArtifactSet(policy)
+	missingArtifacts, diagnostics := observation.Missing(policy.RequiredArtifacts)
+	missingFiles := make([]string, len(missingArtifacts))
+	for i, artifact := range missingArtifacts {
+		missingFiles[i] = string(artifact)
 	}
-	requiredFiles := make(map[string]bool)
-	for _, name := range RequiredWorkspaceFiles(f.Phase) {
-		requiredFiles[name] = true
-	}
-	missingFiles := MissingWorkspaceFiles(f, f.Phase)
 	return &Report{
-		Feature:       f,
+		Slug:          observation.Slug(),
+		Phase:         phase,
 		Required:      required,
-		Missing:       MissingFor(f, f.Phase),
+		Missing:       missingObservationSections(present, policy.RequiredSections),
 		RequiredFiles: requiredFiles,
 		MissingFiles:  missingFiles,
+		present:       present,
+		diagnostics:   diagnostics,
 	}
 }
 
-// MissingFor returns the sections required to complete phase p that the feature
-// does not yet have real content for, in canonical Sections order. Gates use it
-// to check completeness against a phase other than the feature's current one
-// (e.g. seal always checks the full seal-phase set), so its result is
-// independent of f.Phase.
-func MissingFor(f *Feature, p Phase) []Section {
-	required := make(map[Section]bool)
-	for _, s := range RequiredSections(p) {
-		required[s] = true
+func observationSectionPresence(observation *WorkspaceObservation) map[Section]bool {
+	present := make(map[Section]bool, len(Sections))
+	for _, section := range Sections {
+		for _, name := range sectionFiles[section] {
+			fact, ok := observation.Fact(ArtifactPath(name))
+			if ok && fact.State() == ArtifactPresent {
+				present[section] = true
+				break
+			}
+		}
 	}
+	return present
+}
+
+func missingObservationSections(present map[Section]bool, required []Section) []Section {
 	var missing []Section
-	for _, s := range Sections {
-		if required[s] && !f.Present[s] {
-			missing = append(missing, s)
+	for _, section := range required {
+		if !present[section] {
+			missing = append(missing, section)
 		}
 	}
 	return missing
 }
 
-// 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)
-		}
+func requiredSections(policy PhasePolicy) map[Section]bool {
+	required := make(map[Section]bool, len(policy.RequiredSections))
+	for _, section := range policy.RequiredSections {
+		required[section] = true
 	}
-	return missing
+	return required
+}
+
+func requiredArtifactSet(policy PhasePolicy) map[string]bool {
+	required := make(map[string]bool, len(policy.RequiredArtifacts))
+	for _, artifact := range policy.RequiredArtifacts {
+		required[string(artifact)] = true
+	}
+	return required
 }
 
 // Complete reports whether every concrete canonical-workspace file required by
@@ -92,19 +108,22 @@ func (r *Report) Render() string {
 	var b strings.Builder
 	fmt.Fprintf(&b, "feature: %s\n", r.Slug)
 	fmt.Fprintf(&b, "phase: %s\n", r.Phase)
-	for _, s := range Sections {
+	for _, section := range Sections {
 		state := "empty"
-		if r.Present[s] {
+		if r.present[section] {
 			state = "present"
 		}
 		mark := ""
-		if r.Required[s] {
+		if r.Required[section] {
 			mark = "required"
 		}
-		line := fmt.Sprintf("  %-10s %-8s %s", s, state, mark)
+		line := fmt.Sprintf("  %-10s %-8s %s", section, state, mark)
 		b.WriteString(strings.TrimRight(line, " "))
 		b.WriteByte('\n')
 	}
+	for _, diagnostic := range r.diagnostics {
+		fmt.Fprintf(&b, "artifact: %s: %s (%s)\n", diagnostic.Path, diagnostic.State, diagnostic.Code)
+	}
 	if r.Complete() {
 		b.WriteString("result: complete\n")
 	} else {

package/engine/tests/adr_0004_required_by_phase_test.go

@@ -13,31 +13,34 @@ import (
 )
 
 func TestADR0004RequiredSectionsAreAdditiveDownTheArc(t *testing.T) {
-	phaseArc := state.LifecyclePhases()
-	for _, p := range phaseArc {
-		if !state.KnownPhase(p) {
-			t.Fatalf("phase %q in the arc is not a known phase", p)
+	policies := state.PhasePolicies()
+	for _, policy := range policies {
+		lookedUp, ok := state.PolicyFor(policy.Target)
+		if !ok || lookedUp.Target != policy.Target {
+			t.Fatalf("phase %q in the arc is not a known phase", policy.Target)
 		}
 	}
 
 	// Each phase's required set must contain everything the previous phase
 	// required: completeness only accumulates, never regresses.
-	for i := 1; i < len(phaseArc); i++ {
-		prev := asSet(state.RequiredSections(phaseArc[i-1]))
-		cur := asSet(state.RequiredSections(phaseArc[i]))
-		for s := range prev {
-			if !cur[s] {
+	for i := 1; i < len(policies); i++ {
+		previous := asSet(policies[i-1].RequiredSections)
+		current := asSet(policies[i].RequiredSections)
+		for section := range previous {
+			if !current[section] {
 				t.Errorf("phase %q dropped section %q that %q required: arc must be additive",
-					phaseArc[i], s, phaseArc[i-1])
+					policies[i].Target, section, policies[i-1].Target)
 			}
 		}
 	}
 
 	// Anchors: framing requires nothing; seal requires the full section set.
-	if got := state.RequiredSections(state.PhaseFrame); len(got) != 0 {
-		t.Errorf("frame requires %v, want none", got)
+	frame, _ := state.PolicyFor(state.PhaseFrame)
+	if len(frame.RequiredSections) != 0 {
+		t.Errorf("frame requires %v, want none", frame.RequiredSections)
 	}
-	if got, want := len(state.RequiredSections(state.PhaseSeal)), len(state.Sections); got != want {
+	seal, _ := state.PolicyFor(state.PhaseSeal)
+	if got, want := len(seal.RequiredSections), len(state.Sections); got != want {
 		t.Errorf("seal requires %d sections, want the full set of %d", got, want)
 	}
 }

package/engine/tests/adr_0011_define_plan_test.go

@@ -7,24 +7,26 @@ import (
 )
 
 func TestADR0011DefineAndPlanHaveDistinctTransitionRights(t *testing.T) {
-	if got := state.ResumeVerb(state.PhaseDefine); got != "define" {
-		t.Fatalf("define resumes %q, want define", got)
+	define, ok := state.PolicyFor(state.PhaseDefine)
+	if !ok || define.ResumeVerb != "define" {
+		t.Fatalf("define policy=(%+v,%v), want resume verb define", define, ok)
 	}
-	if got := state.ResumeVerb(state.PhasePlan); got != "vet" {
-		t.Fatalf("plan resumes %q, want vet", got)
+	plan, ok := state.PolicyFor(state.PhasePlan)
+	if !ok || plan.ResumeVerb != "vet" {
+		t.Fatalf("plan policy=(%+v,%v), want resume verb vet", plan, ok)
 	}
-	if got, ok := state.PhaseForName("planning"); ok || got != "" {
-		t.Fatalf("planning alias=(%q,%v), want speculative alias rejected", got, ok)
+	if policy, ok := state.PolicyFor(state.Phase("planning")); ok {
+		t.Fatalf("planning alias=(%+v,true), want speculative alias rejected", policy)
 	}
 
 	rights := map[string]state.Phase{}
-	for _, phase := range state.WorkflowPhases() {
-		if phase.TransitionRight == "" {
-			t.Fatalf("phase %q has no transition right", phase.ID)
+	for _, policy := range state.PhasePolicies() {
+		if policy.TransitionRight == "" {
+			t.Fatalf("phase %q has no transition right", policy.Target)
 		}
-		if prior := rights[phase.TransitionRight]; prior != "" {
-			t.Fatalf("phases %q and %q share transition right %q", prior, phase.ID, phase.TransitionRight)
+		if prior := rights[policy.TransitionRight]; prior != "" {
+			t.Fatalf("phases %q and %q share transition right %q", prior, policy.Target, policy.TransitionRight)
 		}
-		rights[phase.TransitionRight] = phase.ID
+		rights[policy.TransitionRight] = policy.Target
 	}
 }