devrites 3.0.0 → 3.0.2

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/testdata/golden/TestParityAnalyze/slug=noac.golden

@@ -2,7 +2,7 @@ exit 0
 # Cross-artifact analysis: noac
 
 ## Coverage
-- [warn] spec.md — no [ACn] acceptance ids found; tag criteria as '[AC1] ...' for a machine-checkable gate.
+- [warn] spec.md — no AC-### acceptance ids found; tag criteria for a machine-checkable gate.
 
 ## Consistency
 

package/engine/testdata/golden/TestParityCheckAcceptance/arg=flat-ok.golden

@@ -1,2 +1,2 @@
 exit 0
-check-acceptance: OK — 2 acceptance items all checked in seal.md (no ids; add [AC1].. for id-level grading)
+check-acceptance: OK — 2 acceptance items all checked in seal.md (no ids; add AC-### for id-level grading)

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

@@ -0,0 +1,44 @@
+package main_test
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCanonicalAcceptanceIDsAcrossGates(t *testing.T) {
+	work := t.TempDir()
+	writeFeatureFile(t, work, "canonical", "spec.md",
+		"## Acceptance criteria\n- [ ] AC-001: alpha\n- [ ] AC-002: beta\n")
+	writeFeatureFile(t, work, "canonical", "tasks.md",
+		"## SLICE-001 alpha\nSatisfies: AC-001\n## SLICE-002 beta\nSatisfies: AC-002\n## SLICE-003 orphan\n")
+	writeFeatureFile(t, work, "canonical", "seal.md",
+		"## Acceptance Criteria\n- [x] AC-001: alpha — evidence: t1\n- [x] AC-002: beta — evidence: t2\n")
+
+	t.Run("analyze", func(t *testing.T) {
+		stdout, stderr, code := runGo(t, work, "analyze", "canonical")
+		if code != 0 || !strings.Contains(stdout, "AC-001 — covered") || !strings.Contains(stdout, "slice 'SLICE-003 orphan'") {
+			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
+		}
+	})
+
+	t.Run("coverage", func(t *testing.T) {
+		stdout, stderr, code := runGo(t, work, "coverage", "canonical")
+		if code != 0 || !strings.Contains(stdout, "| AC-001 | SLICE-001 alpha | yes |") {
+			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
+		}
+	})
+
+	t.Run("check-acceptance", func(t *testing.T) {
+		stdout, stderr, code := runGo(t, work, "check-acceptance", ".devrites/features/canonical")
+		if code != 0 || !strings.Contains(stdout, "AC-001 AC-002") {
+			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
+		}
+	})
+
+	t.Run("lanes", func(t *testing.T) {
+		stdout, stderr, code := runGo(t, work, "lanes", "plan", "canonical")
+		if code != 0 || !strings.Contains(stdout, "- SLICE-001 alpha:") {
+			t.Fatalf("exit=%d stdout=%q stderr=%q", code, stdout, stderr)
+		}
+	})
+}

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/pack/.claude/skills/rite-define/SKILL.md

@@ -119,6 +119,12 @@ Pull these via `Read` when shaping the plan:
    as a blocking gate at `/rite-vet`; no file → none declared → nothing to check.)
 6. **Write** `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md`; update
    `state.md` (phase: plan → next `/rite-vet`).
+6a. **Cross-artifact gate — now that `tasks.md` exists.** Run the deterministic
+   spec↔tasks coverage/consistency check; any non-zero result blocks plan readiness:
+   ```bash
+   S="$(cat .devrites/ACTIVE 2>/dev/null)"
+   devrites-engine analyze "$S"
+   ```
 7. **Readiness gate** (bottom of plan-template): every acceptance criterion covered by a
    slice, dependency order acyclic + risk-first, no unjustified deviation, rollback for
    every destructive/migration step. **Stop and confirm** before code. Render the review-before-code

package/pack/.claude/skills/rite-spec/SKILL.md

