devrites 3.0.2 → 3.0.3

package/engine/internal/lib/resolve_remediation_test.go

@@ -39,6 +39,15 @@ func TestResolveCompletesMissingAnswerFieldsInSingleRewrite(t *testing.T) {
 	}
 }
 
+func TestResolveAcceptsCanonicalUppercaseQuestionID(t *testing.T) {
+	root := resolveWorkspace(t, "## Q-001 blocking\nstatus: open\n")
+	var stdout, stderr bytes.Buffer
+
+	if code := Resolve(root, []string{"Q-001", "canonical answer"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code = %d, want 0; stderr=%q", code, stderr.String())
+	}
+}
+
 func resolveWorkspace(t *testing.T, questions string) string {
 	t.Helper()
 	root := t.TempDir()

package/engine/internal/lib/tickafk.go

@@ -65,7 +65,7 @@ func TickAfk(args []string, stdout, stderr io.Writer) int {
 // readBudget returns the current "AFK slices remaining" value — the first blank-
 // delimited token after the field — and whether the field is present at all.
 func readBudget(lines []string) (value string, found bool) {
-	value, found = state.CursorField(lines, "afk_slices_remaining")
+	value, found = state.CursorField(lines, state.CursorAFKSlicesRemaining)
 	if !found {
 		return "", false
 	}
@@ -77,6 +77,6 @@ func readBudget(lines []string) (value string, found bool) {
 
 // setBudget preserves the cursor's canonical-table or legacy-bullet format.
 func setBudget(lines []string, n int) []byte {
-	updated, _ := state.SetCursorField(lines, "afk_slices_remaining", strconv.Itoa(n))
+	updated, _ := state.SetCursorField(lines, state.CursorAFKSlicesRemaining, strconv.Itoa(n))
 	return []byte(strings.Join(updated, "\n") + "\n")
 }

package/engine/internal/migrate/migrate.go

@@ -151,7 +151,7 @@ func derivePhase(statePath string) state.Phase {
 		return state.PhaseBuild
 	}
 	lines := strings.Split(string(raw), "\n")
-	for _, key := range []string{"phase", "status"} {
+	for _, key := range []string{state.CursorPhase, state.CursorStatus} {
 		if value, found := state.CursorField(lines, key); found {
 			if p, ok := mapLegacyPhase(value); ok {
 				return p
@@ -168,38 +168,7 @@ func mapLegacyPhase(word string) (state.Phase, bool) {
 	if i := strings.IndexAny(word, " \t—-"); i > 0 {
 		word = word[:i]
 	}
-	switch word {
-	case "frame":
-		return state.PhaseFrame, true
-	case "spec", "specced", "specifying":
-		return state.PhaseSpec, true
-	case "temper", "tempered", "tempering":
-		return state.PhaseTemper, true
-	case "define", "defined", "defining":
-		return state.PhaseDefine, true
-	case "plan", "planned", "planning":
-		return state.PhasePlan, true
-	case "vet", "vetted", "vetting":
-		return state.PhaseVet, true
-	case "build", "building", "wip", "in", "in-progress":
-		return state.PhaseBuild, true
-	case "converge", "converged", "converging":
-		return state.PhaseConverge, true
-	case "prove", "proving", "proven", "testing":
-		return state.PhaseProve, true
-	case "polish", "polished", "polishing":
-		return state.PhasePolish, true
-	case "review", "reviewed", "reviewing":
-		return state.PhaseReview, true
-	case "seal", "sealed", "sealing":
-		return state.PhaseSeal, true
-	case "ship", "shipped", "shipping":
-		return state.PhaseShip, true
-	case "done", "closed", "complete", "completed":
-		return state.PhaseDone, true
-	default:
-		return "", false
-	}
+	return state.PhaseForName(word)
 }
 
 // backupWorkspace snapshots mutable state (work/, features/, and the ACTIVE pointer) into

package/engine/internal/migrate/migrate_test.go

@@ -80,6 +80,13 @@ func TestRunNormalizesLiveFeatureAliases(t *testing.T) {
 }
 
 func TestMapLegacyPhase(t *testing.T) {
+	for _, phase := range state.LifecyclePhases() {
+		got, ok := mapLegacyPhase(string(phase))
+		if !ok || got != phase {
+			t.Fatalf("mapLegacyPhase(%q)=(%q,%v), want canonical phase", phase, got, ok)
+		}
+	}
+
 	for _, tc := range []struct {
 		word string
 		want state.Phase
@@ -87,7 +94,6 @@ func TestMapLegacyPhase(t *testing.T) {
 	}{
 		{word: "specced", want: state.PhaseSpec, ok: true},
 		{word: "in-progress", want: state.PhaseBuild, ok: true},
-		{word: "temper", want: state.PhaseTemper, ok: true},
 		{word: "reviewing", want: state.PhaseReview, ok: true},
 		{word: "done - shipped", want: state.PhaseDone, ok: true},
 		{word: "mystery"},

package/engine/internal/state/cmd/workflowmanifest/main.go

@@ -0,0 +1,54 @@
+// Command workflowmanifest writes the deterministic cross-language derivative
+// of state.WorkflowPhases. The typed Go registry remains the authority.
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/devrites/devrites/internal/state"
+)
+
+func main() {
+	outPath := flag.String("out", "workflow_manifest.json", "output path")
+	check := flag.Bool("check", false, "fail when the output is stale")
+	flag.Parse()
+
+	document := struct {
+		GeneratedBy      string                 `json:"generatedBy"`
+		SchemaVersion    int                    `json:"schemaVersion"`
+		Phases           []state.WorkflowPhase  `json:"phases"`
+		CursorKeyAliases []state.CursorKeyAlias `json:"cursorKeyAliases"`
+	}{
+		GeneratedBy:      "go generate ./internal/state; DO NOT EDIT",
+		SchemaVersion:    state.SchemaVersion,
+		Phases:           state.WorkflowPhases(),
+		CursorKeyAliases: state.CursorKeyAliases(),
+	}
+	data, err := json.MarshalIndent(document, "", "  ")
+	if err != nil {
+		fatal(err)
+	}
+	data = append(data, '\n')
+	if *check {
+		current, err := os.ReadFile(*outPath)
+		if err != nil {
+			fatal(err)
+		}
+		if !bytes.Equal(current, data) {
+			fatal(fmt.Errorf("%s is stale; run go generate ./internal/state", *outPath))
+		}
+		return
+	}
+	if err := os.WriteFile(*outPath, data, 0o644); err != nil {
+		fatal(err)
+	}
+}
+
+func fatal(err error) {
+	fmt.Fprintln(os.Stderr, err)
+	os.Exit(1)
+}

package/engine/internal/state/cursor.go

@@ -1,10 +1,48 @@
 package state
 
 import (
+	"sort"
 	"strings"
 	"unicode"
 )
 
+// Canonical cursor keys. Callers use these constants so schema spelling changes
+// remain local to the cursor package; normalizeCursorKey still accepts legacy
+// presentation aliases at the text boundary.
+const (
+	CursorPhase              = "phase"
+	CursorStatus             = "status"
+	CursorNextAction         = "next_action"
+	CursorQuestionID         = "question_id"
+	CursorActiveSlice        = "active_slice"
+	CursorAFKSlicesRemaining = "afk_slices_remaining"
+)
+
+var cursorKeyAliases = map[string]string{
+	"nextstep": CursorNextAction,
+	"qid":      CursorQuestionID,
+}
+
+// CursorKeyAlias is the generated-manifest view of a compatibility key.
+type CursorKeyAlias struct {
+	Alias     string `json:"alias"`
+	Canonical string `json:"canonical"`
+}
+
+// CursorKeyAliases returns compatibility keys in deterministic order.
+func CursorKeyAliases() []CursorKeyAlias {
+	aliases := make([]string, 0, len(cursorKeyAliases))
+	for alias := range cursorKeyAliases {
+		aliases = append(aliases, alias)
+	}
+	sort.Strings(aliases)
+	out := make([]CursorKeyAlias, 0, len(aliases))
+	for _, alias := range aliases {
+		out = append(out, CursorKeyAlias{Alias: alias, Canonical: cursorKeyAliases[alias]})
+	}
+	return out
+}
+
 type cursorLineKind uint8
 
 const (
@@ -73,12 +111,9 @@ func normalizeCursorKey(key string) string {
 			b.WriteRune(r)
 		}
 	}
-	switch b.String() {
-	case "nextstep":
-		return "nextaction"
-	case "qid":
-		return "questionid"
-	default:
-		return b.String()
+	normalized := b.String()
+	if canonical, ok := cursorKeyAliases[normalized]; ok {
+		return normalizeCursorKey(canonical)
 	}
+	return normalized
 }

package/engine/internal/state/feature.go

@@ -108,22 +108,6 @@ func regularFileExists(path string) bool {
 	return err == nil && info.Mode().IsRegular()
 }
 
-// CandidateFiles returns the paths that make up feature <slug>: its feature.md
-// manifest plus every file that can satisfy a section (canonical names and the
-// transitional aliases), in a stable order. Not all need exist; callers that
-// fingerprint the feature stat and hash the ones that do, so including the alias
-// names means a change to either the canonical or the alias file is detected.
-func CandidateFiles(root, slug string) []string {
-	dir := featureDir(root, slug)
-	files := []string{filepath.Join(dir, "feature.md")}
-	for _, s := range Sections {
-		for _, name := range sectionFiles[s] {
-			files = append(files, filepath.Join(dir, name))
-		}
-	}
-	return files
-}
-
 // LoadFeature reads feature <slug> under root. The phase comes from the live
 // working-state ledger when it declares one, otherwise from feature.md
 // frontmatter. A feature with neither a manifest nor a ledger does not exist.
@@ -190,22 +174,12 @@ func sectionPresentAny(dir string, s Section) bool {
 	return false
 }
 
-// PhaseFromLedger reads a phase from the canonical cursor table or the legacy
-// "- Phase: <p>" form, accepting only phases the engine understands.
-func PhaseFromLedger(path string) Phase {
-	phase, declared := declaredPhaseFromLedger(path)
-	if declared && KnownPhase(phase) {
-		return phase
-	}
-	return ""
-}
-
 func declaredPhaseFromLedger(path string) (Phase, bool) {
 	raw, err := os.ReadFile(path)
 	if err != nil {
 		return "", false
 	}
-	value, ok := CursorField(strings.Split(string(raw), "\n"), "phase")
+	value, ok := CursorField(strings.Split(string(raw), "\n"), CursorPhase)
 	if !ok {
 		return "", false
 	}

package/engine/internal/state/schema.go

@@ -1,5 +1,7 @@
 package state
 
+//go:generate go run ./cmd/workflowmanifest -out workflow_manifest.json
+
 // SchemaVersion is the .devrites state-schema version this engine understands.
 // A feature.md may declare its own schemaVersion in frontmatter; the engine
 // refuses a version newer than this (see LoadFeature) and otherwise reads the
@@ -70,36 +72,149 @@ const (
 	PhaseDone     Phase = "done"     // archived completion
 )
 
-// requiredByPhase lists the sections that must have real content to complete a
-// phase. Completeness is phase-relative: a section not yet required (e.g. proof
-// during the spec phase) never blocks. The set is additive down the arc.
-var requiredByPhase = map[Phase][]Section{
-	PhaseFrame:    {},
-	PhaseSpec:     {SectionSpec},
-	PhaseTemper:   {SectionSpec},
-	PhaseDefine:   {SectionSpec, SectionPlan},
-	PhasePlan:     {SectionSpec, SectionPlan},
-	PhaseVet:      {SectionSpec, SectionPlan, SectionDecisions, SectionTasks},
-	PhaseBuild:    {SectionSpec, SectionPlan, SectionDecisions, SectionTasks},
-	PhaseConverge: {SectionSpec, SectionPlan, SectionDecisions, SectionTasks},
-	PhaseProve:    {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof},
-	PhasePolish:   {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof},
-	PhaseReview:   {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof},
-	PhaseSeal:     {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus},
-	PhaseShip:     {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus},
-	PhaseDone:     {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus},
+// phaseDefinition is the single source of truth for lifecycle order and
+// phase-specific behavior. Workflow topology is versioned application logic,
+// rather than deploy-time configuration, so keeping it typed and ordered makes
+// additions compile-visible and lets every consumer derive the same arc.
+type phaseDefinition struct {
+	phase               Phase
+	resumeVerb          string
+	required            []Section
+	aliases             []string
+	workspaceRequired   []string
+	proofRequired       bool
+	blocksOpenQuestions bool
+	shippable           bool
+}
+
+var (
+	sectionsSpec     = []Section{SectionSpec}
+	sectionsPlan     = []Section{SectionSpec, SectionPlan}
+	sectionsBuild    = []Section{SectionSpec, SectionPlan, SectionDecisions, SectionTasks}
+	sectionsProof    = []Section{SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof}
+	sectionsComplete = []Section{SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus}
+
+	workspaceFrame = []string{"state.md"}
+	workspaceSpec  = []string{"brief.md", "spec.md", "state.md", "decisions.md", "assumptions.md", "questions.md"}
+	workspacePlan  = []string{"brief.md", "spec.md", "architecture.md", "plan.md", "tasks.md", "traceability.md", "state.md", "decisions.md", "assumptions.md", "questions.md"}
+	workspaceProof = append(append([]string(nil), workspacePlan...), "evidence.md", "touched-files.md")
+)
+
+// Completeness is phase-relative: a section not yet required (e.g. proof during
+// spec) never blocks. Requirements are additive down the arc. Plan resumes at
+// define because plan is the artifact state produced by rite-define; done has no
+// resume command.
+var phaseDefinitions = []phaseDefinition{
+	{phase: PhaseFrame, resumeVerb: "frame", workspaceRequired: workspaceFrame},
+	{phase: PhaseSpec, resumeVerb: "spec", required: sectionsSpec, aliases: []string{"specced", "specifying"}, workspaceRequired: workspaceSpec},
+	{phase: PhaseTemper, resumeVerb: "temper", required: sectionsSpec, aliases: []string{"tempered", "tempering"}, workspaceRequired: workspaceSpec},
+	{phase: PhaseDefine, resumeVerb: "define", required: sectionsPlan, aliases: []string{"defined", "defining"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhasePlan, resumeVerb: "define", required: sectionsPlan, aliases: []string{"planned", "planning"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseVet, resumeVerb: "vet", required: sectionsBuild, aliases: []string{"vetted", "vetting"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseBuild, resumeVerb: "build", required: sectionsBuild, aliases: []string{"building", "wip", "in", "in-progress"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseConverge, resumeVerb: "converge", required: sectionsBuild, aliases: []string{"converged", "converging"}, workspaceRequired: workspacePlan, blocksOpenQuestions: true},
+	{phase: PhaseProve, resumeVerb: "prove", required: sectionsProof, aliases: []string{"proving", "proven", "testing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true},
+	{phase: PhasePolish, resumeVerb: "polish", required: sectionsProof, aliases: []string{"polished", "polishing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true},
+	{phase: PhaseReview, resumeVerb: "review", required: sectionsProof, aliases: []string{"reviewed", "reviewing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true},
+	{phase: PhaseSeal, resumeVerb: "seal", required: sectionsComplete, aliases: []string{"sealed", "sealing"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true, shippable: true},
+	{phase: PhaseShip, resumeVerb: "ship", required: sectionsComplete, aliases: []string{"shipped", "shipping"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true, shippable: true},
+	{phase: PhaseDone, required: sectionsComplete, aliases: []string{"closed", "complete", "completed"}, workspaceRequired: workspaceProof, proofRequired: true, blocksOpenQuestions: true, shippable: true},
+}
+
+// WorkflowPhase is the read-only cross-format view used to generate the compact
+// manifest consumed by non-Go release tooling.
+type WorkflowPhase struct {
+	ID                  Phase    `json:"id"`
+	ResumeVerb          string   `json:"resumeVerb,omitempty"`
+	Aliases             []string `json:"aliases,omitempty"`
+	WorkspaceRequired   []string `json:"workspaceRequired"`
+	ProofRequired       bool     `json:"proofRequired,omitempty"`
+	BlocksOpenQuestions bool     `json:"blocksOpenQuestions,omitempty"`
+	Shippable           bool     `json:"shippable,omitempty"`
+}
+
+// WorkflowPhases returns copied metadata suitable for deterministic generation.
+func WorkflowPhases() []WorkflowPhase {
+	out := make([]WorkflowPhase, 0, len(phaseDefinitions))
+	for _, definition := range phaseDefinitions {
+		out = append(out, WorkflowPhase{
+			ID:                  definition.phase,
+			ResumeVerb:          definition.resumeVerb,
+			Aliases:             append([]string(nil), definition.aliases...),
+			WorkspaceRequired:   append([]string(nil), definition.workspaceRequired...),
+			ProofRequired:       definition.proofRequired,
+			BlocksOpenQuestions: definition.blocksOpenQuestions,
+			Shippable:           definition.shippable,
+		})
+	}
+	return out
+}
+
+// LifecyclePhases returns the ordered lifecycle. The returned slice is a copy,
+// so callers cannot mutate the registry.
+func LifecyclePhases() []Phase {
+	phases := make([]Phase, len(phaseDefinitions))
+	for i, definition := range phaseDefinitions {
+		phases[i] = definition.phase
+	}
+	return phases
+}
+
+func definitionFor(p Phase) (phaseDefinition, bool) {
+	for _, definition := range phaseDefinitions {
+		if definition.phase == p {
+			return definition, true
+		}
+	}
+	return phaseDefinition{}, false
 }
 
 // KnownPhase reports whether p is a phase the engine understands.
 func KnownPhase(p Phase) bool {
-	_, ok := requiredByPhase[p]
+	_, ok := definitionFor(p)
 	return ok
 }
 
+// ResumeVerb returns the public rite verb that resumes p. Terminal and unknown
+// phases return an empty string.
+func ResumeVerb(p Phase) string {
+	definition, ok := definitionFor(p)
+	if !ok {
+		return ""
+	}
+	return definition.resumeVerb
+}
+
+// ShippablePhase reports whether p is allowed to claim a sealed/shipped result.
+func ShippablePhase(p Phase) bool {
+	definition, ok := definitionFor(p)
+	return ok && definition.shippable
+}
+
+// PhaseForName resolves a canonical phase ID or compatibility alias. Callers
+// should normalize surrounding syntax before querying it.
+func PhaseForName(name string) (Phase, bool) {
+	for _, definition := range phaseDefinitions {
+		if string(definition.phase) == name {
+			return definition.phase, true
+		}
+		for _, alias := range definition.aliases {
+			if alias == name {
+				return definition.phase, true
+			}
+		}
+	}
+	return "", false
+}
+
 // RequiredSections returns the sections required to complete the given phase,
 // in canonical Sections order.
 func RequiredSections(p Phase) []Section {
-	want := requiredByPhase[p]
+	definition, ok := definitionFor(p)
+	if !ok {
+		return nil
+	}
+	want := definition.required
 	set := make(map[Section]bool, len(want))
 	for _, s := range want {
 		set[s] = true

package/engine/internal/state/snapshot.go

@@ -23,6 +23,7 @@ var (
 	snapshotSliceStateRe   = regexp.MustCompile(`[[:space:]]+(built|pending)[[:space:]]*$`)
 	snapshotSliceSepRe     = regexp.MustCompile(`[[:space:]]+[^[:alnum:][:space:]]+[[:space:]]*$`)
 	snapshotSliceCheckedRe = regexp.MustCompile(`\[[xX]\]`)
+	snapshotSliceHeadingRe = regexp.MustCompile(`(?m)^##[[:space:]]+(SLICE-[0-9]{3})(?:[[:space:]]+.*)?$`)
 	snapshotTouchedPathRe  = regexp.MustCompile("`([^`]+)`")
 )
 
@@ -163,13 +164,13 @@ func Snapshot(root, slug string) (*WorkspaceSnapshot, error) {
 
 func nextCommand(workDir string, phase Phase) workflow.Command {
 	if raw, err := os.ReadFile(filepath.Join(workDir, LedgerFile)); err == nil {
-		if action, ok := CursorField(strings.Split(string(raw), "\n"), "next_action"); ok {
+		if action, ok := CursorField(strings.Split(string(raw), "\n"), CursorNextAction); ok {
 			if command := workflow.ForAction(action); command.Verb != "" {
 				return command
 			}
 		}
 	}
-	return workflow.ForPhase(string(phase))
+	return workflow.ForVerb(ResumeVerb(phase))
 }
 
 func readActiveSlug(root string) string {
@@ -191,6 +192,22 @@ func runMode(root string) string {
 }
 
 func currentSlice(workDir string) *SliceSnapshot {
+	if rawState, err := os.ReadFile(filepath.Join(workDir, LedgerFile)); err == nil {
+		if active, ok := CursorField(strings.Split(string(rawState), "\n"), CursorActiveSlice); ok {
+			fields := strings.Fields(active)
+			if len(fields) > 0 {
+				active = fields[0]
+				if rawTasks, taskErr := os.ReadFile(filepath.Join(workDir, "tasks.md")); taskErr == nil {
+					matches := snapshotSliceHeadingRe.FindAllStringSubmatch(string(rawTasks), -1)
+					for i, match := range matches {
+						if match[1] == active {
+							return &SliceSnapshot{Index: i + 1, Total: len(matches), Name: active, State: "pending"}
+						}
+					}
+				}
+			}
+		}
+	}
 	for _, name := range []string{"state.md", "tasks.md"} {
 		raw, err := os.ReadFile(filepath.Join(workDir, name))
 		if err != nil {
@@ -271,6 +288,9 @@ func driftSummary(workDir string) DriftSnapshot {
 			continue
 		}
 		open := countOpenMarkers(string(raw))
+		if name == "questions.md" {
+			open = countOpenQuestions(string(raw))
+		}
 		if open > 0 {
 			return DriftSnapshot{Status: "open", Open: open}
 		}
@@ -278,11 +298,37 @@ func driftSummary(workDir string) DriftSnapshot {
 	return DriftSnapshot{Status: "clear"}
 }
 
+func countOpenQuestions(text string) int {
+	open := 0
+	inQuestion := false
+	status := ""
+	finalize := func() {
+		if inQuestion && status == "open" {
+			open++
+		}
+	}
+	for _, line := range strings.Split(text, "\n") {
+		lower := strings.ToLower(strings.TrimSpace(line))
+		switch {
+		case strings.HasPrefix(lower, "## q-"):
+			finalize()
+			inQuestion, status = true, ""
+		case inQuestion && strings.HasPrefix(lower, "status:"):
+			status = strings.TrimSpace(strings.TrimPrefix(lower, "status:"))
+		case inQuestion && strings.HasPrefix(lower, "## "):
+			finalize()
+			inQuestion = false
+		}
+	}
+	finalize()
+	return open
+}
+
 func countOpenMarkers(text string) int {
 	open := 0
 	for _, line := range strings.Split(text, "\n") {
 		l := strings.ToLower(strings.TrimSpace(line))
-		if strings.Contains(l, "status: open") || strings.Contains(l, "- [ ]") || strings.Contains(l, "gate: blocking") {
+		if strings.Contains(l, "status: open") || strings.Contains(l, "- [ ]") {
 			open++
 		}
 	}

package/engine/internal/state/state_test.go

@@ -29,6 +29,56 @@ func TestRequiredSectionsIsPhaseRelativeAndOrdered(t *testing.T) {
 	}
 }
 
+func TestLifecycleRegistryOwnsOrderAndResumeCommands(t *testing.T) {
+	phases := LifecyclePhases()
+	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)
+	}
+	if got := ResumeVerb(PhaseDone); got != "" {
+		t.Fatalf("ResumeVerb(done)=%q, want empty", got)
+	}
+
+	phases[0] = PhaseDone
+	if got := LifecyclePhases()[0]; got != PhaseFrame {
+		t.Fatalf("LifecyclePhases exposed mutable registry: first=%q", got)
+	}
+}
+
+func TestLifecycleRegistryInvariants(t *testing.T) {
+	phaseNames := map[Phase]bool{}
+	aliases := 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 len(definition.workspaceRequired) == 0 {
+			t.Fatalf("phase %q has no workspace requirements", definition.phase)
+		}
+		for _, alias := range definition.aliases {
+			if alias == "" || aliases[alias] != "" || KnownPhase(Phase(alias)) {
+				t.Fatalf("phase %q has empty or duplicate alias %q", definition.phase, alias)
+			}
+			aliases[alias] = definition.phase
+		}
+		for _, section := range definition.required {
+			known := false
+			for _, canonical := range Sections {
+				known = known || section == canonical
+			}
+			if !known {
+				t.Fatalf("phase %q requires unknown section %q", definition.phase, section)
+			}
+		}
+		if definition.shippable && !definition.proofRequired {
+			t.Fatalf("shippable phase %q does not require proof", definition.phase)
+		}
+	}
+}
+
 func TestStatusFixtureBuildIncomplete(t *testing.T) {
 	rep, err := Status(fixtureRoot, "auth-tokens")
 	if err != nil {
@@ -172,6 +222,27 @@ func TestSnapshotUsesCanonicalNextActionAndWarnsWhenRequiredProofMissing(t *test
 	}
 }
 
+func TestSnapshotReadsCanonicalActiveSliceAndCountsQuestionsByRecord(t *testing.T) {
+	workDir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(workDir, "state.md"), []byte("| phase | build |\n| active_slice | SLICE-002 |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workDir, "tasks.md"), []byte("## SLICE-001 First\n\n## SLICE-002 Second\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workDir, "questions.md"), []byte("## Q-001\nstatus: open\ngate: blocking\n\n## Q-002\nstatus: answered\ngate: blocking\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	slice := currentSlice(workDir)
+	if slice == nil || slice.Name != "SLICE-002" || slice.Index != 2 || slice.Total != 2 {
+		t.Fatalf("currentSlice=%+v, want canonical SLICE-002 at 2/2", slice)
+	}
+	if drift := driftSummary(workDir); drift.Status != "open" || drift.Open != 1 {
+		t.Fatalf("driftSummary=%+v, want one open question record", drift)
+	}
+}
+
 func TestWorkLayoutIsCanonicalAndFeaturesIsAlias(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
 	writeWorkSection(t, root, "live", "state.md", "- Phase: build\n")