devrites 3.0.2 → 3.0.4

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 {
@@ -88,9 +138,9 @@ func writeWorkSection(t *testing.T, root, slug, name, body string) {
 	}
 }
 
-// A live workspace the pack creates has no feature.md manifest: the phase lives in
-// the state.md ledger and the proof/status sections are satisfied by their aliases
-// (evidence.md / state.md). The engine must load, list, and report it anyway.
+// A live workspace map need not carry frontmatter: the phase lives in
+// the canonical state.md ledger and the proof/status concepts are satisfied by
+// evidence.md/state.md. The engine must load, list, and report it anyway.
 func TestLoadFeatureFromLedgerAndAliases(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
 	writeSection(t, root, "live", "state.md", "- Phase: prove\n- Status: running\n")
@@ -98,7 +148,7 @@ func TestLoadFeatureFromLedgerAndAliases(t *testing.T) {
 	writeSection(t, root, "live", "plan.md", "# Plan\n\nApproach.\n")
 	writeSection(t, root, "live", "decisions.md", "# Decisions\n\nChose X.\n")
 	writeSection(t, root, "live", "tasks.md", "# Tasks\n\n- [x] slice 1\n")
-	writeSection(t, root, "live", "evidence.md", "# Evidence\n\nTests pass.\n") // alias for proof
+	writeSection(t, root, "live", "evidence.md", "# Evidence\n\nTests pass.\n")
 
 	rep, err := Status(root, "live")
 	if err != nil {
@@ -108,10 +158,10 @@ func TestLoadFeatureFromLedgerAndAliases(t *testing.T) {
 		t.Errorf("phase = %q, want prove (from the state.md ledger)", rep.Phase)
 	}
 	if !rep.Present[SectionProof] {
-		t.Error("proof section should be present via its evidence.md alias")
+		t.Error("proof section should be present via canonical evidence.md")
 	}
 	if !rep.Present[SectionStatus] {
-		t.Error("status section should be present via its state.md alias")
+		t.Error("status section should be present via canonical state.md")
 	}
 	if !rep.Complete() {
 		t.Errorf("prove-phase feature should be complete, missing: %v", rep.Missing)
@@ -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")

package/engine/internal/state/workflow_manifest.json

@@ -0,0 +1,310 @@
+{
+  "generatedBy": "go generate ./internal/state; DO NOT EDIT",
+  "schemaVersion": 1,
+  "phases": [
+    {
+      "id": "frame",
+      "resumeVerb": "frame",
+      "workspaceRequired": [
+        "state.md"
+      ]
+    },
+    {
+      "id": "spec",
+      "resumeVerb": "spec",
+      "aliases": [
+        "specced",
+        "specifying"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md"
+      ]
+    },
+    {
+      "id": "temper",
+      "resumeVerb": "temper",
+      "aliases": [
+        "tempered",
+        "tempering"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md"
+      ]
+    },
+    {
+      "id": "define",
+      "resumeVerb": "define",
+      "aliases": [
+        "defined",
+        "defining"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md"
+      ],
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "plan",
+      "resumeVerb": "define",
+      "aliases": [
+        "planned",
+        "planning"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md"
+      ],
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "vet",
+      "resumeVerb": "vet",
+      "aliases": [
+        "vetted",
+        "vetting"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md"
+      ],
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "build",
+      "resumeVerb": "build",
+      "aliases": [
+        "building",
+        "wip",
+        "in",
+        "in-progress"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md"
+      ],
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "converge",
+      "resumeVerb": "converge",
+      "aliases": [
+        "converged",
+        "converging"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md"
+      ],
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "prove",
+      "resumeVerb": "prove",
+      "aliases": [
+        "proving",
+        "proven",
+        "testing"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md",
+        "evidence.md",
+        "touched-files.md"
+      ],
+      "proofRequired": true,
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "polish",
+      "resumeVerb": "polish",
+      "aliases": [
+        "polished",
+        "polishing"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md",
+        "evidence.md",
+        "touched-files.md"
+      ],
+      "proofRequired": true,
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "review",
+      "resumeVerb": "review",
+      "aliases": [
+        "reviewed",
+        "reviewing"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md",
+        "evidence.md",
+        "touched-files.md"
+      ],
+      "proofRequired": true,
+      "blocksOpenQuestions": true
+    },
+    {
+      "id": "seal",
+      "resumeVerb": "seal",
+      "aliases": [
+        "sealed",
+        "sealing"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md",
+        "evidence.md",
+        "touched-files.md"
+      ],
+      "proofRequired": true,
+      "blocksOpenQuestions": true,
+      "shippable": true
+    },
+    {
+      "id": "ship",
+      "resumeVerb": "ship",
+      "aliases": [
+        "shipped",
+        "shipping"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md",
+        "evidence.md",
+        "touched-files.md"
+      ],
+      "proofRequired": true,
+      "blocksOpenQuestions": true,
+      "shippable": true
+    },
+    {
+      "id": "done",
+      "aliases": [
+        "closed",
+        "complete",
+        "completed"
+      ],
+      "workspaceRequired": [
+        "brief.md",
+        "spec.md",
+        "architecture.md",
+        "plan.md",
+        "tasks.md",
+        "traceability.md",
+        "state.md",
+        "decisions.md",
+        "assumptions.md",
+        "questions.md",
+        "evidence.md",
+        "touched-files.md"
+      ],
+      "proofRequired": true,
+      "blocksOpenQuestions": true,
+      "shippable": true
+    }
+  ],
+  "cursorKeyAliases": [
+    {
+      "alias": "nextstep",
+      "canonical": "next_action"
+    },
+    {
+      "alias": "qid",
+      "canonical": "question_id"
+    }
+  ]
+}

package/engine/internal/workflow/commands.go

@@ -12,22 +12,6 @@ type Command struct {
 	Codex  string
 }
 
-var phaseToVerb = map[string]string{
-	"frame":    "frame",
-	"spec":     "spec",
-	"temper":   "temper",
-	"define":   "define",
-	"plan":     "define", // plan is the artifact state produced by rite-define.
-	"vet":      "vet",
-	"build":    "build",
-	"converge": "converge",
-	"prove":    "prove",
-	"polish":   "polish",
-	"review":   "review",
-	"seal":     "seal",
-	"ship":     "ship",
-}
-
 // ForVerb returns the Claude and Codex forms for a public rite verb. The empty
 // verb returns an empty command so callers can omit suggestions safely.
 func ForVerb(verb string) Command {
@@ -52,12 +36,6 @@ func ForAction(action string) Command {
 	return Command{}
 }
 
-// ForPhase returns the next public command for a workflow phase.
-func ForPhase(phase string) Command {
-	verb := phaseToVerb[strings.TrimSpace(strings.ToLower(phase))]
-	return ForVerb(verb)
-}
-
 // Both renders a command in host-neutral prose for engine stderr/stdout messages.
 func (c Command) Both() string {
 	if c.Verb == "" {
@@ -65,17 +43,3 @@ func (c Command) Both() string {
 	}
 	return c.Claude + " (Claude) / " + c.Codex + " (Codex)"
 }
-
-// ClaudeOrCodex returns the command for a known harness. Empty/unknown harnesses
-// deliberately get the host-neutral rendering so CLI output remains safe when the
-// engine is run outside a hook.
-func (c Command) ClaudeOrCodex(harness string) string {
-	switch strings.ToLower(strings.TrimSpace(harness)) {
-	case "claude", "claude-code", "claudecode":
-		return c.Claude
-	case "codex":
-		return c.Codex
-	default:
-		return c.Both()
-	}
-}

package/engine/internal/workflow/commands_test.go

@@ -16,20 +16,3 @@ func TestForActionExtractsCanonicalInvocation(t *testing.T) {
 		}
 	}
 }
-
-func TestForPhaseCoversCurrentLifecycle(t *testing.T) {
-	for _, phase := range []string{
-		"frame", "spec", "temper", "define", "vet", "build", "converge",
-		"prove", "polish", "review", "seal", "ship",
-	} {
-		if got := ForPhase(phase).Verb; got != phase {
-			t.Fatalf("ForPhase(%q).Verb=%q, want %q", phase, got, phase)
-		}
-	}
-	if got := ForPhase("plan").Verb; got != "define" {
-		t.Fatalf("ForPhase(plan).Verb=%q, want define compatibility route", got)
-	}
-	if got := ForPhase("done").Verb; got != "" {
-		t.Fatalf("ForPhase(done).Verb=%q, want empty", got)
-	}
-}

package/engine/testdata/golden/TestParityProgress/arg=allbuilt.golden

@@ -1,4 +1,4 @@
 exit 0
 ── rite-build ─────────
 Slices 2/2  ██████████  ✅ ALL BUILT
-Flow   spec ✓ define ✓ build ◉ prove ○ polish ○ review ○ seal ○ ship ○
+Flow   spec ✓ define ✓ plan ✓ build ◉ prove ○ polish ○ review ○ seal ○ ship ○

package/engine/testdata/golden/TestParityProgress/arg=done.golden

@@ -1,3 +1,3 @@
 exit 0
 ── rite-done ─────────
-Flow   spec ✓ define ✓ build ✓ prove ✓ polish ✓ review ✓ seal ✓ ship ✓
+Flow   spec ✓ define ✓ plan ✓ build ✓ prove ✓ polish ✓ review ✓ seal ✓ ship ✓

package/engine/testdata/golden/TestParityProgress/arg=mid.golden

@@ -1,4 +1,4 @@
 exit 0
 ── rite-build ─────────
 Slice 2/3  ███████░░░  detail ✓
-Flow   spec ✓ temper ✓ define ✓ vet ✓ build ◉ prove ○ polish ○ review ○ seal ○ ship ○
+Flow   spec ✓ temper ✓ define ✓ plan ✓ vet ✓ build ◉ prove ○ polish ○ review ○ seal ○ ship ○

package/engine/testdata/golden/TestParityProgress/arg=nophase.golden

@@ -1,3 +1,3 @@
 exit 0
 ── rite-spec ─────────
-Flow   spec ◉ define ○ build ○ prove ○ polish ○ review ○ seal ○ ship ○
+Flow   spec ◉ define ○ plan ○ build ○ prove ○ polish ○ review ○ seal ○ ship ○

package/engine/testdata/golden/TestParityProgress/arg=noslice.golden

@@ -1,3 +1,3 @@
 exit 0
 ── rite-spec ─────────
-Flow   spec ◉ define ○ build ○ prove ○ polish ○ review ○ seal ○ ship ○
+Flow   spec ◉ define ○ plan ○ build ○ prove ○ polish ○ review ○ seal ○ ship ○

package/engine/testdata/golden/TestParityProgress/arg=plan.golden

@@ -1,4 +1,4 @@
 exit 0
 ── rite-plan ─────────
 Slice 2/3  ███████░░░  detail ✓
-Flow   spec ✓ define ✓ build ◉ prove ○ polish ○ review ○ seal ○ ship ○
+Flow   spec ✓ define ✓ plan ◉ build ○ prove ○ polish ○ review ○ seal ○ ship ○

package/engine/testdata/golden/TestParityProgress/arg=seal.golden

@@ -1,3 +1,3 @@
 exit 0
 ── rite-seal ─────────
-Flow   spec ✓ define ✓ build ✓ prove ✓ polish ✓ review ✓ seal ◉ ship ○
+Flow   spec ✓ define ✓ plan ✓ build ✓ prove ✓ polish ✓ review ✓ seal ◉ ship ○

package/engine/tests/adr_0004_required_by_phase_test.go

@@ -12,25 +12,8 @@ import (
 	"github.com/devrites/devrites/internal/state"
 )
 
-// phaseArc is the canonical order the lifecycle advances through (ADR-0004).
-var phaseArc = []state.Phase{
-	state.PhaseFrame,
-	state.PhaseSpec,
-	state.PhaseTemper,
-	state.PhaseDefine,
-	state.PhasePlan,
-	state.PhaseVet,
-	state.PhaseBuild,
-	state.PhaseConverge,
-	state.PhaseProve,
-	state.PhasePolish,
-	state.PhaseReview,
-	state.PhaseSeal,
-	state.PhaseShip,
-	state.PhaseDone,
-}
-
 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)

package/engine/tests/budget_test.go

@@ -7,8 +7,8 @@ import (
 
 // TestStatusLiveWorkspace is the P2 acceptance check: `devrites-engine status <slug>`
 // must report a canonical work/<slug> feature the live pack created without a
-// feature.md manifest — phase from the state.md ledger, proof/status via their
-// evidence.md/state.md aliases. Before the schema unification this returned
+// workspace-map frontmatter — phase from the canonical state.md ledger and proof/status
+// completeness from canonical evidence.md/state.md files. Before schema unification this returned
 // "feature not found".
 func TestStatusLiveWorkspace(t *testing.T) {
 	work := t.TempDir()

package/engine/tests/lib_parity_test.go

@@ -795,7 +795,7 @@ func TestParityPreamble(t *testing.T) {
 //
 // Golden: the header rule width, the slice meter (round-half math, ✅ ALL BUILT
 // vs the last-built tail), and the flow ribbon (conditional temper/vet, the
-// plan→build and done cursor rules) are checked against golden snapshots.
+// explicit plan and terminal done cursor rules) are checked against golden snapshots.
 
 func TestParityProgress(t *testing.T) {
 	work := t.TempDir()

package/engine/tests/meta_test.go

@@ -1,7 +1,7 @@
 package main_test
 
-// Cross-cutting assertions the spec calls out explicitly: the engine makes zero
-// network calls, and the inline fail-open guard no-ops when the binary is absent.
+// Cross-cutting assertions: network I/O stays inside the one sanctioned package,
+// and the inline fail-open guard no-ops when the binary is absent.
 
 import (
 	"bytes"
@@ -11,7 +11,7 @@ import (
 )
 
 // TestFirstPartyMakesNoNetworkCalls asserts that no first-party package imports a
-// network client EXCEPT internal/iohooks — the ONE sanctioned network surface,
+// network client EXCEPT internal/iohooks — the one sanctioned network surface,
 // where the source-citation cache does conditional-HEAD revalidation. Confining
 // network to that single, auditable package keeps the rest of the engine a
 // network-free control plane that makes zero model calls (PRD: "zero API"). The