@@ -185,6 +185,8 @@ stay flat `AC-###` bullets; the grammar is opt-in by rigor, never forced.
    devrites-engine spec-skeleton ".devrites/work/<slug>"
    devrites-engine spec-validate ".devrites/work/<slug>" --against .devrites/specs
    ```
+   **Do not run `devrites-engine analyze` in this phase:** `tasks.md` deliberately does not
+   exist yet. `/rite-define` owns the first analyze pass after it writes the slices.
    Treat edge/prohibition findings as blocking just like grammar findings. When it passes, write `Spec gate: passed <iso>` to `state.md`.
 6a. **Review-before-code digest.** Before handing off to planning, render the cheap human review:
    `Intent` (one sentence), `Done means` (top acceptance/scenario IDs), `Scope/risk` (what is in/out

package/pack/.claude/skills/rite-vet/SKILL.md

@@ -140,7 +140,12 @@ Audit for a plan resting on unstated beliefs).
    (`/rite-build` and `/rite-prove` read it). Harden `plan.md` / `tasks.md` directly for
    behavior-preserving refinements; route every acceptance/behavior-changing delta through the
    **Spec Drift Guard** (`drift.md` + recorded decision + `/rite-plan repair`). Append
-   `decisions.md` (one ADR per material call) and `assumptions.md`. Update `state.md`:
+   `decisions.md` (one ADR per material call) and `assumptions.md`. Re-run the gate after
+   every fold-back so a task edit cannot invalidate the earlier pass:
+   ```bash
+   devrites-engine analyze; echo "final analyze rc=$?"
+   ```
+   Any non-zero result blocks the handoff. Then update `state.md`:
    `Phase: vet`, `Next step: /rite-build`; on a blocking pause write the `Awaiting human` block +
    `Status: awaiting_human` before stopping.
 6. **Adversarial verification loop.** Apply the light/full branching contract in

package/pack/generated/claude/skills/rite-define/SKILL.md

@@ -119,6 +119,12 @@ Pull these via `Read` when shaping the plan:
    as a blocking gate at `/rite-vet`; no file → none declared → nothing to check.)
 6. **Write** `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md`; update
    `state.md` (phase: plan → next `/rite-vet`).
+6a. **Cross-artifact gate — now that `tasks.md` exists.** Run the deterministic
+   spec↔tasks coverage/consistency check; any non-zero result blocks plan readiness:
+   ```bash
+   S="$(cat .devrites/ACTIVE 2>/dev/null)"
+   devrites-engine analyze "$S"
+   ```
 7. **Readiness gate** (bottom of plan-template): every acceptance criterion covered by a
    slice, dependency order acyclic + risk-first, no unjustified deviation, rollback for
    every destructive/migration step. **Stop and confirm** before code. Render the review-before-code

package/pack/generated/claude/skills/rite-spec/SKILL.md

@@ -185,6 +185,8 @@ stay flat `AC-###` bullets; the grammar is opt-in by rigor, never forced.
    devrites-engine spec-skeleton ".devrites/work/<slug>"
    devrites-engine spec-validate ".devrites/work/<slug>" --against .devrites/specs
    ```
+   **Do not run `devrites-engine analyze` in this phase:** `tasks.md` deliberately does not
+   exist yet. `/rite-define` owns the first analyze pass after it writes the slices.
    Treat edge/prohibition findings as blocking just like grammar findings. When it passes, write `Spec gate: passed <iso>` to `state.md`.
 6a. **Review-before-code digest.** Before handing off to planning, render the cheap human review:
    `Intent` (one sentence), `Done means` (top acceptance/scenario IDs), `Scope/risk` (what is in/out

package/pack/generated/claude/skills/rite-vet/SKILL.md

@@ -140,7 +140,12 @@ Audit for a plan resting on unstated beliefs).
    (`/rite-build` and `/rite-prove` read it). Harden `plan.md` / `tasks.md` directly for
    behavior-preserving refinements; route every acceptance/behavior-changing delta through the
    **Spec Drift Guard** (`drift.md` + recorded decision + `/rite-plan repair`). Append
-   `decisions.md` (one ADR per material call) and `assumptions.md`. Update `state.md`:
+   `decisions.md` (one ADR per material call) and `assumptions.md`. Re-run the gate after
+   every fold-back so a task edit cannot invalidate the earlier pass:
+   ```bash
+   devrites-engine analyze; echo "final analyze rc=$?"
+   ```
+   Any non-zero result blocks the handoff. Then update `state.md`:
    `Phase: vet`, `Next step: /rite-build`; on a blocking pause write the `Awaiting human` block +
    `Status: awaiting_human` before stopping.
 6. **Adversarial verification loop.** Apply the light/full branching contract in

package/pack/generated/codex/skills/rite-define/SKILL.md

@@ -131,6 +131,12 @@ Pull these via `Read` when shaping the plan:
    as a blocking gate at `$rite-vet`; no file → none declared → nothing to check.)
 6. **Write** `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md`; update
    `state.md` (phase: plan → next `$rite-vet`).
+6a. **Cross-artifact gate — now that `tasks.md` exists.** Run the deterministic
+   spec↔tasks coverage/consistency check; any non-zero result blocks plan readiness:
+   ```bash
+   S="$(cat .devrites/ACTIVE 2>/dev/null)"
+   devrites-engine analyze "$S"
+   ```
 7. **Readiness gate** (bottom of plan-template): every acceptance criterion covered by a
    slice, dependency order acyclic + risk-first, no unjustified deviation, rollback for
    every destructive/migration step. **Stop and confirm** before code. Render the review-before-code

package/pack/generated/codex/skills/rite-spec/SKILL.md

@@ -197,6 +197,8 @@ stay flat `AC-###` bullets; the grammar is opt-in by rigor, never forced.
    devrites-engine spec-skeleton ".devrites/work/<slug>"
    devrites-engine spec-validate ".devrites/work/<slug>" --against .devrites/specs
    ```
+   **Do not run `devrites-engine analyze` in this phase:** `tasks.md` deliberately does not
+   exist yet. `$rite-define` owns the first analyze pass after it writes the slices.
    Treat edge/prohibition findings as blocking just like grammar findings. When it passes, write `Spec gate: passed <iso>` to `state.md`.
 6a. **Review-before-code digest.** Before handing off to planning, render the cheap human review:
    `Intent` (one sentence), `Done means` (top acceptance/scenario IDs), `Scope/risk` (what is in/out

package/pack/generated/codex/skills/rite-vet/SKILL.md

@@ -152,7 +152,12 @@ Audit for a plan resting on unstated beliefs).
    (`$rite-build` and `$rite-prove` read it). Harden `plan.md` / `tasks.md` directly for
    behavior-preserving refinements; route every acceptance/behavior-changing delta through the
    **Spec Drift Guard** (`drift.md` + recorded decision + `$rite-plan repair`). Append
-   `decisions.md` (one ADR per material call) and `assumptions.md`. Update `state.md`:
+   `decisions.md` (one ADR per material call) and `assumptions.md`. Re-run the gate after
+   every fold-back so a task edit cannot invalidate the earlier pass:
+   ```bash
+   devrites-engine analyze; echo "final analyze rc=$?"
+   ```
+   Any non-zero result blocks the handoff. Then update `state.md`:
    `Phase: vet`, `Next step: $rite-build`; on a blocking pause write the `Awaiting human` block +
    `Status: awaiting_human` before stopping.
 6. **Adversarial verification loop.** Apply the light/full branching contract in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "3.0.0",
+  "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",