devrites 4.4.0 → 4.4.2

package/engine/internal/state/taskgraph.go

@@ -0,0 +1,213 @@
+package state
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// TaskSlice is one SLICE-### block parsed from tasks.md.
+type TaskSlice struct {
+	ID           string
+	Dependencies []string
+}
+
+// TaskGraphResult is the deterministic outcome of parsing a tasks.md slice graph.
+type TaskGraphResult struct {
+	Slices   []TaskSlice
+	Cycle    []string // empty when acyclic
+	Unknown  []string // dependency ids with no defining slice
+	Problems []string // human-readable blockers
+}
+
+var (
+	sliceHeaderRE  = regexp.MustCompile(`(?m)^##\s+(SLICE-\d+)\b`)
+	dependenciesRE = regexp.MustCompile(`(?m)^Dependencies:\s*(.+)\s*$`)
+	dependsOnRE    = regexp.MustCompile(`(?m)^depends_on:\s*(.+)\s*$`)
+	sliceIDValidRE = regexp.MustCompile(`^SLICE-\d+$`)
+)
+
+// ParseTaskGraph reads tasks.md content and validates the slice dependency DAG.
+func ParseTaskGraph(tasksMarkdown []byte) TaskGraphResult {
+	text := string(tasksMarkdown)
+	result := TaskGraphResult{}
+	if strings.TrimSpace(text) == "" {
+		result.Problems = append(result.Problems, "tasks.md is empty")
+		return result
+	}
+
+	headers := sliceHeaderRE.FindAllStringSubmatchIndex(text, -1)
+	if len(headers) == 0 {
+		result.Problems = append(result.Problems, "no SLICE-### sections found")
+		return result
+	}
+
+	known := make(map[string]bool, len(headers))
+	firstIndex := make(map[string]int, len(headers))
+	for i, match := range headers {
+		id := text[match[2]:match[3]]
+		if _, seen := firstIndex[id]; seen {
+			result.Problems = append(result.Problems, fmt.Sprintf("duplicate slice id %s", id))
+			continue
+		}
+		firstIndex[id] = i
+		known[id] = true
+	}
+
+	for i, match := range headers {
+		id := text[match[2]:match[3]]
+		if firstIndex[id] != i {
+			continue
+		}
+		start := match[1]
+		end := len(text)
+		if i+1 < len(headers) {
+			end = headers[i+1][0]
+		}
+		block := text[start:end]
+		deps, problems := parseSliceGraph(id, block)
+		result.Problems = append(result.Problems, problems...)
+		result.Slices = append(result.Slices, TaskSlice{ID: id, Dependencies: deps})
+		for _, dep := range deps {
+			if !known[dep] {
+				result.Unknown = append(result.Unknown, dep)
+				result.Problems = append(result.Problems, fmt.Sprintf("%s depends on unknown slice %s", id, dep))
+			}
+		}
+	}
+
+	if cycle := findTaskCycle(result.Slices); len(cycle) > 0 {
+		result.Cycle = cycle
+		result.Problems = append(result.Problems, "dependency cycle: "+strings.Join(cycle, " -> "))
+	}
+	return result
+}
+
+func parseSliceGraph(id, block string) ([]string, []string) {
+	var problems []string
+	depsLine := firstLineValue(dependenciesRE, block)
+	mirrorLine := firstLineValue(dependsOnRE, block)
+	deps, malformed := parseIDList(depsLine)
+	for _, token := range malformed {
+		problems = append(problems, fmt.Sprintf("%s has malformed dependency %q", id, token))
+	}
+	mirror, mirrorMalformed := parseIDList(mirrorLine)
+	for _, token := range mirrorMalformed {
+		problems = append(problems, fmt.Sprintf("%s has malformed depends_on %q", id, token))
+	}
+	if depsLine != "" && mirrorLine != "" && !sameIDSet(deps, mirror) {
+		problems = append(problems, fmt.Sprintf("%s Dependencies and depends_on sets differ", id))
+	}
+	if depsLine == "" && mirrorLine == "" {
+		problems = append(problems, fmt.Sprintf("%s is missing Dependencies", id))
+	}
+	if depsLine == "" {
+		deps = mirror
+	}
+	return deps, problems
+}
+
+func firstLineValue(re *regexp.Regexp, block string) string {
+	match := re.FindStringSubmatch(block)
+	if len(match) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(match[1])
+}
+
+func parseIDList(raw string) ([]string, []string) {
+	raw = strings.TrimSpace(raw)
+	raw = strings.Trim(raw, "[]")
+	raw = strings.TrimSpace(raw)
+	if raw == "" || strings.EqualFold(raw, "none") {
+		return nil, nil
+	}
+	parts := strings.FieldsFunc(raw, func(r rune) bool {
+		return r == ',' || r == ';' || unicode.IsSpace(r)
+	})
+	var ids []string
+	var malformed []string
+	seen := make(map[string]bool)
+	for _, part := range parts {
+		id := strings.Trim(strings.TrimSpace(part), "`'\"(){}")
+		if id == "" {
+			continue
+		}
+		if !sliceIDValidRE.MatchString(id) {
+			malformed = append(malformed, id)
+			continue
+		}
+		if seen[id] {
+			continue
+		}
+		seen[id] = true
+		ids = append(ids, id)
+	}
+	return ids, malformed
+}
+
+func sameIDSet(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	seen := make(map[string]bool, len(a))
+	for _, id := range a {
+		seen[id] = true
+	}
+	for _, id := range b {
+		if !seen[id] {
+			return false
+		}
+	}
+	return true
+}
+
+func findTaskCycle(slices []TaskSlice) []string {
+	graph := make(map[string][]string, len(slices))
+	for _, slice := range slices {
+		graph[slice.ID] = append([]string(nil), slice.Dependencies...)
+	}
+	visited := make(map[string]uint8, len(slices))
+	stack := make([]string, 0, len(slices))
+	var cycle []string
+
+	var visit func(id string) bool
+	visit = func(id string) bool {
+		switch visited[id] {
+		case 2:
+			return false
+		case 1:
+			for i := len(stack) - 1; i >= 0; i-- {
+				cycle = append(cycle, stack[i])
+				if stack[i] == id {
+					break
+				}
+			}
+			for i, j := 0, len(cycle)-1; i < j; i, j = i+1, j-1 {
+				cycle[i], cycle[j] = cycle[j], cycle[i]
+			}
+			return true
+		}
+		visited[id] = 1
+		stack = append(stack, id)
+		for _, dep := range graph[id] {
+			if visit(dep) {
+				return true
+			}
+		}
+		stack = stack[:len(stack)-1]
+		visited[id] = 2
+		return false
+	}
+
+	for _, slice := range slices {
+		if visited[slice.ID] == 0 {
+			cycle = nil
+			if visit(slice.ID) {
+				return cycle
+			}
+		}
+	}
+	return nil
+}

