devrites 4.2.0 → 4.3.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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`.
 
+## [4.3.0](https://github.com/ViktorsBaikers/DevRites/compare/v4.2.0...v4.3.0) (2026-08-25)
+
+### Added
+
+* **devrites:** add skill-trust, task-graph, and observe commands ([#38](https://github.com/ViktorsBaikers/DevRites/issues/38)) ([2562355](https://github.com/ViktorsBaikers/DevRites/commit/2562355a970726fb95e57e2f328961ca136c9f81))
+* **rite-build:** opt-in parallel worktree slices (N≤3) ([#37](https://github.com/ViktorsBaikers/DevRites/issues/37)) ([fe71d67](https://github.com/ViktorsBaikers/DevRites/commit/fe71d672408559af030e95f700b18ead798f18fc))
+
 ## [4.2.0](https://github.com/ViktorsBaikers/DevRites/compare/v4.1.0...v4.2.0) (2026-08-23)
 
 ### Added

package/README.md

@@ -28,7 +28,7 @@ project-conventional push, tag, or PR action, and archive the workspace.
 Unattended runs may create local WIP checkpoint commits along the way, but they
 remain local unless Ship's disclosed plan includes an approved remote action.
 
-**Status:** [`v4.2.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v4.2.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v4.3.0`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v4.3.0): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/docs/engine/commands.md

@@ -15,6 +15,10 @@ workflow strategy.
 | `check readiness <slug>` | Check target-Phase files, open human gates from Clarify onward, and the current stable Build-input binding when applicable. |
 | `check readiness --emit-binding <slug>` | Render the exact stable Build-input binding for Vet to record after review. |
 | `check seal <slug>` | Check files required by target Phase `seal`, open human gates, the stable Build-input binding, and exact candidate bindings. |
+| `check path-disjoint [--root <dir>] [<json-file>|-]` | Verify slice path sets are pairwise disjoint. |
+| `check task-graph <slug>` | Validate `tasks.md` slice dependency graph for cycles and unknown dependencies. |
+| `check skill-trust <path>` | Scan one skill/agent Markdown file for structural trust violations. |
+| `observe summary <slug>` | Emit sanitized JSON workspace summary from one retained observation. |
 | `state resolve <qid> "<answer>"` | Resolve an open question and update `questions.md` plus `state.md` atomically. |
 | `state close <slug>` | Archive a shipped workspace and clear matching `ACTIVE`. |
 | `secret-scan [--staged] [--stdin] [slug]` | Scan exact staged blobs, stdin, or touched regular files for credential material. |

package/docs/orchestration.md

@@ -126,9 +126,12 @@ base before native transfer, then re-proves the reconciled candidate. Missing tr
 conflict, extra paths, moved base, or cleanup failure stops with worktree evidence
 preserved. No ad hoc copy/cherry-pick/merge occurs from the read-only root.
 
-Isolation does not authorize throughput. At most one writer runs across all linked
-worktrees for the workspace; parallel writers remain forbidden until serial transfer,
-conflict, proof, and review measurements justify a separate design.
+Isolation does not authorize same-worktree throughput. Parallel writers are allowed
+**only** under `/rite-build --parallel N` when path-disjoint eligibility, abort-batch,
+and a control `parallel-lease.md` apply (see
+[`parallel-batch.md`](../pack/.claude/skills/rite-build/reference/parallel-batch.md)).
+Same-worktree multi-writer and root-emulated worktrees remain forbidden; default
+`/rite-build` stays one writer across linked worktrees.
 
 ## Engine boundary
 

package/engine/internal/lib/cli_observe.go

@@ -0,0 +1,66 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+)
+
+// RunTaskGraphCheck validates tasks.md for one slug.
+func RunTaskGraphCheck(root, slug string, stdout, stderr io.Writer) int {
+	graph, err := CheckTaskGraph(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "task-graph: %v\n", err)
+		return 2
+	}
+	if len(graph.Problems) > 0 {
+		for _, problem := range graph.Problems {
+			fmt.Fprintf(stdout, "task-graph: BLOCKED: %s\n", problem)
+		}
+		return 3
+	}
+	fmt.Fprintf(stdout, "task-graph: ok (%d slices)\n", len(graph.Slices))
+	return 0
+}
+
+// RunSkillTrustCheck scans one Markdown path.
+func RunSkillTrustCheck(path string, stdout, stderr io.Writer) int {
+	result, err := ScanSkillTrust(path)
+	if err != nil {
+		fmt.Fprintf(stderr, "skill-trust: %v\n", err)
+		return 2
+	}
+	fmt.Fprint(stdout, FormatSkillTrust(result))
+	if SkillTrustBlocks(result.Findings) {
+		return 3
+	}
+	return 0
+}
+
+// RunObserveSummary emits JSON for one slug.
+func RunObserveSummary(root, slug string, stdout, stderr io.Writer) int {
+	if err := WriteObserveSummaryJSON(root, slug, stdout); err != nil {
+		fmt.Fprintf(stderr, "observe: %v\n", err)
+		return 2
+	}
+	return 0
+}
+
+// ActiveSlug resolves slug from args or ACTIVE pointer.
+func ActiveSlug(root string, args []string) (string, int, error) {
+	if len(args) == 1 {
+		return args[0], 0, nil
+	}
+	if len(args) != 0 {
+		return "", 2, fmt.Errorf("expected one slug argument")
+	}
+	slug, err := devritespaths.ActiveSlug(root)
+	if err != nil {
+		return "", 2, err
+	}
+	if slug == "" {
+		return "", 2, fmt.Errorf("no slug and ACTIVE is empty")
+	}
+	return slug, 0, nil
+}

package/engine/internal/lib/observe_summary.go

@@ -0,0 +1,79 @@
+package lib
+
+import (
+	"encoding/json"
+	"io"
+
+	"github.com/devrites/devrites/internal/state"
+)
+
+// ObserveSummary is a sanitized, machine-readable workspace snapshot.
+type ObserveSummary struct {
+	Slug              string   `json:"slug"`
+	Phase             string   `json:"phase,omitempty"`
+	Status            string   `json:"status,omitempty"`
+	NextAction        string   `json:"next_action,omitempty"`
+	MissingSections   []string `json:"missing_sections,omitempty"`
+	MissingFiles      []string `json:"missing_files,omitempty"`
+	PrinciplesPresent bool     `json:"principles_present"`
+	TaskGraph         *struct {
+		SliceCount int      `json:"slice_count"`
+		Cycle      []string `json:"cycle,omitempty"`
+		Unknown    []string `json:"unknown_dependencies,omitempty"`
+		OK         bool     `json:"ok"`
+	} `json:"task_graph,omitempty"`
+}
+
+// ObserveSummaryFor builds a summary for one feature slug.
+func ObserveSummaryFor(root, slug string) (ObserveSummary, error) {
+	report, err := state.Status(root, slug)
+	if err != nil {
+		return ObserveSummary{}, err
+	}
+	summary := ObserveSummary{
+		Slug:              report.Slug,
+		Phase:             string(report.Phase),
+		Status:            report.Status,
+		NextAction:        report.NextAction,
+		PrinciplesPresent: report.PrinciplesPresent,
+		MissingFiles:      append([]string(nil), report.MissingFiles...),
+		MissingSections:   missingSectionNames(report.Missing),
+	}
+
+	if graph, graphErr := CheckTaskGraph(root, slug); graphErr == nil && len(graph.Slices) > 0 {
+		summary.TaskGraph = &struct {
+			SliceCount int      `json:"slice_count"`
+			Cycle      []string `json:"cycle,omitempty"`
+			Unknown    []string `json:"unknown_dependencies,omitempty"`
+			OK         bool     `json:"ok"`
+		}{
+			SliceCount: len(graph.Slices),
+			Cycle:      graph.Cycle,
+			Unknown:    graph.Unknown,
+			OK:         len(graph.Problems) == 0,
+		}
+	}
+	return summary, nil
+}
+
+func missingSectionNames(sections []state.Section) []string {
+	if len(sections) == 0 {
+		return nil
+	}
+	out := make([]string, len(sections))
+	for i, section := range sections {
+		out[i] = string(section)
+	}
+	return out
+}
+
+// WriteObserveSummaryJSON prints one JSON object to stdout.
+func WriteObserveSummaryJSON(root, slug string, stdout io.Writer) error {
+	summary, err := ObserveSummaryFor(root, slug)
+	if err != nil {
+		return err
+	}
+	enc := json.NewEncoder(stdout)
+	enc.SetIndent("", "  ")
+	return enc.Encode(summary)
+}

package/engine/internal/lib/skilltrust.go

@@ -0,0 +1,196 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// SkillTrustFinding is one deterministic trust scan result.
+type SkillTrustFinding struct {
+	Severity string // HIGH or MEDIUM
+	Rule     string
+	Line     int
+	Detail   string
+}
+
+// SkillTrustResult summarizes a skill-trust scan.
+type SkillTrustResult struct {
+	Path     string
+	Findings []SkillTrustFinding
+}
+
+var skillTrustRules = []struct {
+	severity string
+	rule     string
+	re       *regexp.Regexp
+	detail   string
+}{
+	{
+		severity: "HIGH",
+		rule:     "prompt_injection_disregard",
+		re:       regexp.MustCompile(`(?i)\b(disregard|ignore)\b.{0,40}\b(prior|previous|above|system|instruction|rule|constraint|safety)\b`),
+		detail:   "instruction attempts to override prior constraints",
+	},
+	{
+		severity: "HIGH",
+		rule:     "credential_exfil_curl_env",
+		re:       regexp.MustCompile(`(?i)\bcurl\b.{0,120}\$(?:ENV|HOME|[A-Z_][A-Z0-9_]*)`),
+		detail:   "curl command references environment variables (possible exfiltration)",
+	},
+	{
+		severity: "HIGH",
+		rule:     "sensitive_path_reference",
+		re:       regexp.MustCompile(`(?i)(~/.ssh|~/.aws|/etc/passwd|id_rsa|\.pem\b|api[_-]?key\s*[:=])`),
+		detail:   "references sensitive filesystem or credential material",
+	},
+	{
+		severity: "MEDIUM",
+		rule:     "hidden_remote_fetch",
+		re:       regexp.MustCompile(`(?i)\b(curl|wget|fetch)\b.{0,80}\b(http|https)://`),
+		detail:   "network fetch instruction in skill prose",
+	},
+}
+
+// ScanSkillTrust reads one Markdown skill/agent file and returns structural trust findings.
+func ScanSkillTrust(path string) (SkillTrustResult, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return SkillTrustResult{}, err
+	}
+	if info.IsDir() {
+		return SkillTrustResult{}, fmt.Errorf("skill-trust: %q is a directory", path)
+	}
+	if info.Size() > 1<<20 {
+		return SkillTrustResult{}, fmt.Errorf("skill-trust: %q exceeds 1 MiB limit", path)
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		return SkillTrustResult{}, err
+	}
+	defer file.Close()
+	raw, err := io.ReadAll(io.LimitReader(file, 1<<20+1))
+	if err != nil {
+		return SkillTrustResult{}, err
+	}
+	if len(raw) > 1<<20 {
+		return SkillTrustResult{}, fmt.Errorf("skill-trust: %q exceeds 1 MiB limit", path)
+	}
+	return SkillTrustResult{Path: filepath.Clean(path), Findings: analyzeSkillTrustContent(string(raw))}, nil
+}
+
+func analyzeSkillTrustContent(text string) []SkillTrustFinding {
+	var findings []SkillTrustFinding
+	lines := strings.Split(text, "\n")
+	for i, line := range lines {
+		lineNum := i + 1
+		for _, r := range line {
+			if isSuspiciousUnicode(r) {
+				findings = append(findings, SkillTrustFinding{
+					Severity: "HIGH",
+					Rule:     "suspicious_unicode",
+					Line:     lineNum,
+					Detail:   fmt.Sprintf("suspicious Unicode U+%04X", r),
+				})
+				break
+			}
+		}
+		for _, rule := range skillTrustRules {
+			if rule.re.MatchString(line) {
+				findings = append(findings, SkillTrustFinding{
+					Severity: rule.severity,
+					Rule:     rule.rule,
+					Line:     lineNum,
+					Detail:   rule.detail,
+				})
+			}
+		}
+	}
+	findings = appendMissingNameFinding(text, findings)
+	return dedupeFindings(findings)
+}
+
+func looksLikeSkillFile(text string) bool {
+	lower := strings.ToLower(text)
+	return strings.Contains(lower, "user-invocable:") || strings.Contains(lower, "# /rite-") || strings.Contains(lower, "disable-model-invocation:")
+}
+
+func appendMissingNameFinding(text string, findings []SkillTrustFinding) []SkillTrustFinding {
+	if strings.Contains(text, "---") && !strings.Contains(text, "\nname:") && looksLikeSkillFile(text) {
+		findings = append(findings, SkillTrustFinding{
+			Severity: "MEDIUM",
+			Rule:     "missing_name_frontmatter",
+			Line:     1,
+			Detail:   "skill-like Markdown lacks name frontmatter",
+		})
+	}
+	return findings
+}
+
+func isSuspiciousUnicode(r rune) bool {
+	switch r {
+	case '\u200B', '\u200C', '\u200D', '\uFEFF', '\u2060':
+		return true
+	}
+	if r >= '\u202A' && r <= '\u202E' {
+		return true
+	}
+	if r >= '\u2066' && r <= '\u2069' {
+		return true
+	}
+	return false
+}
+
+func dedupeFindings(in []SkillTrustFinding) []SkillTrustFinding {
+	if len(in) == 0 {
+		return nil
+	}
+	seen := make(map[string]bool, len(in))
+	out := make([]SkillTrustFinding, 0, len(in))
+	for _, finding := range in {
+		key := finding.Rule + "|" + fmt.Sprint(finding.Line) + "|" + finding.Detail
+		if seen[key] {
+			continue
+		}
+		seen[key] = true
+		out = append(out, finding)
+	}
+	return out
+}
+
+// SkillTrustBlocks returns true when findings contain any HIGH severity item.
+func SkillTrustBlocks(findings []SkillTrustFinding) bool {
+	for _, finding := range findings {
+		if finding.Severity == "HIGH" {
+			return true
+		}
+	}
+	return false
+}
+
+// FormatSkillTrust writes a human-readable report.
+func FormatSkillTrust(result SkillTrustResult) string {
+	if len(result.Findings) == 0 {
+		return fmt.Sprintf("skill-trust: PASS (%s)\n", result.Path)
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "skill-trust: FINDINGS (%s)\n", result.Path)
+	for _, finding := range result.Findings {
+		fmt.Fprintf(&b, "%s %s line=%d %s\n", finding.Severity, finding.Rule, finding.Line, finding.Detail)
+	}
+	return b.String()
+}
+
+// ContainsOnlyASCII returns false when non-ASCII control or bidi characters appear.
+func ContainsOnlyASCII(text string) bool {
+	for _, r := range text {
+		if r > unicode.MaxASCII && isSuspiciousUnicode(r) {
+			return false
+		}
+	}
+	return true
+}

