devrites 3.0.0 → 3.0.1

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.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.1`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.0.1) — 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/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/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/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/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/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/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.1",
   "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",