package/engine/internal/testutil/testutil.go

@@ -7,6 +7,9 @@ import (
 	"testing"
 )
 
+// CanonicalTasksMarkdown is a minimal valid slice graph for gate fixtures.
+const CanonicalTasksMarkdown = "# Tasks\n\n## SLICE-001 Ready\nDependencies: none\n"
+
 // CopyTree recursively copies the directory tree at src into dst, creating dst
 // and any parents. It is used to give each test an isolated, writable copy of a
 // read-only fixture.

package/engine/main.go

@@ -22,9 +22,9 @@ Usage:
   devrites-engine update [flags]           Update an existing DevRites install in place
   devrites-engine uninstall [flags]        Remove a DevRites install, preserving runtime state
   devrites-engine check candidate <slug>   Validate and hash the closed project candidate
-  devrites-engine check readiness <slug>   Check required files and the stable Build-input binding
+  devrites-engine check readiness <slug>   Check required files, tasks.md graph, and Build-input binding
   devrites-engine check readiness --emit-binding <slug>  Emit the stable Build-input binding for Vet
-  devrites-engine check seal <slug>        Recheck the Build-input binding, final files, and evidence freshness
+  devrites-engine check seal <slug>        Recheck files, tasks.md graph, Build-input binding, and evidence freshness
   devrites-engine check path-disjoint [--root <dir>] [<json-file>|-]
                                          Verify slice path sets are pairwise disjoint
   devrites-engine check task-graph <slug>  Validate tasks.md slice dependency graph