package/engine/internal/lib/taskgraph.go

@@ -0,0 +1,162 @@
+package lib
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// 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*$`)
+	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)
+	for _, match := range headers {
+		id := text[match[2]:match[3]]
+		known[id] = true
+	}
+
+	for i, match := range headers {
+		id := text[match[2]:match[3]]
+		start := match[1]
+		end := len(text)
+		if i+1 < len(headers) {
+			end = headers[i+1][0]
+		}
+		block := text[start:end]
+		deps := parseSliceDependencies(block)
+		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 parseSliceDependencies(block string) []string {
+	match := dependenciesRE.FindStringSubmatch(block)
+	if len(match) < 2 {
+		return nil
+	}
+	raw := strings.TrimSpace(match[1])
+	if raw == "" || strings.EqualFold(raw, "none") {
+		return nil
+	}
+	parts := strings.FieldsFunc(raw, func(r rune) bool {
+		return r == ',' || r == ';'
+	})
+	var deps []string
+	seen := make(map[string]bool)
+	for _, part := range parts {
+		id := strings.TrimSpace(part)
+		if id == "" {
+			continue
+		}
+		if !sliceIDValidRE.MatchString(id) {
+			continue
+		}
+		if seen[id] {
+			continue
+		}
+		seen[id] = true
+		deps = append(deps, id)
+	}
+	return deps
+}
+
+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
+}
+
+// CheckTaskGraph validates tasks.md for a feature workspace slug.
+func CheckTaskGraph(root, slug string) (TaskGraphResult, error) {
+	raw, err := readWorkspaceArtifact(root, slug, "tasks.md")
+	if err != nil {
+		return TaskGraphResult{}, err
+	}
+	return ParseTaskGraph(raw), nil
+}