devrites 3.0.0 → 3.0.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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
+
+* **rite:** run analysis after task definition ([6373227](https://github.com/ViktorsBaikers/DevRites/commit/6373227521b5e1e6b22bfe48e98799e709f5dc7a))
+
 ## [3.0.0](https://github.com/ViktorsBaikers/DevRites/compare/v2.6.1...v3.0.0) (2026-07-17)
 
 ### ⚠ BREAKING CHANGES

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.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.0.0) — 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/docs/engine/commands.md

@@ -159,7 +159,7 @@ Prohibitions tables — a blocking spec-gate check.
 any code is written, so a coverage gap surfaces as a one-line plan edit instead of a reslice
 mid-build. It emits a markdown report with four passes:
 
-- **Coverage** — a spec `[ACn]` that no slice `Satisfies:` (**CRITICAL**).
+- **Coverage** — a spec `AC-###` that no slice `Satisfies:` (**CRITICAL**; legacy `[ACn]` remains supported).
 - **Consistency** — a slice that `Satisfies:` an AC the spec never defines (**CRITICAL**).
 - **Orphan slice** — a slice satisfying no acceptance criterion (warn).
 - **Ambiguity** — an unquantified vague adjective (`fast`, `robust`, `intuitive`, …) or an

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/analyze.go

@@ -15,7 +15,7 @@ import (
 // written, so a coverage gap surfaces as a one-line plan edit rather than a reslice
 // mid-build. It emits a markdown report and flags:
 //
-//	Coverage     — a spec [ACn] that no slice Satisfies                (CRITICAL)
+//	Coverage     — a spec AC id that no slice Satisfies                 (CRITICAL)
 //	Consistency  — a slice that Satisfies an AC the spec never defines (CRITICAL)
 //	Orphan slice — a slice that satisfies no acceptance criterion       (warn)
 //	Ambiguity    — an unquantified vague adjective or unresolved
@@ -27,9 +27,8 @@ import (
 // Exit codes: 0 clear · 1 at least one CRITICAL finding · 2 no workspace (no active
 // slug, or spec.md/tasks.md missing).
 var (
-	specACRe           = regexp.MustCompile(`\[AC[0-9]+\]`) // a bracketed [ACn] in the spec
-	taskACRe           = regexp.MustCompile(`\bAC[0-9]+\b`) // a bare ACn in the tasks
-	sliceHeadRe        = regexp.MustCompile(`^##[[:space:]]*Slice`)
+	taskACRe           = regexp.MustCompile(`\b(?:AC-[0-9]{3}|AC[0-9]+)\b`)
+	sliceHeadRe        = regexp.MustCompile(`(?i)^##[[:space:]]*(?:SLICE-[0-9]{3}\b|Slice\b)`)
 	sliceNamePrefixRe  = regexp.MustCompile(`^##[[:space:]]*`) // stripped to leave the slice name
 	analyzeSatisfiesRe = regexp.MustCompile(`^[[:space:]]*Satisfies:`)
 	// Ambiguity scan: a vague quality adjective with no number on the line is an
@@ -57,7 +56,7 @@ func Analyze(root string, args []string, stdout, stderr io.Writer) int {
 	specData, _ := os.ReadFile(spec)
 	tasksData, _ := os.ReadFile(tasks)
 
-	specACs := sortedACIDs(specACRe, specData, true) // brackets stripped: "[AC1]" -> "AC1"
+	specACs := sortedACIDs(acIDRe, specData, true) // legacy brackets stripped: "[AC1]" -> "AC1"
 	taskACs := sortedACIDs(taskACRe, tasksData, false)
 	specSet := stringSet(specACs)
 	taskSet := stringSet(taskACs)
@@ -70,7 +69,7 @@ func Analyze(root string, args []string, stdout, stderr io.Writer) int {
 	covered := 0
 	fmt.Fprintln(stdout, "## Coverage")
 	if len(specACs) == 0 {
-		fmt.Fprintln(stdout, "- [warn] spec.md — no [ACn] acceptance ids found; tag criteria as '[AC1] ...' for a machine-checkable gate.")
+		fmt.Fprintln(stdout, "- [warn] spec.md — no AC-### acceptance ids found; tag criteria for a machine-checkable gate.")
 	} else {
 		for _, ac := range specACs {
 			if taskSet[ac] {
@@ -155,9 +154,9 @@ func ambiguityFindings(specData []byte) []string {
 			out = append(out, fmt.Sprintf("- [warn] spec.md:L%d — unresolved placeholder %q", ln, m))
 			continue
 		}
-		// Strip the AC id before the digit gate — else the id's own digit
-		// ("[AC1]") masks a vague adjective on the very criterion line it tags.
-		bare := specACRe.ReplaceAllString(line, "")
+		// Strip the AC id before the digit gate — else the id's own digit masks
+		// a vague adjective on the very criterion line it tags.
+		bare := acIDRe.ReplaceAllString(line, "")
 		bare = taskACRe.ReplaceAllString(bare, "")
 		if !analyzeDigitRe.MatchString(bare) {
 			if m := vagueAdjRe.FindString(bare); m != "" {
@@ -170,7 +169,7 @@ func ambiguityFindings(specData []byte) []string {
 
 // sortedACIDs collects every acceptance id matched by re, deduplicated and sorted
 // lexicographically. When strip is set the surrounding brackets are removed, so
-// "[AC1]" becomes "AC1". Returns nil when there are none.
+// Legacy "[AC1]" becomes "AC1". Returns nil when there are none.
 func sortedACIDs(re *regexp.Regexp, data []byte, strip bool) []string {
 	seen := map[string]bool{}
 	var out []string

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/checkacceptance.go

@@ -10,17 +10,17 @@ import (
 )
 
 // Executable acceptance criteria — a port of check-acceptance.sh. Grades the
-// [ACn]-tagged acceptance criteria in spec.md against seal.md: each spec
+// AC-### acceptance criteria in spec.md against seal.md: each spec
 // criterion must be checked ([x]) in seal.md. Without ids it falls back to a
 // count/unchecked heuristic. The spec-time mirror is SpecValidate (shape); this
-// grades proof.
+// grades proof. Legacy [ACn] ids remain supported for existing workspaces.
 //
 // Exit codes: 0 every criterion proven · 1 gap (uncovered/unproven) · 2 usage ·
 // 5 missing spec.md or seal.md.
 var (
 	acHeadingRe = regexp.MustCompile(`^##[[:space:]]+[Aa]cceptance [Cc]riteria`)
 	h2Re        = regexp.MustCompile(`^##[[:space:]]`)
-	acIDRe      = regexp.MustCompile(`\[AC[0-9]+\]`)
+	acIDRe      = regexp.MustCompile(`\[AC[0-9]+\]|\bAC-[0-9]{3}\b`)
 	checkedRe   = regexp.MustCompile(`^[[:space:]]*-[[:space:]]*\[[xX]\]`)
 	bulletRe    = regexp.MustCompile(`^[[:space:]]*-[[:space:]]`)
 	checkboxRe  = regexp.MustCompile(`^[[:space:]]*-[[:space:]]*\[[ xX]\]`)
@@ -64,7 +64,7 @@ func CheckAcceptance(ws string, stdout, stderr io.Writer) int {
 	specIDs := sortedUniqueIDs(specBody)
 
 	if len(specIDs) > 0 {
-		// ID mode — each spec [ACn] must be checked ([x]) in seal.md.
+		// ID mode — each spec AC id must be checked ([x]) in seal.md.
 		checkedIDs := map[string]bool{}
 		for _, line := range sealBody {
 			if checkedRe.MatchString(line) {
@@ -96,15 +96,15 @@ func CheckAcceptance(ws string, stdout, stderr io.Writer) int {
 	sealUnchecked := countMatching(sealBody, uncheckedRe)
 
 	if sealTotal < specN {
-		fmt.Fprintf(stderr, "check-acceptance: seal.md lists %d acceptance items but spec.md has %d criteria — %d dropped. (Tag criteria [AC1].. to grade by id.)\n",
+		fmt.Fprintf(stderr, "check-acceptance: seal.md lists %d acceptance items but spec.md has %d criteria — %d dropped. (Tag criteria AC-### to grade by id.)\n",
 			sealTotal, specN, specN-sealTotal)
 		return 1
 	}
 	if sealUnchecked > 0 {
-		fmt.Fprintf(stderr, "check-acceptance: %d acceptance criterion(s) unchecked in seal.md (unproven). (Tag criteria [AC1].. to grade by id.)\n", sealUnchecked)
+		fmt.Fprintf(stderr, "check-acceptance: %d acceptance criterion(s) unchecked in seal.md (unproven). (Tag criteria AC-### to grade by id.)\n", sealUnchecked)
 		return 1
 	}
-	fmt.Fprintf(stdout, "check-acceptance: OK — %d acceptance items all checked in seal.md (no ids; add [AC1].. for id-level grading)\n", sealTotal)
+	fmt.Fprintf(stdout, "check-acceptance: OK — %d acceptance items all checked in seal.md (no ids; add AC-### for id-level grading)\n", sealTotal)
 	return 0
 }
 
@@ -145,8 +145,8 @@ func sectionEmpty(lines []string) bool {
 	return strings.TrimRight(strings.Join(lines, "\n"), "\n") == ""
 }
 
-// sortedUniqueIDs extracts every [ACn] id from the lines and returns them sorted
-// and de-duplicated, matching `grep -oE '\[AC[0-9]+\]' | sort -u`.
+// sortedUniqueIDs extracts canonical AC-### and legacy [ACn] ids from the lines,
+// then returns them sorted and de-duplicated.
 func sortedUniqueIDs(lines []string) []string {
 	set := map[string]bool{}
 	for _, line := range lines {

package/engine/internal/lib/coverage.go

@@ -18,9 +18,9 @@ import (
 // criterion is covered by a slice and proven in the seal. Read-only.
 //
 // The convention pairs with check-acceptance: a criterion carries a stable id,
-// spec.md declares `- [ ] [ACn] …`, a tasks.md slice claims it with a
-// `Satisfies: ACn` line, and seal.md proves it with `- [x] [ACn] …`. A criterion
-// is proven iff its `[ACn]` id is checked in seal.md.
+// spec.md declares `- [ ] AC-###: …`, a tasks.md slice claims it with a
+// `Satisfies: AC-###` line, and seal.md proves it with `- [x] AC-###: …`.
+// Legacy [ACn] ids remain supported for existing workspaces.
 //
 // base is the project directory that contains the .devrites tree; slug defaults
 // to the active feature named in .devrites/ACTIVE. The matrix is the stdout
@@ -83,16 +83,14 @@ func Coverage(root string, args []string, stdout, stderr io.Writer) int {
 	return 0
 }
 
-// acIDRe (`\[AC[0-9]+\]`) is shared with check-acceptance, which declares it.
+// acIDRe is shared with check-acceptance, which declares it.
 var (
-	sliceHeaderRe = regexp.MustCompile(`^##[[:space:]]*Slice`)
-	sliceStripRe  = regexp.MustCompile(`^##[[:space:]]*`)
-	satisfiesRe   = regexp.MustCompile(`^[[:space:]]*Satisfies:`)
+	sliceStripRe = regexp.MustCompile(`^##[[:space:]]*`)
+	satisfiesRe  = regexp.MustCompile(`^[[:space:]]*Satisfies:`)
 )
 
-// acIDs returns the unique `[ACn]` ids declared in spec.md, bracket-stripped and
-// byte-order sorted — mirroring `grep -oE '\[AC[0-9]+\]' | tr -d '[]' | sort -u`
-// under LC_ALL=C.
+// acIDs returns unique canonical AC-### and legacy [ACn] ids declared in
+// spec.md, bracket-stripped and byte-order sorted.
 func acIDs(spec string) []string {
 	seen := map[string]bool{}
 	var ids []string
@@ -118,7 +116,7 @@ func slicesForAC(tasks, ac string) string {
 	sc := newLineScanner(strings.NewReader(tasks))
 	for sc.Scan() {
 		line := sc.Text()
-		if sliceHeaderRe.MatchString(line) {
+		if sliceHeadRe.MatchString(line) {
 			cur = sliceStripRe.ReplaceAllString(line, "")
 		}
 		if satisfiesRe.MatchString(line) && strings.Contains(line, ac) {
@@ -128,11 +126,11 @@ func slicesForAC(tasks, ac string) string {
 	return strings.Join(matched, ";")
 }
 
-// provenInSeal reports whether seal.md checks off ac's id — a line of the form
-// `- [x] [ACn]` (with optional surrounding whitespace), the same pattern the
-// script greps for.
+// provenInSeal reports whether seal.md contains a checked canonical or legacy
+// criterion line.
 func provenInSeal(seal, ac string) bool {
-	re := regexp.MustCompile(`(?m)^[[:space:]]*-[[:space:]]*\[x\][[:space:]]*\[` + regexp.QuoteMeta(ac) + `\]`)
+	quoted := regexp.QuoteMeta(ac)
+	re := regexp.MustCompile(`(?m)^[[:space:]]*-[[:space:]]*\[x\][[:space:]]*(?:\[` + quoted + `\]|` + quoted + `\b)`)
 	return re.MatchString(seal)
 }
 

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/lanes.go

@@ -83,7 +83,7 @@ func parseLaneSlices(md string) []laneSlice {
 	}
 	for _, line := range strings.Split(md, "\n") {
 		trim := strings.TrimSpace(line)
-		if strings.HasPrefix(trim, "## Slice") {
+		if sliceHeadRe.MatchString(trim) {
 			flush()
 			cur = &laneSlice{name: strings.TrimPrefix(trim, "## ")}
 			continue

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