devrites 4.2.0 → 4.3.0

package/engine/internal/parallel/pathdisjoint.go

@@ -0,0 +1,129 @@
+// Package parallel implements deterministic parallel-worktree control ops:
+// path-disjoint checks, advisory leases, and git worktree create/integrate/cleanup.
+package parallel
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+var winAbsRE = regexp.MustCompile(`(?i)^[A-Za-z]:[/\\]`)
+
+// SlicePaths is one path-disjoint eligibility unit.
+type SlicePaths struct {
+	ID    string   `json:"id"`
+	Paths []string `json:"paths"`
+}
+
+// NormalizePath mirrors scripts/check-path-disjoint.py: slash-normalize, reject
+// empty/absolute/.. paths, and drop empty/"." segments.
+func NormalizePath(raw string) (string, error) {
+	path := strings.TrimSpace(strings.ReplaceAll(raw, `\`, "/"))
+	if path == "" {
+		return "", fmt.Errorf("empty path is not allowed")
+	}
+	if strings.HasPrefix(path, "/") || winAbsRE.MatchString(path) {
+		return "", fmt.Errorf("path must be project-relative, not absolute: %q", raw)
+	}
+	parts := make([]string, 0, strings.Count(path, "/")+1)
+	for part := range strings.SplitSeq(path, "/") {
+		if part == "" || part == "." {
+			continue
+		}
+		if part == ".." {
+			return "", fmt.Errorf("path must not contain '..': %q", raw)
+		}
+		parts = append(parts, part)
+	}
+	if len(parts) == 0 {
+		return "", fmt.Errorf("empty path is not allowed")
+	}
+	return strings.Join(parts, "/"), nil
+}
+
+func validateSlicePaths(paths []string, label, root string) ([]string, error) {
+	if paths == nil {
+		return nil, fmt.Errorf("%s: paths must be a list", label)
+	}
+	normalized := make([]string, 0, len(paths))
+	seen := make(map[string]struct{}, len(paths))
+	for _, raw := range paths {
+		path, err := NormalizePath(raw)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", label, err)
+		}
+		// Parallel eligibility must reject workspace control metadata so slices
+		// cannot claim control-tree / SSOT files (docs: ".devrites/**").
+		if path == ".devrites" || strings.HasPrefix(path, ".devrites/") {
+			return nil, fmt.Errorf("%s: path must not include .devrites: %q", label, path)
+		}
+		if _, ok := seen[path]; ok {
+			return nil, fmt.Errorf("%s: duplicate path %q", label, path)
+		}
+		seen[path] = struct{}{}
+		normalized = append(normalized, path)
+		if root != "" {
+			full := filepath.Join(root, filepath.FromSlash(path))
+			if info, err := os.Lstat(full); err == nil && info.Mode()&os.ModeSymlink != 0 {
+				return nil, fmt.Errorf("%s: symlink path is not allowed: %q", label, path)
+			}
+		}
+	}
+	return normalized, nil
+}
+
+// CheckPathDisjoint returns slice ids when every pair of path sets is disjoint.
+func CheckPathDisjoint(slices []SlicePaths, root string) ([]string, error) {
+	if len(slices) < 2 {
+		return nil, fmt.Errorf("need at least two slices to check path-disjoint eligibility")
+	}
+	owners := make(map[string][]string)
+	ids := make([]string, 0, len(slices))
+	for index, item := range slices {
+		label := fmt.Sprintf("slice %d", index)
+		if item.ID != "" {
+			label = fmt.Sprintf("slice %q", item.ID)
+			ids = append(ids, item.ID)
+		} else {
+			ids = append(ids, fmt.Sprintf("%d", index))
+		}
+		paths, err := validateSlicePaths(item.Paths, label, root)
+		if err != nil {
+			return nil, err
+		}
+		for _, path := range paths {
+			owners[path] = append(owners[path], label)
+		}
+	}
+	var overlaps []string
+	for path, labels := range owners {
+		if len(labels) > 1 {
+			overlaps = append(overlaps, fmt.Sprintf("%q shared by %s", path, strings.Join(labels, ", ")))
+		}
+	}
+	if len(overlaps) > 0 {
+		sort.Strings(overlaps)
+		return nil, fmt.Errorf("path sets overlap: %s", strings.Join(overlaps, "; "))
+	}
+	return ids, nil
+}
+
+// ParseSlicesJSON accepts {"slices":[...]} or a top-level slices array.
+func ParseSlicesJSON(data []byte) ([]SlicePaths, error) {
+	var asObject struct {
+		Slices []SlicePaths `json:"slices"`
+	}
+	if err := json.Unmarshal(data, &asObject); err == nil && asObject.Slices != nil {
+		return asObject.Slices, nil
+	}
+	var asList []SlicePaths
+	if err := json.Unmarshal(data, &asList); err == nil {
+		return asList, nil
+	}
+	return nil, fmt.Errorf(`input must be {"slices": [...]} or a top-level slices array`)
+}

package/engine/internal/parallel/pathdisjoint_test.go

@@ -0,0 +1,97 @@
+package parallel
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestNormalizePathRejectsDirty(t *testing.T) {
+	t.Parallel()
+	cases := []string{"", " ", "/", "/abs", `C:\windows`, `..`, "a/../b", "../x"}
+	for _, raw := range cases {
+		if _, err := NormalizePath(raw); err == nil {
+			t.Fatalf("NormalizePath(%q) should fail", raw)
+		}
+	}
+}
+
+func TestNormalizePathAcceptsRelative(t *testing.T) {
+	t.Parallel()
+	got, err := NormalizePath(`src\foo.go`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "src/foo.go" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestCheckPathDisjointOverlap(t *testing.T) {
+	t.Parallel()
+	_, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{"src/a.go"}},
+		{ID: "b", Paths: []string{"src/a.go"}},
+	}, "")
+	if err == nil || !strings.Contains(err.Error(), "overlap") {
+		t.Fatalf("expected overlap error, got %v", err)
+	}
+}
+
+func TestCheckPathDisjointOK(t *testing.T) {
+	t.Parallel()
+	ids, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{"src/a.go"}},
+		{ID: "b", Paths: []string{"src/b.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ids) != 2 {
+		t.Fatalf("ids=%v", ids)
+	}
+}
+
+func TestCheckPathDisjointRejectsDevritesPaths(t *testing.T) {
+	t.Parallel()
+	_, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{".devrites/work/state.md"}},
+		{ID: "b", Paths: []string{"src/b.go"}},
+	}, "")
+	if err == nil || !strings.Contains(err.Error(), ".devrites") {
+		t.Fatalf("expected .devrites rejection error, got %v", err)
+	}
+}
+
+func TestCheckPathDisjointSymlinkRoot(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	target := filepath.Join(dir, "real.go")
+	if err := os.WriteFile(target, []byte("x"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(dir, "link.go")
+	if err := os.Symlink(target, link); err != nil {
+		t.Skip("symlinks unavailable")
+	}
+	_, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{"link.go"}},
+		{ID: "b", Paths: []string{"other.go"}},
+	}, dir)
+	if err == nil || !strings.Contains(err.Error(), "symlink") {
+		t.Fatalf("expected symlink error, got %v", err)
+	}
+}
+
+func TestParseSlicesJSONShapes(t *testing.T) {
+	t.Parallel()
+	a, err := ParseSlicesJSON([]byte(`{"slices":[{"id":"a","paths":["x.go"]},{"id":"b","paths":["y.go"]}]}`))
+	if err != nil || len(a) != 2 {
+		t.Fatalf("object shape: %v %#v", err, a)
+	}
+	b, err := ParseSlicesJSON([]byte(`[{"id":"a","paths":["x.go"]},{"id":"b","paths":["y.go"]}]`))
+	if err != nil || len(b) != 2 {
+		t.Fatalf("array shape: %v %#v", err, b)
+	}
+}

package/engine/internal/state/status.go

@@ -7,14 +7,17 @@ import (
 
 // Report is the computed completeness status of a feature at its current phase.
 type Report struct {
-	Slug          string
-	Phase         Phase
-	Required      map[Section]bool
-	Missing       []Section // required-but-empty sections, in policy order
-	RequiredFiles map[string]bool
-	MissingFiles  []string // required-but-empty workspace files, in lifecycle order
-	present       map[Section]bool
-	diagnostics   []ArtifactDiagnostic
+	Slug              string
+	Phase             Phase
+	Status            string
+	NextAction        string
+	PrinciplesPresent bool
+	Required          map[Section]bool
+	Missing           []Section // required-but-empty sections, in policy order
+	RequiredFiles     map[string]bool
+	MissingFiles      []string // required-but-empty workspace files, in lifecycle order
+	present           map[Section]bool
+	diagnostics       []ArtifactDiagnostic
 }
 
 // Status computes phase-relative completeness from one retained workspace observation.
@@ -35,6 +38,24 @@ func statusWithCallback(root, slug string, callback observationCallback) (*Repor
 	return newObservationReport(observation, phase, policy), nil
 }
 
+func observationCursorFields(observation *WorkspaceObservation) (status, nextAction string, principlesPresent bool) {
+	if fact, ok := observation.Fact(".devrites/principles.md"); ok && fact.State() == ArtifactPresent {
+		principlesPresent = true
+	}
+	fact, ok := observation.Fact(LedgerFile)
+	if !ok || fact.State() != ArtifactPresent {
+		return "", "", principlesPresent
+	}
+	lines := strings.Split(string(fact.Bytes()), "\n")
+	if value, ok := CursorField(lines, CursorStatus); ok {
+		status = value
+	}
+	if value, ok := CursorField(lines, CursorNextAction); ok {
+		nextAction = value
+	}
+	return status, nextAction, principlesPresent
+}
+
 func newObservationReport(observation *WorkspaceObservation, phase Phase, policy PhasePolicy) *Report {
 	present := observationSectionPresence(observation)
 	required := requiredSections(policy)
@@ -44,15 +65,19 @@ func newObservationReport(observation *WorkspaceObservation, phase Phase, policy
 	for i, artifact := range missingArtifacts {
 		missingFiles[i] = string(artifact)
 	}
+	status, nextAction, principlesPresent := observationCursorFields(observation)
 	return &Report{
-		Slug:          observation.Slug(),
-		Phase:         phase,
-		Required:      required,
-		Missing:       missingObservationSections(present, policy.RequiredSections),
-		RequiredFiles: requiredFiles,
-		MissingFiles:  missingFiles,
-		present:       present,
-		diagnostics:   diagnostics,
+		Slug:              observation.Slug(),
+		Phase:             phase,
+		Status:            status,
+		NextAction:        nextAction,
+		PrinciplesPresent: principlesPresent,
+		Required:          required,
+		Missing:           missingObservationSections(present, policy.RequiredSections),
+		RequiredFiles:     requiredFiles,
+		MissingFiles:      missingFiles,
+		present:           present,
+		diagnostics:       diagnostics,
 	}
 }
 

package/engine/main.go

@@ -10,6 +10,7 @@ import (
 	"github.com/devrites/devrites/internal/gate"
 	"github.com/devrites/devrites/internal/install"
 	"github.com/devrites/devrites/internal/lib"
+	"github.com/devrites/devrites/internal/parallel"
 	"github.com/devrites/devrites/internal/state"
 	"github.com/devrites/devrites/internal/version"
 )
@@ -24,6 +25,12 @@ Usage:
   devrites-engine check readiness <slug>   Check required files and the stable 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 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
+  devrites-engine check skill-trust <path> Scan one skill/agent Markdown for trust violations
+  devrites-engine observe summary <slug>   Emit sanitized JSON workspace summary
+  devrites-engine parallel <subcommand>   Deterministic parallel worktree lease/create/integrate/cleanup
   devrites-engine state resolve <qid> "<ans>"  Resolve an open question and update state atomically
   devrites-engine state close <slug>       Archive a shipped feature and clear ACTIVE
   devrites-engine secret-scan [--staged] [--stdin] [slug]  Scan exact staged blobs, stdin, or touched files; HIGH blocks
@@ -71,7 +78,11 @@ func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	case "uninstall":
 		return install.Run(args[1:], stdout, stderr, install.ModeUninstall)
 	case "check":
-		return cmdCheck(args[1:], stdout, stderr)
+		return cmdCheck(root, args[1:], stdin, stdout, stderr)
+	case "parallel":
+		return parallel.Run("parallel", args[1:], stdin, stdout, stderr)
+	case "observe":
+		return cmdObserve(root, args[1:], stdout, stderr)
 	case "state":
 		return cmdState(root, args[1:], stdout, stderr)
 	case "secret-scan":
@@ -88,9 +99,9 @@ func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	}
 }
 
-func cmdCheck(args []string, stdout, stderr io.Writer) int {
+func cmdCheck(root string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	if len(args) == 0 {
-		fmt.Fprintln(stderr, "usage: devrites-engine check <candidate|readiness|seal> ...")
+		fmt.Fprintln(stderr, "usage: devrites-engine check <candidate|readiness|seal|path-disjoint|task-graph|skill-trust> ...")
 		return exitUsage
 	}
 	sub, rest := args[0], args[1:]
@@ -99,6 +110,12 @@ func cmdCheck(args []string, stdout, stderr io.Writer) int {
 		return cmdCandidate(rest, stdout, stderr)
 	case "readiness", "seal":
 		return cmdGate(gate.Kind(sub), rest, stdout, stderr)
+	case "path-disjoint":
+		return parallel.Run("path-disjoint", rest, stdin, stdout, stderr)
+	case "task-graph":
+		return cmdTaskGraph(root, rest, stdout, stderr)
+	case "skill-trust":
+		return cmdSkillTrust(rest, stdout, stderr)
 	default:
 		fmt.Fprintf(stderr, "devrites: unknown check %q\n", sub)
 		return exitUsage
@@ -185,3 +202,55 @@ func cmdGate(kind gate.Kind, args []string, stdout, stderr io.Writer) int {
 	fmt.Fprint(stdout, result.Render())
 	return exitOK
 }
+
+func cmdTaskGraph(root string, args []string, stdout, stderr io.Writer) int {
+	if len(args) != 1 {
+		fmt.Fprintln(stderr, "usage: devrites-engine check task-graph <slug>")
+		return exitUsage
+	}
+	if root == "" {
+		var err error
+		root, err = state.ResolveRoot(os.Getenv("DEVRITES_ROOT"))
+		if err != nil {
+			fmt.Fprintf(stderr, "devrites: %v\n", err)
+			return exitUsage
+		}
+	}
+	return lib.RunTaskGraphCheck(root, args[0], stdout, stderr)
+}
+
+func cmdSkillTrust(args []string, stdout, stderr io.Writer) int {
+	if len(args) != 1 {
+		fmt.Fprintln(stderr, "usage: devrites-engine check skill-trust <path>")
+		return exitUsage
+	}
+	return lib.RunSkillTrustCheck(args[0], stdout, stderr)
+}
+
+func cmdObserve(root string, args []string, stdout, stderr io.Writer) int {
+	if len(args) == 0 {
+		fmt.Fprintln(stderr, "usage: devrites-engine observe summary <slug>")
+		return exitUsage
+	}
+	if args[0] != "summary" {
+		fmt.Fprintf(stderr, "devrites: unknown observe command %q\n", args[0])
+		return exitUsage
+	}
+	if root == "" {
+		var err error
+		root, err = state.ResolveRoot(os.Getenv("DEVRITES_ROOT"))
+		if err != nil {
+			fmt.Fprintf(stderr, "devrites: %v\n", err)
+			return exitUsage
+		}
+	}
+	slug, code, err := lib.ActiveSlug(root, args[1:])
+	if err != nil {
+		fmt.Fprintf(stderr, "observe: %v\n", err)
+		if code == 0 {
+			code = exitUsage
+		}
+		return code
+	}
+	return lib.RunObserveSummary(root, slug, stdout, stderr)
+}

package/engine/root_routing_test.go

@@ -126,7 +126,7 @@ func TestNestedCommandFamilyUsageListsOnlyRetainedCommands(t *testing.T) {
 		want    string
 		removed []string
 	}{
-		{args: []string{"check"}, want: "check <candidate|readiness|seal>", removed: []string{"spec"}},
+		{args: []string{"check"}, want: "check <candidate|readiness|seal|path-disjoint|task-graph|skill-trust>", removed: []string{"spec"}},
 		{args: []string{"state"}, want: "state <resolve|close>", removed: []string{"clarify", "tick-afk", "recovery"}},
 	} {
 		t.Run(test.args[0], func(t *testing.T) {

package/pack/.claude/skills/devrites-lib/reference/standards/skill-authoring.md

@@ -96,6 +96,28 @@ External sources are references, not authority. Promote only when one
 
 Missing field → no promotion.
 
+## Skill trust tiers
+
+Every skill or agent surface belongs to exactly one trust tier. Higher tiers may
+constrain lower ones; nothing may weaken shipped gates or permissions.
+
+| Tier | Source | Authority | Install check |
+| --- | --- | --- | --- |
+| **shipped** | `pack/.claude/` built by CI | Full workflow authority | manifest hash + host parity |
+| **project-local** | Repo-scoped customization approved by a human | May extend project rules; cannot weaken DevRites method | `devrites-engine check skill-trust` on the path |
+| **imported** | External skill with `docs/research/` admission record | Read/adapt only after provenance review | skill-trust scan + admission record required |
+| **untrusted** | Unknown origin or failed scan | Reference-only; never executable authority | block on any HIGH finding |
+
+Before promoting or installing project-local/imported Markdown, run:
+
+```bash
+devrites-engine check skill-trust <path>
+```
+
+HIGH findings (prompt-injection override prose, suspicious Unicode, credential exfil
+patterns, sensitive path references) block installation. MEDIUM findings require
+explicit human acknowledgment in the customization diff, not silent merge.
+
 ## Match form to failure
 
 - Rule breaks under pressure → hard guard + rationalization rebuttal + stop list.

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

@@ -1,7 +1,7 @@
 ---
 name: rite-build
-description: Build the next approved vertical slice with evidence. HITL stops after one; explicit AFK may chain bounded green slices.
-argument-hint: "[slice number or name]"
+description: Build the next approved vertical slice with evidence. HITL one-slice default; AFK may chain serially; opt-in `--parallel N` (2≤N≤3) for path-disjoint worktrees.
+argument-hint: "[--parallel N] [slice number or name]"
 user-invocable: true
 ---
 
@@ -9,8 +9,9 @@ user-invocable: true
 
 Build and prove one slice. HITL stops; a later user invocation starts the next.
 Explicit `.devrites/AFK` alone lets the controlling root chain pending slices
-under green proof, caps, and pause rules. Every wright returns after it. Read the
-active workspace first; without one, route `/rite-spec <feature>`.
+serially under green proof, caps, and pause rules. Every wright returns after it.
+**Opt-in:** `/rite-build --parallel N` (2≤N≤3; N=1≡serial) follows
+[`reference/parallel-batch.md`](reference/parallel-batch.md).
 
 Root owns gates/bookkeeping. Fresh
 [`devrites-slice-wright`](../../agents/devrites-slice-wright.md) writes product
@@ -21,45 +22,37 @@ Execute [`reference/phase-contract.md`](reference/phase-contract.md); dispatch u
 
 ## Required rules
 
-Read `.claude/skills/devrites-lib/reference/standards/core.md` first. Load only
-rules triggered by the slice:
-
-- coding style, error handling, testing, [`reference/tdd.md`](reference/tdd.md),
-  patterns, and definition of done;
-- binding `.devrites/principles.md` invariants when present;
-- security for input/auth/data/integrations;
-- repository topology for multiple roots/languages or generated/vendor surfaces;
-- data integrity for durable state, migration, concurrency, tenancy, or retention;
-- integration reliability for API/webhook/queue/job/cache/service boundaries.
-
-The wright also applies the canonical anti-slop list. Root verifies its return;
-it never patches source itself.
+Read `.claude/skills/devrites-lib/reference/standards/core.md` first. Load only triggered rules:
+coding/error/testing/[`tdd.md`](reference/tdd.md)/patterns/DoD; binding
+`.devrites/principles.md`; security; topology; data integrity; integration reliability.
+Wright applies anti-slop; root verifies returns and never patches source.
 
 ## Invariants
 
-- One slice per wright dispatch; writers are serial. Use the native-worktree pilot
-  only when `wright-dispatch.md`'s clean preflight and reconciliation both hold,
-  otherwise serial same-worktree writing.
-- Exact feature scope only. Record adjacent issues and Things I didn't touch;
-  reject any returned diff outside the task's explicit source/test paths.
-- Never rerun an unchanged check. Re-prove after edits.
-- Unplanned dependency, design system, objective technical gap, or repair stays
-  inside Vet/Spec Drift Guard. Ask only for licensing/cost/security/product or
-  explicit architecture-policy decisions.
-- Root never edits product source/tests. It writes canonical `.devrites/`
-  bookkeeping and applies the Workflow Artifact route only. The supported host's
-  wright is sole product writer. Put exact project-relative paths directly in the
-  task; compare returned file list and `git diff --name-only`; extras hard-stop.
-- Project principles are binding. An unavoidable conflict or irreversible risk
-  needs a human-approved scoped exception or stop, never silent balancing.
-- Evidence beats confidence. Never weaken a failing test, skip TDD, widen a
-  writer, or self-approve a wright return. Route drift through
-  [`reference/spec-drift-guard.md`](reference/spec-drift-guard.md); checkpoint
-  mode follows [`reference/checkpoint.md`](reference/checkpoint.md).
+- Default: one slice; writers serial on control. Parallel only via `--parallel N`
+  under [`reference/parallel-batch.md`](reference/parallel-batch.md). Same-worktree
+  multi-writer / root-emulated concurrency forbidden. Native-worktree pilot =
+  single-slice isolation when `wright-dispatch.md` preflight + reconcile hold.
+- Exact feature scope only; reject out-of-allowlist diffs; record adjacent issues.
+- Never rerun an unchanged check; re-prove after edits.
+- Unplanned dependency/design-system/gap/repair → Vet/Spec Drift Guard. Ask only
+  for licensing/cost/security/product or explicit architecture-policy decisions.
+- Root never edits product source/tests (`.devrites/` + Workflow Artifact only).
+  Wright is sole product writer; extras in returned paths/`git diff --name-only` hard-stop.
+- Principles bind; irreversible conflict needs human exception or stop.
+- Evidence beats confidence. Never weaken tests, skip TDD, widen writers, or
+  self-approve. Drift → [`spec-drift-guard.md`](reference/spec-drift-guard.md);
+  checkpoint → [`checkpoint.md`](reference/checkpoint.md).
 
 ## Workflow Artifact branch
 
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"Vet-ready admitted bytes require root authorship outside product wright","action":"ROOT_TRANSACTION; root writes only admitted .devrites/** targets","return":"saved Build slice cursor; wright product allowlist unchanged"} -->
+## `--parallel N` (opt-in)
+
+Omitted/`1` ≡ serial; `2`/`3` → path-disjoint fan-out when eligible; else hard refuse.
+All-green serial integrate; one red/gap aborts. AFK charges after integrate only.
+Running lease blocks another `/rite-build`. Details: `parallel-batch.md`.
+
 ## Execute and reply
 
 Run every step in `reference/phase-contract.md`: readiness, one target, dispatch

package/pack/.claude/skills/rite-build/reference/afk-discipline.md

@@ -8,16 +8,8 @@ Load the shared
 contract for the sentinel schema, defaults, gate ceiling, and mutable-counter
 ownership. This file owns only Build's dispatch, charging, and red-path behavior.
 
-These rules follow established autonomous-coding loops, including Ralph Wiggum and
-Claude Code auto mode:
-
-1. **Require green feedback.** Tests, types, and lint must pass before a slice is
-   marked `built`.
-2. **Cap iterations.** `max_slices` is the hard limit.
-3. **Run gates before the action they control.** A post-action gate is only a review
-   queue.
-4. **Keep irreversible work manual.** Destructive work, auth boundaries, and public
-   API breaks always pause regardless of the sentinel.
+Rules: green before `built`; hard `max_slices` cap; gates before the action they
+control; irreversible work (destructive/auth/public API) always pauses.
 
 ## Iteration cap
 
@@ -41,32 +33,33 @@ The controlling root owns the cap:
    A controlling orchestrator may pre-seed the remaining field from a validated
    post-plan budget before the first dispatch; never increase or reinitialize an
    existing value.
-3. **Charge exactly once after each green built slice.** A slice already marked
-   built is not charged again after retry, resume, or compaction. Re-read the
-   saved cursor; if it is zero, report the cap and stop before the next
-   dispatch.
+3. **Charge exactly once after each green built slice.** On the control tree, a slice
+   already marked built is not charged again after retry, resume, or
+   compaction. Re-read the saved cursor; if it is zero, report the cap and stop
+   before the next dispatch.
+   - **Serial:** charge when fail-on-red is green and the built record is written
+     (same rewrite as step 2).
+   - **Parallel `--parallel`:** charge only after **successful serial integrate**
+     — once per integrated green sibling. Abort / integrate-failed → charge **0**.
+     Do not charge on worktree-green before integrate. See
+     [`parallel-batch.md`](parallel-batch.md).
 
 Use this stop message:
 
-```
+```text
 AFK cap reached. Raise `state.md` `AFK slices remaining` or remove the sentinel to continue.
 ```
 
 `max_slices` itself is read-only and never rewritten. No exit-code command
 enforces this policy.
 
-Choose a missing or large cap deliberately. Ralph's rule is 5-10 iterations for small
-tasks and 30-50 for larger ones. Do not use `unlimited` for work that has not completed
-successfully in HITL.
+Choose caps deliberately (≈5–10 small, ≈30–50 larger). Avoid `unlimited` until HITL
+has succeeded for the work.
 
 ## Fail-on-red
 
-The **fail-on-red step** (workflow step 5) refuses to mark a slice `built` if targeted
-tests, types, or lint are red:
-
-- A red signal means either the slice's contract is wrong or the implementation/proof path is.
-  The slice cannot advance, but an objective root cause is agent-owned recovery work.
-- Marking it `built` would let the next slice build on broken state.
+The **fail-on-red step** refuses `built` when targeted tests/types/lint are red. Red means
+wrong contract or proof path — agent-owned recovery; never advance on broken state.
 
 The fail-on-red path:
 
@@ -105,7 +98,7 @@ The hook is a single shell command run on the `awaiting_human` transition. Envir
 the hook receives:
 
 | Var | Value |
-|---|---|
+| --- | --- |
 | `DEVRITES_QID` | the new qid (e.g. `q-2026-05-28-001`) |
 | `DEVRITES_GATE` | `advisory` / `validating` / `blocking` / `escalating` |
 | `DEVRITES_SLICE` | `<N — name>` |
@@ -117,6 +110,7 @@ The hook is best effort: a non-zero exit does **not** roll back the pause. Failu
 logged to `evidence.md` so the user sees them on return.
 
 Example targets:
+
 - `curl -d "$DEVRITES_QID: $DEVRITES_QUESTION" ntfy.sh/my-topic`
 - `osascript -e "display notification \"$DEVRITES_QUESTION\" with title \"DevRites: $DEVRITES_GATE\""`
 - `pb push "$DEVRITES_SLUG: $DEVRITES_QUESTION"` (via pushbullet CLI)