package/engine/tests/adr_0027_readiness_binding_test.go

@@ -23,7 +23,7 @@ func TestADR0027ReadinessBindingBlocksPlanDriftWithRestoredMtime(t *testing.T) {
 		"decision-coverage.md": "# Decision coverage\n\nCLEAR\n",
 		"architecture.md":      "# Architecture\n\nUse the deterministic gate.\n",
 		"plan.md":              "# Plan\n\nBuild slice A.\n",
-		"tasks.md":             "# Tasks\n\n- [ ] Build slice A.\n",
+		"tasks.md":             testutil.CanonicalTasksMarkdown,
 		"traceability.md":      "# Traceability\n\nAC-001 -> slice A.\n",
 		"eng-review.md":        "# Engineering review\n\nREADY\n",
 		"test-plan.md":         "# Test plan\n\nRun focused Go tests.\n",

package/engine/tests/gate_test.go

@@ -70,7 +70,7 @@ func TestReadinessEmitBindingPassesExactCLIContract(t *testing.T) {
 	writeCompleteGateCLIWorkspace(t, root, slug, state.PhaseBuild, state.PhaseBuild, "none\n")
 
 	out, errOut, code := runDevrites(t, root, "check", "readiness", "--emit-binding", slug)
-	const wantOut = "Readiness inputs SHA-256: 71c2d192ea09bca1d2c8806cb197e7fa4d1d08e0b331cf25b2e1bcb7ecac34e4\n"
+	const wantOut = "Readiness inputs SHA-256: f72109687057f33d5d7f05e5436a4dcc88ccf87367d0933afd9fdcf1a023f5c0\n"
 	if code != 0 || out != wantOut || errOut != "" {
 		t.Fatalf("code=%d stdout=%q stderr=%q, want code=0 stdout=%q stderr empty", code, out, errOut, wantOut)
 	}
@@ -565,6 +565,8 @@ func writeCompleteGateCLIWorkspace(t *testing.T, root, slug string, current, req
 		case "questions.md":
 			questionsRequired = true
 			content = questions
+		case "tasks.md":
+			content = testutil.CanonicalTasksMarkdown
 		}
 		testutil.WriteFile(t, filepath.Join(root, "work", slug, name), content)
 	}
@@ -590,7 +592,7 @@ func newFinalSealRepo(t *testing.T) (string, string) {
 		"decision-coverage.md": "# Decision coverage\n\nCLEAR\n",
 		"architecture.md":      "# Architecture\n\nUse existing gates.\n",
 		"plan.md":              "# Plan\n\nCompose the final checks.\n",
-		"tasks.md":             "# Tasks\n\n- [x] Build final seal.\n",
+		"tasks.md":             testutil.CanonicalTasksMarkdown,
 		"traceability.md":      "# Traceability\n\nAC-001 -> final seal.\n",
 		"eng-review.md":        "# Engineering review\n\nPASS\n",
 		"test-plan.md":         "# Test plan\n\nRun focused Go tests.\n",

package/pack/.claude/skills/rite-plan/reference/dependency-graph.md

@@ -37,7 +37,10 @@ define the contract first (so both sides can proceed) and trigger `devrites-doub
 before standing the interface.
 
 After editing `tasks.md`, run `devrites-engine check task-graph <slug>` before Vet.
-Cycles or unknown dependencies block readiness.
+`check readiness` and `check seal` also reject cycles, unknown dependencies,
+malformed tokens, duplicate slice IDs, a missing `Dependencies`/`depends_on`
+line, and a `depends_on` set that disagrees with `Dependencies`. Cycles or
+unknown dependencies block readiness.
 
 For monorepos/multiple repositories, annotate the proven root and deployable on each node.
 For data/integration changes, include recovery ordering: expand before new writers,

package/pack/generated/claude/skills/rite-plan/reference/dependency-graph.md

@@ -37,7 +37,10 @@ define the contract first (so both sides can proceed) and trigger `devrites-doub
 before standing the interface.
 
 After editing `tasks.md`, run `devrites-engine check task-graph <slug>` before Vet.
-Cycles or unknown dependencies block readiness.
+`check readiness` and `check seal` also reject cycles, unknown dependencies,
+malformed tokens, duplicate slice IDs, a missing `Dependencies`/`depends_on`
+line, and a `depends_on` set that disagrees with `Dependencies`. Cycles or
+unknown dependencies block readiness.
 
 For monorepos/multiple repositories, annotate the proven root and deployable on each node.
 For data/integration changes, include recovery ordering: expand before new writers,

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

@@ -19,12 +19,11 @@ When they ask how phases connect, load [`reference/menu.md`](reference/menu.md).
 
 ## Dispatch
 
-If `$ARGUMENTS` starts with a verb in this table, **load the matching skill and execute its workflow** with the remainder of `$ARGUMENTS` as that skill's argument. Try post-install path first, fall back to pre-install:
+If `$ARGUMENTS` starts with a verb in this table, **load the matching skill and execute its workflow** with the remainder of `$ARGUMENTS` as that skill's argument. Resolve the installed skill path:
 
 ```bash
 V=<verb>; ARGS="<remaining args>"
 F=.agents/skills/rite-$V/SKILL.md
-[ -f "$F" ] || F=.agents/skills/rite-$V/SKILL.md
 # Then Read "$F" and follow its workflow with $ARGS as that skill's $ARGUMENTS.
 ```
 

package/pack/generated/codex/skills/rite-plan/reference/dependency-graph.md

@@ -37,7 +37,10 @@ define the contract first (so both sides can proceed) and trigger `devrites-doub
 before standing the interface.
 
 After editing `tasks.md`, run `devrites-engine check task-graph <slug>` before Vet.
-Cycles or unknown dependencies block readiness.
+`check readiness` and `check seal` also reject cycles, unknown dependencies,
+malformed tokens, duplicate slice IDs, a missing `Dependencies`/`depends_on`
+line, and a `depends_on` set that disagrees with `Dependencies`. Cycles or
+unknown dependencies block readiness.
 
 For monorepos/multiple repositories, annotate the proven root and deployable on each node.
 For data/integration changes, include recovery ordering: expand before new writers,

package/package.json

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

package/scripts/codex-generate.sh

@@ -8,6 +8,8 @@ gen_codex_markdown_file() {
   local _src="$1" _out="$2"
   mkdir -p "$(dirname "$_out")"
   sed -E \
+    -e 's#Try post-install path first, fall back to pre-install:#Resolve the installed skill path:#g' \
+    -e '/^\[ -f "\$F" \] \|\| F=[^ ].*SKILL\.md$/d' \
     -e 's#(pack/)?\.claude/agents/devrites-\{security-auditor,performance-reviewer,simplifier-reviewer\}\.md#.codex/agents/devrites-security-auditor.toml`, `.codex/agents/devrites-performance-reviewer.toml`, or `.codex/agents/devrites-simplifier-reviewer.toml#g' \
     -e 's#(\.\./)+agents/devrites-\{security-auditor,performance-reviewer,simplifier-reviewer\}\.md#.codex/agents/devrites-security-auditor.toml`, `.codex/agents/devrites-performance-reviewer.toml`, or `.codex/agents/devrites-simplifier-reviewer.toml#g' \
     -e 's#pack/\.claude/skills/devrites-lib/scripts/#.agents/skills/devrites-lib/scripts/#g' \