devrites 3.0.1 → 3.0.2

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to DevRites are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and DevRites adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases are generated automatically by [semantic-release](https://semantic-release.gitbook.io/) from Conventional Commits on `main`.
 
+## [3.0.2](https://github.com/ViktorsBaikers/DevRites/compare/v3.0.1...v3.0.2) (2026-07-20)
+
+### Fixed
+
+* **rite:** read canonical workspace cursor state ([e2fd60c](https://github.com/ViktorsBaikers/DevRites/commit/e2fd60c13aa53637e1af02a792f36f3efe32e1c9))
+
 ## [3.0.1](https://github.com/ViktorsBaikers/DevRites/compare/v3.0.0...v3.0.1) (2026-07-20)
 
 ### Fixed

package/README.md

@@ -115,7 +115,7 @@ Full diagram set (lifecycle, polish orchestrator, review fan-out, debug loop,
 rules carrier, workspace state, namespace map) →
 [`docs/flow.md`](docs/flow.md).
 
-**Status:** [`v3.0.1`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.0.1) — see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v3.0.2`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.0.2) — see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 ## Contents
 

package/engine/hooks_events_test.go

@@ -26,6 +26,21 @@ func makeHookWorkspace(t *testing.T) string {
 	return root
 }
 
+func TestHookStatuslineReadsCanonicalCursor(t *testing.T) {
+	root := makeHookWorkspace(t)
+	state := "| Key | Value |\n| --- | --- |\n| phase | temper |\n| status | running |\n"
+	if err := os.WriteFile(filepath.Join(root, "work", "demo", "state.md"), []byte(state), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	var stdout bytes.Buffer
+	if code := hookStatusline(strings.NewReader(""), &stdout, &bytes.Buffer{}); code != 0 {
+		t.Fatalf("hookStatusline code=%d", code)
+	}
+	if !strings.Contains(stdout.String(), "demo · temper ·") {
+		t.Fatalf("statusline ignored table phase: %s", stdout.String())
+	}
+}
+
 func TestHookEventWritesTimelineAndWorkspaceEvents(t *testing.T) {
 	root := makeHookWorkspace(t)
 	if code := hookEvent([]string{"subagent-stop"}, strings.NewReader(`{}`), &bytes.Buffer{}, &bytes.Buffer{}); code != 0 {

package/engine/hooks_workspace.go

@@ -22,20 +22,8 @@ import (
 	"github.com/devrites/devrites/internal/state"
 )
 
-// State-field patterns. Each hook reads a field the way the scripts do:
-// `grep -iE <find>` (case-INSENSITIVE) selects the first matching line, then
-// `sed -E s/<strip>//` (case-SENSITIVE, as sed is) removes the key prefix — a
-// no-op when the case differs, so the mismatched-case behavior is preserved.
 var (
-	findNextStep  = regexp.MustCompile(`(?i)^[-[:space:]]*Next step:`)
-	stripNextStep = regexp.MustCompile(`^[-[:space:]]*Next step:[[:space:]]*`)
-	findStatus    = regexp.MustCompile(`(?i)^[-[:space:]]*Status:`)
-	stripStatus   = regexp.MustCompile(`^[-[:space:]]*Status:[[:space:]]*`)
-	findPhase     = regexp.MustCompile(`(?i)^[-[:space:]]*Phase:`)
-	stripPhase    = regexp.MustCompile(`^[-[:space:]]*Phase:[[:space:]]*`)
-	findAFKRem    = regexp.MustCompile(`(?i)AFK slices remaining:`)
-	stripAFKRem   = regexp.MustCompile(`.*remaining:[[:space:]]*`)
-	openStatusRe  = regexp.MustCompile(`(?i)^[[:space:]]*status:[[:space:]]*open`)
+	openStatusRe = regexp.MustCompile(`(?i)^[[:space:]]*status:[[:space:]]*open`)
 )
 
 // resolveWorkspaceDir resolves the active feature's directory. New writes default
@@ -199,9 +187,9 @@ func hookHandoffSnapshot(stdin io.Reader, stdout, stderr io.Writer) int {
 		return exitOK
 	}
 	stateLines := wsReadLines(filepath.Join(dir, "state.md"))
-	phase := wsField(stateLines, findPhase, stripPhase)
-	status := wsField(stateLines, findStatus, stripStatus)
-	next := wsField(stateLines, findNextStep, stripNextStep)
+	phase, _ := state.CursorField(stateLines, "phase")
+	status, _ := state.CursorField(stateLines, "status")
+	next, _ := state.CursorField(stateLines, "next_action")
 	stamp := time.Now().UTC().Format(time.RFC3339)
 	var b strings.Builder
 	fmt.Fprintf(&b, "\n## Handoff snapshot — %s\n", stamp)
@@ -233,12 +221,12 @@ func hookCursor(stdin io.Reader, stdout, stderr io.Writer) int {
 	}
 	stateLines := wsReadLines(filepath.Join(dir, "state.md"))
 
-	next := wsField(stateLines, findNextStep, stripNextStep)
-	status := wsField(stateLines, findStatus, stripStatus)
+	next, _ := state.CursorField(stateLines, "next_action")
+	status, _ := state.CursorField(stateLines, "status")
 	gates := wsGateCount(filepath.Join(dir, "questions.md"))
 	afk := ""
 	if wsIsFile(filepath.Join(root, "AFK")) {
-		afk = wsField(stateLines, findAFKRem, stripAFKRem)
+		afk, _ = state.CursorField(stateLines, "afk_slices_remaining")
 	}
 
 	fmt.Fprintf(stdout, "DevRites cursor — active feature: %s\n", slug)
@@ -267,7 +255,7 @@ func hookStatusline(stdin io.Reader, stdout, stderr io.Writer) int {
 	if !ok {
 		return exitOK
 	}
-	phase := wsField(wsReadLines(filepath.Join(dir, "state.md")), findPhase, stripPhase)
+	phase, _ := state.CursorField(wsReadLines(filepath.Join(dir, "state.md")), "phase")
 	if phase == "" {
 		phase = "?"
 	}
@@ -536,17 +524,6 @@ func hookWrightScope(h harness.Harness, stdin io.Reader, stdout, stderr io.Write
 	return exitOK
 }
 
-// wsField mirrors `grep -iE <find> | head -1 | sed -E s/<strip>//`: the first line
-// matching find (case-insensitive) with strip removed (case-sensitive).
-func wsField(lines []string, find, strip *regexp.Regexp) string {
-	for _, line := range lines {
-		if find.MatchString(line) {
-			return strip.ReplaceAllString(line, "")
-		}
-	}
-	return ""
-}
-
 // wsGateCount mirrors `grep -ciE '^\s*status:\s*open' questions.md || echo 0`,
 // INCLUDING grep's quirk: on a present file with zero matches grep prints "0" and
 // exits 1, so `|| echo 0` appends a second "0" (the captured value is "0\n0").

package/engine/internal/gate/gate.go

@@ -90,7 +90,7 @@ func (r *Result) Render() string {
 }
 
 // StopGate evaluates the stop-hook rest-point invariant for the active feature:
-// a feature that CLAIMS completion (it has advanced to the seal or ship phase)
+// a feature that CLAIMS completion (it has advanced to seal, ship, or done)
 // must not have an empty proof section. This is a rest-point check, NOT
 // whole-feature completeness — normal in-progress incompleteness never trips it,
 // so a mid-build turn is never blocked.
@@ -129,7 +129,7 @@ func StopGate(root string) (StopResult, error) {
 				slug, strings.Join(gates, "/")),
 		}, nil
 	}
-	claimsDone := f.Phase == state.PhaseSeal || f.Phase == state.PhaseShip
+	claimsDone := f.Phase == state.PhaseSeal || f.Phase == state.PhaseShip || f.Phase == state.PhaseDone
 	if claimsDone && !f.Present[state.SectionProof] {
 		return StopResult{
 			Slug:    slug,
@@ -191,13 +191,8 @@ func openBlockingQuestionGates(data []byte) []string {
 }
 
 func stateAwaitingHuman(data []byte) bool {
-	for _, line := range splitLinesNoTrailing(data) {
-		if strings.HasPrefix(line, "- Status:") {
-			status := strings.TrimLeft(strings.TrimPrefix(line, "- Status:"), gateSpaceChars)
-			return status == "awaiting_human"
-		}
-	}
-	return false
+	status, _ := state.CursorField(splitLinesNoTrailing(data), "status")
+	return status == "awaiting_human"
 }
 
 func isHeadingLine(line string) bool {

package/engine/internal/gate/gate_test.go

@@ -38,6 +38,13 @@ func TestCheckAndRenderReadiness(t *testing.T) {
 	}
 }
 
+func TestStateAwaitingHumanReadsCanonicalCursor(t *testing.T) {
+	data := []byte("| Key | Value |\n| --- | --- |\n| status | awaiting_human |\n")
+	if !stateAwaitingHuman(data) {
+		t.Fatal("stateAwaitingHuman ignored canonical cursor table")
+	}
+}
+
 func TestStopGateRestPointInvariants(t *testing.T) {
 	for _, tc := range []struct {
 		name          string
@@ -82,6 +89,15 @@ func TestStopGateRestPointInvariants(t *testing.T) {
 			wantBlocked:   true,
 			wantReasonSub: "proof.md is empty",
 		},
+		{
+			name: "done without proof blocks",
+			files: map[string]string{
+				"feature.md": "---\nphase: ship\nschemaVersion: 1\n---\n",
+				"state.md":   "| Key | Value |\n| --- | --- |\n| phase | done |\n",
+			},
+			wantBlocked:   true,
+			wantReasonSub: "proof.md is empty",
+		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			root := t.TempDir()

package/engine/internal/lib/buildreadiness.go

@@ -7,6 +7,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/devrites/devrites/internal/state"
 	"github.com/devrites/devrites/internal/workflow"
 )
 
@@ -67,22 +68,15 @@ func BuildReadiness(root string, args []string, stdout, stderr io.Writer) int {
 // state.md field value.
 var fieldAnnotation = regexp.MustCompile(`[[:space:]]*(#|\|).*$`)
 
-// readinessField reads a `Key: value` field from state.md, tolerating a leading
-// "- " bullet and trimming any trailing annotation and blanks. It returns the
-// first match, or "" when the key is absent. A key may contain spaces (e.g.
-// "Plan approved") — it is matched literally.
+// readinessField reads canonical cursor tables and legacy bullet fields, then
+// trims the legacy trailing annotations accepted by the original command.
 func readinessField(lines []string, key string) string {
-	field := regexp.MustCompile(`^[[:space:]]*-?[[:space:]]*` + key + `:[[:space:]]*`)
-	for _, line := range lines {
-		loc := field.FindStringIndex(line)
-		if loc == nil {
-			continue
-		}
-		value := line[loc[1]:]
-		if m := fieldAnnotation.FindStringIndex(value); m != nil {
-			value = value[:m[0]]
-		}
-		return strings.TrimRight(value, spaceChars)
+	value, ok := state.CursorField(lines, key)
+	if !ok {
+		return ""
+	}
+	if m := fieldAnnotation.FindStringIndex(value); m != nil {
+		value = value[:m[0]]
 	}
-	return ""
+	return strings.TrimRight(value, spaceChars)
 }

package/engine/internal/lib/cursor_compat_test.go

@@ -0,0 +1,91 @@
+package lib
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const canonicalCursor = `# State
+
+## Cursor
+| Key | Value |
+| --- | --- |
+| phase | temper |
+| status | running |
+| next_action | /rite-define |
+| plan_approved | 2026-07-20 |
+| afk_slices_remaining | 2 |
+`
+
+func TestCanonicalCursorReadAndWriteConsumers(t *testing.T) {
+	root := t.TempDir()
+	dir := filepath.Join(root, "work", "demo")
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	statePath := filepath.Join(dir, "state.md")
+	if err := os.WriteFile(statePath, []byte(canonicalCursor), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	t.Run("build readiness", func(t *testing.T) {
+		var stdout, stderr bytes.Buffer
+		if code := BuildReadiness(root, []string{"demo"}, &stdout, &stderr); code != 0 {
+			t.Fatalf("code=%d, stderr=%s", code, stderr.String())
+		}
+	})
+
+	t.Run("progress", func(t *testing.T) {
+		var stdout bytes.Buffer
+		if code := Progress(root, []string{"demo"}, &stdout, &bytes.Buffer{}); code != 0 {
+			t.Fatalf("code=%d", code)
+		}
+		if !strings.Contains(stdout.String(), "rite-temper") || !strings.Contains(stdout.String(), "temper ◉") {
+			t.Fatalf("progress ignored table phase:\n%s", stdout.String())
+		}
+	})
+
+	t.Run("tick AFK", func(t *testing.T) {
+		var stdout, stderr bytes.Buffer
+		if code := TickAfk([]string{statePath}, &stdout, &stderr); code != 0 {
+			t.Fatalf("code=%d, stderr=%s", code, stderr.String())
+		}
+		raw, err := os.ReadFile(statePath)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(string(raw), "| afk_slices_remaining | 1 |") {
+			t.Fatalf("tick AFK did not preserve/update table:\n%s", raw)
+		}
+	})
+}
+
+func TestClearAwaitingSupportsCanonicalCursor(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "state.md")
+	state := canonicalCursor + `
+## Awaiting human
+| Key | Value |
+| --- | --- |
+| question_id | Q-001 |
+| gate | blocking |
+`
+	state = strings.Replace(state, "| status | running |", "| status | awaiting_human |", 1)
+	if err := os.WriteFile(path, []byte(state), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := clearAwaiting(path, "Q-001"); err != nil {
+		t.Fatal(err)
+	}
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(raw)
+	if strings.Contains(text, "## Awaiting human") || !strings.Contains(text, "| status | running |") {
+		t.Fatalf("canonical awaiting state was not cleared:\n%s", text)
+	}
+}

package/engine/internal/lib/progress.go

@@ -7,13 +7,14 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+
+	"github.com/devrites/devrites/internal/state"
 )
 
 // State-parsing patterns ported verbatim from progress.sh's awk. Each name-strip
 // sub is anchored (^ or $), so it matches at most once per line — ReplaceAllString
 // is therefore equivalent to awk's single-match sub.
 var (
-	phaseSplitRe   = regexp.MustCompile(`: *`)
 	sliceCheckRe   = regexp.MustCompile(`^- \[[^\]]*\][[:space:]]*`)             // drop "- [x] "
 	sliceNameRe    = regexp.MustCompile(`^Slice[[:space:]]*[0-9]+:[[:space:]]*`) // drop "Slice N: "
 	sliceStateRe   = regexp.MustCompile(`[[:space:]]+(built|pending)[[:space:]]*$`)
@@ -77,17 +78,25 @@ func Progress(root string, args []string, stdout, stderr io.Writer) int {
 		}
 	}
 
-	// Flow ribbon: the lifecycle spine; temper/vet appear only once their artifact
-	// exists.
-	order := []string{"spec"}
-	if isFile(filepath.Join(workDir, "strategy.md")) {
+	// Flow ribbon: the lifecycle spine; optional phases appear once their artifact
+	// exists or while they are the active phase, so the cursor is never omitted.
+	var order []string
+	if phase == "frame" {
+		order = append(order, "frame")
+	}
+	order = append(order, "spec")
+	if phase == "temper" || isFile(filepath.Join(workDir, "strategy.md")) {
 		order = append(order, "temper")
 	}
 	order = append(order, "define")
-	if isFile(filepath.Join(workDir, "eng-review.md")) {
+	if phase == "vet" || isFile(filepath.Join(workDir, "eng-review.md")) {
 		order = append(order, "vet")
 	}
-	order = append(order, "build", "prove", "polish", "review", "seal", "ship")
+	order = append(order, "build")
+	if phase == "converge" {
+		order = append(order, "converge")
+	}
+	order = append(order, "prove", "polish", "review", "seal", "ship")
 
 	cur := phase
 	if cur == "plan" { // replan sits at build
@@ -118,25 +127,17 @@ func Progress(root string, args []string, stdout, stderr io.Writer) int {
 	return 0
 }
 
-// parsePhase returns the first whitespace token of the value on the first
-// "- Phase:" line, mirroring progress.sh's `awk -F': *' '/^- Phase:/{print $2}' |
-// awk '{print $1}'`. Empty when absent.
+// parsePhase returns the first token of the canonical or legacy phase field.
 func parsePhase(lines []string) string {
-	for _, line := range lines {
-		if !strings.HasPrefix(line, "- Phase:") {
-			continue
-		}
-		fields := phaseSplitRe.Split(line, -1)
-		if len(fields) < 2 {
-			return ""
-		}
-		toks := strings.Fields(fields[1])
-		if len(toks) == 0 {
-			return ""
-		}
-		return toks[0]
+	value, ok := state.CursorField(lines, "phase")
+	if !ok {
+		return ""
+	}
+	toks := strings.Fields(value)
+	if len(toks) == 0 {
+		return ""
 	}
-	return ""
+	return toks[0]
 }
 
 // tallySlices reads the "## Slice progress" block: total slice lines, how many are

package/engine/internal/lib/resolve.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/state"
 	"github.com/devrites/devrites/internal/workflow"
 )
 
@@ -285,8 +286,6 @@ func rewriteQuestionFields(lines []string, target *regexp.Regexp, status, answer
 var (
 	awaitingRe = regexp.MustCompile(`^## Awaiting human`)
 	hdrSpaceRe = regexp.MustCompile(`^##[[:space:]]`)
-	statusMdRe = regexp.MustCompile(`^- Status:`)
-	nextStepRe = regexp.MustCompile(`^- Next step:`)
 	logHdrRe   = regexp.MustCompile(`^## Log`)
 )
 
@@ -300,10 +299,9 @@ func clearAwaiting(sfile, qid string) error {
 		return fmt.Errorf("read state %s: %w", sfile, err)
 	}
 	lines := splitLinesNoTrailing(data)
-	qidRef := regexp.MustCompile(`qid:[[:space:]]*` + regexp.QuoteMeta(qid) + `([[:space:]]|$)`)
-
 	// First check whether the awaiting block references this question at all.
-	inAw, matched := false, false
+	inAw := false
+	var awaitingLines []string
 	for _, line := range lines {
 		switch {
 		case awaitingRe.MatchString(line):
@@ -312,11 +310,12 @@ func clearAwaiting(sfile, qid string) error {
 		case inAw && hdrSpaceRe.MatchString(line):
 			inAw = false
 		}
-		if inAw && qidRef.MatchString(line) {
-			matched = true
+		if inAw {
+			awaitingLines = append(awaitingLines, line)
 		}
 	}
-	if !matched {
+	waitingOn, _ := state.CursorField(awaitingLines, "question_id")
+	if waitingOn != qid {
 		return nil
 	}
 
@@ -336,12 +335,6 @@ func clearAwaiting(sfile, qid string) error {
 			continue
 		}
 		switch {
-		case statusMdRe.MatchString(line):
-			out = append(out, "- Status: running")
-			continue
-		case nextStepRe.MatchString(line):
-			out = append(out, "- Next step: (resume — `"+workflow.ForVerb("build").Both()+"` to continue the workflow)")
-			continue
 		case logHdrRe.MatchString(line):
 			out = append(out, line)
 			inLog = true
@@ -360,6 +353,8 @@ func clearAwaiting(sfile, qid string) error {
 	if inLog && !logAppended {
 		out = append(out, fmt.Sprintf("- %s build: resolved %s", ts, qid))
 	}
+	out, _ = state.SetCursorField(out, "status", "running")
+	out, _ = state.SetCursorField(out, "next_action", "(resume — `"+workflow.ForVerb("build").Both()+"` to continue the workflow)")
 	if err := fsutil.WriteFileAtomic(sfile, joinRecords(out), 0o644); err != nil {
 		return fmt.Errorf("update state %s: %w", sfile, err)
 	}

package/engine/internal/lib/tickafk.go

@@ -4,17 +4,13 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"regexp"
 	"strconv"
 	"strings"
 
 	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/state"
 )
 
-// budgetField matches an "AFK slices remaining:" line and captures the value that
-// follows. The optional leading "- " tolerates state.md's markdown-bullet form.
-var budgetField = regexp.MustCompile(`^[[:space:]]*-?[[:space:]]*AFK slices remaining:[[:space:]]*`)
-
 // TickAfk spends one slice from a run's AFK budget: it reads the "AFK slices
 // remaining" count from the state.md at args[0], decrements it, and writes the
 // file back. /rite-build calls it after building a slice unattended.
@@ -69,31 +65,18 @@ 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) {
-	for _, line := range lines {
-		loc := budgetField.FindStringIndex(line)
-		if loc == nil {
-			continue
-		}
-		value = line[loc[1]:]
-		if i := strings.IndexAny(value, spaceChars); i >= 0 {
-			value = value[:i]
-		}
-		return value, true
+	value, found = state.CursorField(lines, "afk_slices_remaining")
+	if !found {
+		return "", false
 	}
-	return "", false
+	if i := strings.IndexAny(value, spaceChars); i >= 0 {
+		value = value[:i]
+	}
+	return value, true
 }
 
-// setBudget rewrites every budget line to the canonical bullet form with the new
-// count, passing all other lines through. The result is newline-terminated.
+// setBudget preserves the cursor's canonical-table or legacy-bullet format.
 func setBudget(lines []string, n int) []byte {
-	var b strings.Builder
-	for _, line := range lines {
-		if budgetField.MatchString(line) {
-			fmt.Fprintf(&b, "- AFK slices remaining: %d", n)
-		} else {
-			b.WriteString(line)
-		}
-		b.WriteByte('\n')
-	}
-	return []byte(b.String())
+	updated, _ := state.SetCursorField(lines, "afk_slices_remaining", strconv.Itoa(n))
+	return []byte(strings.Join(updated, "\n") + "\n")
 }

package/engine/internal/migrate/migrate.go

@@ -141,29 +141,29 @@ Normalized by DevRites migration.
 `, slug, slug, phase, state.SchemaVersion)
 }
 
-// derivePhase reads the legacy state.md and maps its recorded phase/status onto a
-// v1 phase. An unreadable or unrecognised state defaults to build — the safe
-// middle of the arc, from which the completeness gates re-derive what's missing.
+// derivePhase reads state.md in either canonical cursor-table or legacy form and
+// maps its recorded phase/status onto the current lifecycle. An unreadable or
+// unrecognised state defaults to build — the safe middle of the arc, from which
+// the completeness gates re-derive what's missing.
 func derivePhase(statePath string) state.Phase {
 	raw, err := os.ReadFile(statePath)
 	if err != nil {
 		return state.PhaseBuild
 	}
-	for _, line := range strings.Split(string(raw), "\n") {
-		t := strings.TrimLeft(strings.ToLower(strings.TrimSpace(line)), "-*+ \t")
-		key, val, ok := strings.Cut(t, ":")
-		if !ok || (strings.TrimSpace(key) != "phase" && strings.TrimSpace(key) != "status") {
-			continue
-		}
-		if p, ok := mapLegacyPhase(strings.TrimSpace(val)); ok {
-			return p
+	lines := strings.Split(string(raw), "\n")
+	for _, key := range []string{"phase", "status"} {
+		if value, found := state.CursorField(lines, key); found {
+			if p, ok := mapLegacyPhase(value); ok {
+				return p
+			}
 		}
 	}
 	return state.PhaseBuild
 }
 
-// mapLegacyPhase maps a legacy phase/status word onto a v1 phase.
+// mapLegacyPhase maps a current or legacy phase/status word onto the lifecycle.
 func mapLegacyPhase(word string) (state.Phase, bool) {
+	word = strings.ToLower(strings.TrimSpace(word))
 	// Take the first token, so "done — shipped 2024" maps on "done".
 	if i := strings.IndexAny(word, " \t—-"); i > 0 {
 		word = word[:i]
@@ -173,18 +173,30 @@ func mapLegacyPhase(word string) (state.Phase, bool) {
 		return state.PhaseFrame, true
 	case "spec", "specced", "specifying":
 		return state.PhaseSpec, true
-	case "plan", "planned", "define", "defined":
+	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 "vet", "review", "reviewing", "vetting":
-		return state.PhaseVet, 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", "done", "closed", "complete", "completed":
+	case "ship", "shipped", "shipping":
 		return state.PhaseShip, true
+	case "done", "closed", "complete", "completed":
+		return state.PhaseDone, true
 	default:
 		return "", false
 	}

package/engine/internal/migrate/migrate_test.go

@@ -41,8 +41,8 @@ func TestRunNormalizesCanonicalWorkLayout(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if f.Phase != state.PhaseShip {
-		t.Fatalf("migrated phase=%q, want %q", f.Phase, state.PhaseShip)
+	if f.Phase != state.PhaseDone {
+		t.Fatalf("migrated phase=%q, want %q", f.Phase, state.PhaseDone)
 	}
 	assertFile(t, res.BackupDir, "ACTIVE", "alpha\n")
 
@@ -87,7 +87,9 @@ func TestMapLegacyPhase(t *testing.T) {
 	}{
 		{word: "specced", want: state.PhaseSpec, ok: true},
 		{word: "in-progress", want: state.PhaseBuild, ok: true},
-		{word: "done - shipped", want: state.PhaseShip, 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"},
 	} {
 		got, ok := mapLegacyPhase(tc.word)

package/engine/internal/state/cursor.go

@@ -0,0 +1,84 @@
+package state
+
+import (
+	"strings"
+	"unicode"
+)
+
+type cursorLineKind uint8
+
+const (
+	cursorLineUnknown cursorLineKind = iota
+	cursorLineLegacy
+	cursorLineTable
+)
+
+// CursorField reads a state.md field from either the canonical | key | value |
+// cursor table or the legacy "- Key: value" form.
+func CursorField(lines []string, key string) (string, bool) {
+	want := normalizeCursorKey(key)
+	for _, line := range lines {
+		gotKey, value, _, ok := parseCursorLine(line)
+		if ok && normalizeCursorKey(gotKey) == want {
+			return value, true
+		}
+	}
+	return "", false
+}
+
+// SetCursorField replaces an existing state.md field without changing whether
+// the file uses the canonical table or legacy bullet form.
+func SetCursorField(lines []string, key, value string) ([]string, bool) {
+	want := normalizeCursorKey(key)
+	out := append([]string(nil), lines...)
+	for i, line := range out {
+		gotKey, _, kind, ok := parseCursorLine(line)
+		if !ok || normalizeCursorKey(gotKey) != want {
+			continue
+		}
+		switch kind {
+		case cursorLineTable:
+			indent := line[:len(line)-len(strings.TrimLeft(line, " \t"))]
+			out[i] = indent + "| " + strings.TrimSpace(gotKey) + " | " + value + " |"
+		case cursorLineLegacy:
+			colon := strings.IndexByte(line, ':')
+			out[i] = line[:colon+1] + " " + value
+		}
+		return out, true
+	}
+	return out, false
+}
+
+func parseCursorLine(line string) (key, value string, kind cursorLineKind, ok bool) {
+	trimmed := strings.TrimSpace(line)
+	if len(trimmed) >= 2 && trimmed[0] == '|' && trimmed[len(trimmed)-1] == '|' {
+		cells := strings.Split(trimmed[1:len(trimmed)-1], "|")
+		if len(cells) >= 2 {
+			return strings.TrimSpace(cells[0]), strings.TrimSpace(cells[1]), cursorLineTable, true
+		}
+	}
+
+	trimmed = strings.TrimLeft(trimmed, "-*+ \t")
+	key, value, ok = strings.Cut(trimmed, ":")
+	if !ok || strings.TrimSpace(key) == "" {
+		return "", "", cursorLineUnknown, false
+	}
+	return strings.TrimSpace(key), strings.TrimSpace(value), cursorLineLegacy, true
+}
+
+func normalizeCursorKey(key string) string {
+	var b strings.Builder
+	for _, r := range strings.ToLower(key) {
+		if unicode.IsLetter(r) || unicode.IsDigit(r) {
+			b.WriteRune(r)
+		}
+	}
+	switch b.String() {
+	case "nextstep":
+		return "nextaction"
+	case "qid":
+		return "questionid"
+	default:
+		return b.String()
+	}
+}

package/engine/internal/state/cursor_test.go

@@ -0,0 +1,58 @@
+package state
+
+import "testing"
+
+func TestCursorFieldReadsCanonicalTableAndLegacyLines(t *testing.T) {
+	table := []string{
+		"| Key | Value |",
+		"| --- | --- |",
+		"| phase | temper |",
+		"| status | awaiting_human |",
+		"| next_action | /rite-define |",
+	}
+	legacy := []string{
+		"- Phase: build",
+		"- Status: running",
+		"- Next step: /rite-prove",
+	}
+
+	for _, tc := range []struct {
+		name  string
+		lines []string
+		key   string
+		want  string
+	}{
+		{"table phase", table, "phase", "temper"},
+		{"table status", table, "status", "awaiting_human"},
+		{"table next alias", table, "Next step", "/rite-define"},
+		{"legacy phase", legacy, "phase", "build"},
+		{"legacy next alias", legacy, "next_action", "/rite-prove"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, ok := CursorField(tc.lines, tc.key)
+			if !ok || got != tc.want {
+				t.Fatalf("CursorField(%q) = %q, %v; want %q, true", tc.key, got, ok, tc.want)
+			}
+		})
+	}
+}
+
+func TestSetCursorFieldPreservesCanonicalAndLegacyFormats(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		lines []string
+		key   string
+		value string
+		want  string
+	}{
+		{"table", []string{"| status | awaiting_human |"}, "status", "running", "| status | running |"},
+		{"legacy", []string{"- AFK slices remaining: 2"}, "afk_slices_remaining", "1", "- AFK slices remaining: 1"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, ok := SetCursorField(tc.lines, tc.key, tc.value)
+			if !ok || len(got) != 1 || got[0] != tc.want {
+				t.Fatalf("SetCursorField() = %v, %v; want [%q], true", got, ok, tc.want)
+			}
+		})
+	}
+}

package/engine/internal/state/feature.go

@@ -124,11 +124,11 @@ func CandidateFiles(root, slug string) []string {
 	return files
 }
 
-// LoadFeature reads feature <slug> under root. The phase comes from the manifest
-// (feature.md) frontmatter when present, otherwise from the working-state ledger
-// (state.md, a "- Phase: <p>" line) the live pack writes. A feature with neither a
-// manifest nor a ledger does not exist. Section content is read from the canonical
-// section files or their transitional aliases (see sectionFiles).
+// 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.
+// Section content is read from the canonical section files or their transitional
+// aliases (see sectionFiles).
 func LoadFeature(root, slug string) (*Feature, error) {
 	dir := featureDir(root, slug)
 
@@ -142,7 +142,7 @@ func LoadFeature(root, slug string) (*Feature, error) {
 		return nil, fmt.Errorf("feature %q not found", slug)
 	}
 
-	var phase Phase
+	var manifestPhase Phase
 	if hasManifest {
 		fm, _ := splitFrontmatter(manifest)
 		if v := strings.TrimSpace(fm["schemaVersion"]); v != "" {
@@ -154,12 +154,16 @@ func LoadFeature(root, slug string) (*Feature, error) {
 				return nil, fmt.Errorf("feature %q: schemaVersion %d is newer than this engine supports (%d); upgrade devrites", slug, n, SchemaVersion)
 			}
 		}
-		phase = Phase(strings.TrimSpace(fm["phase"]))
+		manifestPhase = Phase(strings.TrimSpace(fm["phase"]))
 	}
-	// Ledger fallback: only when the manifest did not declare a phase, so a manifest
-	// with an explicit-but-unknown phase still surfaces as that error below.
-	if phase == "" {
-		phase = PhaseFromLedger(filepath.Join(dir, LedgerFile))
+
+	// state.md is the mutable runtime cursor, so it must win over the manifest,
+	// which migration and compatibility flows may leave stale. Preserve an
+	// explicitly unknown ledger value so the validation below reports it rather
+	// than silently falling back to feature.md.
+	phase, ledgerDeclared := declaredPhaseFromLedger(filepath.Join(dir, LedgerFile))
+	if !ledgerDeclared {
+		phase = manifestPhase
 	}
 	if phase == "" {
 		return nil, fmt.Errorf("feature %q: no phase in feature.md frontmatter or %s ledger", slug, LedgerFile)
@@ -186,31 +190,30 @@ func sectionPresentAny(dir string, s Section) bool {
 	return false
 }
 
-// PhaseFromLedger reads a phase from the working-state ledger: the value of a
-// "- Phase: <p>" line (leading list markers tolerated), taking the first token
-// and accepting it only if it is a phase the engine understands. Returns "" when
-// the file is absent or declares no recognized phase. Unlike migrate's tolerant
-// legacy mapping, this accepts only canonical phase words — the live pack's form.
+// 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 ""
+		return "", false
 	}
-	for _, line := range strings.Split(string(raw), "\n") {
-		t := strings.TrimLeft(strings.TrimSpace(line), "-*+ \t")
-		key, val, ok := strings.Cut(t, ":")
-		if !ok || !strings.EqualFold(strings.TrimSpace(key), "phase") {
-			continue
-		}
-		word := strings.ToLower(strings.TrimSpace(val))
-		if i := strings.IndexAny(word, " \t"); i > 0 {
-			word = word[:i]
-		}
-		if p := Phase(word); KnownPhase(p) {
-			return p
-		}
+	value, ok := CursorField(strings.Split(string(raw), "\n"), "phase")
+	if !ok {
+		return "", false
 	}
-	return ""
+	word := strings.ToLower(strings.TrimSpace(value))
+	if i := strings.IndexAny(word, " \t"); i > 0 {
+		word = word[:i]
+	}
+	return Phase(word), true
 }
 
 // ReadDeclaredSchemaVersion returns the schemaVersion declared in a feature's

package/engine/internal/state/schema.go

@@ -46,36 +46,48 @@ var sectionFiles = map[Section][]string{
 }
 
 // LedgerFile is the working-state ledger the live pack writes. It carries the
-// phase (as a "- Phase: <p>" line) when no feature.md manifest declares one, and
-// it satisfies the status section.
+// phase in its canonical cursor table (legacy "- Phase: <p>" remains readable)
+// when no feature.md manifest declares one, and it satisfies the status section.
 const LedgerFile = "state.md"
 
 // Phase is a workflow state. The order mirrors the rite-* arc.
 type Phase string
 
 const (
-	PhaseFrame Phase = "frame" // problem framing
-	PhaseSpec  Phase = "spec"  // specification
-	PhasePlan  Phase = "plan"  // planning
-	PhaseBuild Phase = "build" // implementation
-	PhaseProve Phase = "prove" // proof / testing
-	PhaseVet   Phase = "vet"   // review
-	PhaseSeal  Phase = "seal"  // completeness seal
-	PhaseShip  Phase = "ship"  // shipping
+	PhaseFrame    Phase = "frame"    // problem framing
+	PhaseSpec     Phase = "spec"     // specification
+	PhaseTemper   Phase = "temper"   // strategic specification review
+	PhaseDefine   Phase = "define"   // plan definition
+	PhasePlan     Phase = "plan"     // approved plan
+	PhaseVet      Phase = "vet"      // pre-build engineering review
+	PhaseBuild    Phase = "build"    // implementation
+	PhaseConverge Phase = "converge" // post-build gap closure
+	PhaseProve    Phase = "prove"    // proof / testing
+	PhasePolish   Phase = "polish"   // quality pass
+	PhaseReview   Phase = "review"   // post-proof review
+	PhaseSeal     Phase = "seal"     // completeness seal
+	PhaseShip     Phase = "ship"     // shipping
+	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},
-	PhasePlan:  {SectionSpec, SectionPlan},
-	PhaseBuild: {SectionSpec, SectionPlan, SectionDecisions, SectionTasks},
-	PhaseProve: {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof},
-	PhaseVet:   {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof},
-	PhaseSeal:  {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus},
-	PhaseShip:  {SectionSpec, SectionPlan, SectionDecisions, SectionTasks, SectionProof, SectionStatus},
+	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},
 }
 
 // KnownPhase reports whether p is a phase the engine understands.

package/engine/internal/state/snapshot.go

@@ -121,7 +121,7 @@ func Snapshot(root, slug string) (*WorkspaceSnapshot, error) {
 	}
 
 	workDir := featureDir(root, report.Slug)
-	next := workflow.ForPhase(string(report.Phase))
+	next := nextCommand(workDir, report.Phase)
 	snap := &WorkspaceSnapshot{
 		SchemaVersion:  WorkspaceSnapshotSchema,
 		Slug:           report.Slug,
@@ -152,7 +152,7 @@ func Snapshot(root, slug string) (*WorkspaceSnapshot, error) {
 	if snap.RunMode == "AFK" && len(snap.MissingSections) > 0 {
 		snap.Warnings = append(snap.Warnings, "AFK workspace has missing required sections")
 	}
-	if snap.Evidence.Status == "missing" && (report.Phase == PhaseProve || report.Phase == PhaseSeal || report.Phase == PhaseShip) {
+	if report.Required[SectionProof] && snap.Evidence.Status != "fresh" {
 		snap.Warnings = append(snap.Warnings, "proof phase requires fresh evidence")
 	}
 	if snap.Drift.Open > 0 {
@@ -161,6 +161,17 @@ func Snapshot(root, slug string) (*WorkspaceSnapshot, error) {
 	return snap, nil
 }
 
+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 command := workflow.ForAction(action); command.Verb != "" {
+				return command
+			}
+		}
+	}
+	return workflow.ForPhase(string(phase))
+}
+
 func readActiveSlug(root string) string {
 	if ws := devritespaths.WorkspaceOverride(root, ""); ws != "" {
 		return filepath.Base(ws)

package/engine/internal/state/state_test.go

@@ -126,6 +126,52 @@ func TestLoadFeatureFromLedgerAndAliases(t *testing.T) {
 	}
 }
 
+func TestLedgerPhaseOverridesStaleManifestPhase(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	writeWorkSection(t, root, "live", "feature.md", "---\nphase: spec\nschemaVersion: 1\n---\n")
+	writeWorkSection(t, root, "live", "state.md", "| Key | Value |\n| --- | --- |\n| phase | temper |\n")
+	writeWorkSection(t, root, "live", "spec.md", "# Spec\n\nReady.\n")
+
+	rep, err := Status(root, "live")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rep.Phase != PhaseTemper {
+		t.Fatalf("phase=%q, want current ledger phase %q", rep.Phase, PhaseTemper)
+	}
+}
+
+func TestSnapshotUsesCanonicalNextActionAndWarnsWhenRequiredProofMissing(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	writeWorkSection(t, root, "live", "state.md", `# State
+
+| Key | Value |
+| --- | --- |
+| phase | review |
+| status | running |
+| next_action | /rite-seal after review is clean |
+`)
+	for name, body := range map[string]string{
+		"spec.md":      "# Spec\n\nReady.\n",
+		"plan.md":      "# Plan\n\nReady.\n",
+		"decisions.md": "# Decisions\n\nReady.\n",
+		"tasks.md":     "# Tasks\n\nReady.\n",
+	} {
+		writeWorkSection(t, root, "live", name, body)
+	}
+
+	snap, err := Snapshot(root, "live")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if snap.NextCommands.Verb != "seal" || snap.NextCommand != "/rite-seal" {
+		t.Fatalf("next commands=%+v legacy=%q, want canonical next_action seal", snap.NextCommands, snap.NextCommand)
+	}
+	if got := strings.Join(snap.Warnings, "\n"); !strings.Contains(got, "requires fresh evidence") {
+		t.Fatalf("warnings=%v, want missing required-proof warning", snap.Warnings)
+	}
+}
+
 func TestWorkLayoutIsCanonicalAndFeaturesIsAlias(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
 	writeWorkSection(t, root, "live", "state.md", "- Phase: build\n")
@@ -148,9 +194,8 @@ func TestWorkLayoutIsCanonicalAndFeaturesIsAlias(t *testing.T) {
 	}
 }
 
-// An unknown phase word in the ledger is ignored (not accepted as a phase), so a
-// ledger-only feature with no recognizable phase is a clear error, not a silent
-// mis-load.
+// An unknown phase word in the ledger is rejected, so a ledger-only feature is a
+// clear error rather than silently falling back or mis-loading.
 func TestLedgerPhaseRejectsUnknownWord(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
 	writeSection(t, root, "bogus", "state.md", "- Phase: banana\n")

package/engine/internal/workflow/commands.go

@@ -13,14 +13,19 @@ type Command struct {
 }
 
 var phaseToVerb = map[string]string{
-	"frame": "frame",
-	"spec":  "spec",
-	"plan":  "define",
-	"build": "build",
-	"prove": "prove",
-	"vet":   "vet",
-	"seal":  "seal",
-	"ship":  "ship",
+	"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
@@ -35,6 +40,18 @@ func ForVerb(verb string) Command {
 	return Command{Verb: verb, Claude: "/" + name, Codex: "$" + name}
 }
 
+// ForAction extracts the first explicit rite invocation from a cursor action.
+// Cursor values may append a short reason after the command.
+func ForAction(action string) Command {
+	for _, field := range strings.Fields(action) {
+		field = strings.Trim(field, "`'\"()[]{}<>,.;:")
+		if strings.HasPrefix(field, "/rite-") || strings.HasPrefix(field, "$rite-") {
+			return ForVerb(field)
+		}
+	}
+	return Command{}
+}
+
 // ForPhase returns the next public command for a workflow phase.
 func ForPhase(phase string) Command {
 	verb := phaseToVerb[strings.TrimSpace(strings.ToLower(phase))]

package/engine/internal/workflow/commands_test.go

@@ -0,0 +1,35 @@
+package workflow
+
+import "testing"
+
+func TestForActionExtractsCanonicalInvocation(t *testing.T) {
+	for _, tc := range []struct {
+		action string
+		verb   string
+	}{
+		{action: "/rite-define after readiness passes", verb: "define"},
+		{action: "resume with $rite-build", verb: "build"},
+		{action: "none"},
+	} {
+		if got := ForAction(tc.action); got.Verb != tc.verb {
+			t.Fatalf("ForAction(%q).Verb=%q, want %q", tc.action, got.Verb, tc.verb)
+		}
+	}
+}
+
+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/tests/adr_0004_required_by_phase_test.go

@@ -16,12 +16,18 @@ import (
 var phaseArc = []state.Phase{
 	state.PhaseFrame,
 	state.PhaseSpec,
+	state.PhaseTemper,
+	state.PhaseDefine,
 	state.PhasePlan,
+	state.PhaseVet,
 	state.PhaseBuild,
+	state.PhaseConverge,
 	state.PhaseProve,
-	state.PhaseVet,
+	state.PhasePolish,
+	state.PhaseReview,
 	state.PhaseSeal,
 	state.PhaseShip,
+	state.PhaseDone,
 }
 
 func TestADR0004RequiredSectionsAreAdditiveDownTheArc(t *testing.T) {

package/engine/tests/gate_test.go

@@ -85,6 +85,28 @@ func TestReadinessPassesCompletePhase(t *testing.T) {
 	}
 }
 
+func TestReadinessAcceptsCanonicalTemperCursor(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	testutil.WriteFile(t, filepath.Join(root, "work", "tempered", "state.md"), `# State
+
+## Cursor
+| Key | Value |
+| --- | --- |
+| phase | temper |
+| status | running |
+| next_action | /rite-define |
+`)
+	testutil.WriteFile(t, filepath.Join(root, "work", "tempered", "spec.md"), "# Spec\n\nReady.\n")
+
+	out, errOut, code := runDevrites(t, root, "readiness", "tempered")
+	if code != 0 {
+		t.Fatalf("exit = %d, want 0; stderr:\n%s", code, errOut)
+	}
+	if !strings.Contains(out, "phase: temper") || !strings.Contains(out, "result: pass") {
+		t.Fatalf("unexpected readiness output:\n%s", out)
+	}
+}
+
 func TestSealBlocksWhenSealSectionsMissing(t *testing.T) {
 	root := newWorkspace(t)
 	out, _, code := runDevrites(t, root, "seal", "auth-tokens")

package/engine/tests/migrate_cli_test.go

@@ -20,7 +20,7 @@ func workWorkspace(t *testing.T) (root, slug string) {
 		t.Fatal(err)
 	}
 	files := map[string]string{
-		"state.md":     "# State\n\nphase: build\n\nWorking on it.\n",
+		"state.md":     "# State\n\n| Key | Value |\n| --- | --- |\n| phase | temper |\n| status | running |\n",
 		"spec.md":      "# Spec\n\nRotate tokens.\n",
 		"plan.md":      "# Plan\n\nStep 1, step 2.\n",
 		"tasks.md":     "# Tasks\n\n- [x] one\n",
@@ -68,7 +68,7 @@ func TestMigrateNormalizesCanonicalWorkSchema(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !strings.Contains(string(fm), "phase: build") {
+	if !strings.Contains(string(fm), "phase: temper") {
 		t.Errorf("feature.md phase not derived from state.md\n%s", fm)
 	}
 	if !strings.Contains(string(fm), "schemaVersion: 1") {
@@ -94,7 +94,7 @@ func TestMigratePostStatusWorks(t *testing.T) {
 	if code != 0 {
 		t.Fatalf("status after migrate exit = %d (stderr: %s)", code, errOut)
 	}
-	if !strings.Contains(out, "phase: build") {
+	if !strings.Contains(out, "phase: temper") {
 		t.Errorf("migrated feature status is wrong\n%s", out)
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "DevRites — disciplined senior-engineer workflow skills pack for Claude Code and Codex",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",