devrites 5.13.1 → 5.14.1

package/engine/internal/hostpack/hostpack_test.go

@@ -20,6 +20,7 @@ func TestValidatePayloadRequiresClaudeAndCodexFiles(t *testing.T) {
 		"codex/config.toml":                            {},
 		"omp/skills/rite/SKILL.md":                     {},
 		"omp/agents/devrites-code-reviewer.md":         {},
+		"omp/commands/rite.md":                         {},
 		"omp/.omp-plugin/plugin.json":                  {},
 		"pi/skills/rite/SKILL.md":                      {},
 		"pi/agents/devrites-code-reviewer.md":          {},
@@ -66,6 +67,7 @@ func TestInstallTreesMapPayloadsToTargets(t *testing.T) {
 		{PayloadPrefix: "claude/skills", TargetPrefix: ".claude/skills"},
 		{PayloadPrefix: "codex/skills", TargetPrefix: ".agents/skills"},
 		{PayloadPrefix: "omp/skills", TargetPrefix: ".omp/skills"},
+		{PayloadPrefix: "omp/commands", TargetPrefix: ".omp/commands"},
 		{PayloadPrefix: "pi/skills", TargetPrefix: ".pi/skills"},
 		{PayloadPrefix: "pi/prompts", TargetPrefix: ".pi/prompts"},
 		{PayloadPrefix: "devin/skills", TargetPrefix: ".devin/skills"},

package/engine/internal/install/apply.go

@@ -274,9 +274,11 @@ func (r *runner) pruneDropped() error {
 						return fmt.Errorf("strip hooks from %s: %w", merge.TargetRel, err)
 					}
 				} else if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
-					_ = r.stripClaudeSettings(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), true)
-				} else {
-					_ = stripMarkerPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), merge.Begin, merge.End)
+					if err := r.stripClaudeSettings(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), true); err != nil {
+						return fmt.Errorf("strip DevRites settings from %s: %w", merge.TargetRel, err)
+					}
+				} else if err := stripMarkerPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), merge.Begin, merge.End); err != nil {
+					return fmt.Errorf("strip marker block from %s: %w", merge.TargetRel, err)
 				}
 			}
 			if err := os.Remove(dead); err != nil && !os.IsNotExist(err) {

package/engine/internal/install/binary.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/version"
 )
 
 func (r *runner) installBinary() error {
@@ -28,7 +29,8 @@ func (r *runner) installBinary() error {
 	incoming := strings.TrimPrefix(tag, "v")
 	dest := binaryDest()
 	if exists(dest) {
-		if ev := engineVersion(dest); semverLike(ev) && semverLike(incoming) && verGT(ev, incoming) {
+		ev := engineVersion(dest)
+		if c, ok := version.Compare(ev, incoming); ok && c > 0 {
 			fmt.Fprintf(r.opts.Stderr, "warning: engine binary: installed %s is newer than %s - refusing to downgrade (kept).\n", ev, tag)
 			return nil
 		}

package/engine/internal/install/install.go

@@ -405,28 +405,3 @@ func semverLike(v string) bool {
 	v = strings.TrimPrefix(v, "v")
 	return len(v) > 0 && v[0] >= '0' && v[0] <= '9'
 }
-
-func verGT(a, b string) bool {
-	a = strings.TrimPrefix(a, "v")
-	b = strings.TrimPrefix(b, "v")
-	as := strings.Split(strings.Split(a, "-")[0], ".")
-	bs := strings.Split(strings.Split(b, "-")[0], ".")
-	for len(as) < 3 {
-		as = append(as, "0")
-	}
-	for len(bs) < 3 {
-		bs = append(bs, "0")
-	}
-	for i := 0; i < 3; i++ {
-		var ai, bi int
-		_, _ = fmt.Sscanf(as[i], "%d", &ai)
-		_, _ = fmt.Sscanf(bs[i], "%d", &bi)
-		if ai > bi {
-			return true
-		}
-		if ai < bi {
-			return false
-		}
-	}
-	return false
-}

package/engine/internal/install/install_test.go

@@ -1294,6 +1294,7 @@ extends = ":workspace"
 `)
 	testutil.WriteFile(t, filepath.Join(root, "omp", "skills", "rite", "SKILL.md"), "omp rite\n")
 	testutil.WriteFile(t, filepath.Join(root, "omp", "agents", "devrites-code-reviewer.md"), "omp agent\n")
+	testutil.WriteFile(t, filepath.Join(root, "omp", "commands", "rite.md"), "omp command\n")
 	testutil.WriteFile(t, filepath.Join(root, "omp", ".omp-plugin", "plugin.json"), "{}\n")
 	testutil.WriteFile(t, filepath.Join(root, "pi", "skills", "rite", "SKILL.md"), "pi rite\n")
 	testutil.WriteFile(t, filepath.Join(root, "pi", "agents", "devrites-code-reviewer.md"), "pi agent\n")

package/engine/internal/lib/claims.go

@@ -15,6 +15,7 @@ import (
 	"time"
 
 	"github.com/devrites/devrites/internal/parallel"
+	"github.com/devrites/devrites/internal/state"
 )
 
 // ClaimsFile is the repo-level append-only claim ledger under .devrites.
@@ -249,6 +250,20 @@ func claimAdd(root string, args []string, stdout, stderr io.Writer) int {
 		return 2
 	}
 	path := claimsPath(root)
+	// Hold the ledger lock across read, conflict check, and append so two
+	// sessions cannot both pass the check and claim the same path.
+	code := 0
+	if err := state.WithLock(path+".lock", func() error {
+		code = claimAddLocked(path, session, reason, ttl, paths, stdout, stderr)
+		return nil
+	}); err != nil {
+		fmt.Fprintf(stderr, "claim: %v\n", err)
+		return 2
+	}
+	return code
+}
+
+func claimAddLocked(path, session, reason string, ttl int, paths []string, stdout, stderr io.Writer) int {
 	latest, order, _, err := readClaims(path)
 	if err != nil {
 		fmt.Fprintf(stderr, "claim: %v\n", err)

package/engine/internal/lib/claims_test.go

@@ -3,9 +3,11 @@ package lib
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )
@@ -180,3 +182,29 @@ func TestClaimLedgerToleratesMalformedLines(t *testing.T) {
 		t.Fatalf("malformed ledger: %d %q", code, out)
 	}
 }
+
+func TestClaimAddConcurrentOverlapOneWins(t *testing.T) {
+	root := claimTestRoot(t)
+	const n = 8
+	codes := make(chan int, n)
+	var wg sync.WaitGroup
+	for i := range n {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			var out, errOut bytes.Buffer
+			codes <- RunClaim(root, []string{"add", "--session", fmt.Sprintf("s%d", i), "pkg/a.go"}, &out, &errOut)
+		}()
+	}
+	wg.Wait()
+	close(codes)
+	wins := 0
+	for c := range codes {
+		if c == 0 {
+			wins++
+		}
+	}
+	if wins != 1 {
+		t.Fatalf("overlapping concurrent claims: %d succeeded, want exactly 1", wins)
+	}
+}

package/engine/internal/lib/context_next_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 )
 
@@ -519,3 +520,55 @@ func TestDiffScopeAllowlist(t *testing.T) {
 		t.Fatalf("code=%d\n%s", code, stdout.String())
 	}
 }
+
+func TestDispatchConcurrentReturnsCompleteWave(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	run := func(args ...string) int {
+		out, err := &bytes.Buffer{}, &bytes.Buffer{}
+		return RunDispatch(root, args, out, err)
+	}
+	roles := []string{"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7"}
+	open := []string{"feat", "open", "--phase", "review", "--wave", "w"}
+	for _, r := range roles {
+		open = append(open, "--role", r)
+	}
+	if c := run(open...); c != 0 {
+		t.Fatal("open failed")
+	}
+	for _, r := range roles {
+		if c := run("feat", "start", "--wave", "w", "--role", r, "--handle", "h-"+r); c != 0 {
+			t.Fatalf("start %s failed", r)
+		}
+	}
+	if c := run("feat", "seal", "--wave", "w"); c != 0 {
+		t.Fatal("seal failed")
+	}
+	var wg sync.WaitGroup
+	for _, r := range roles {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if c := run("feat", "return", "--wave", "w", "--role", r); c != 0 {
+				t.Errorf("return %s failed: %d", r, c)
+			}
+		}()
+	}
+	wg.Wait()
+	if c := run("feat", "status", "--wave", "w"); c != 0 {
+		data, _ := os.ReadFile(filepath.Join(featureDir, "dispatch.json"))
+		t.Fatalf("concurrent returns lost an update; wave not complete:\n%s", data)
+	}
+}
+
+func TestDispatchAbandonRecordsReason(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
+	if c := RunDispatch(root, []string{"feat", "open", "--phase", "build", "--wave", "w", "--role", "x"}, out, errOut); c != 0 {
+		t.Fatal("open failed")
+	}
+	RunDispatch(root, []string{"feat", "abandon", "--wave", "w", "--reason", "host limit"}, out, errOut)
+	data, err := os.ReadFile(filepath.Join(featureDir, "dispatch.json"))
+	if err != nil || !strings.Contains(string(data), `"reason": "host limit"`) {
+		t.Fatalf("abandon reason not persisted: %v\n%s", err, data)
+	}
+}

package/engine/internal/lib/dispatch.go

@@ -6,10 +6,12 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
 
 	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/state"
 )
 
 // dispatch.go: launch-wave barrier for host-native agent dispatch. Hosts own
@@ -31,9 +33,10 @@ type dispatchFile struct {
 }
 
 type dispatchWave struct {
-	Phase string                   `json:"phase"`
-	State string                   `json:"state"` // open, sealed, abandoned, complete
-	Roles map[string]*dispatchRole `json:"roles"`
+	Phase  string                   `json:"phase"`
+	State  string                   `json:"state"` // open, sealed, abandoned, complete
+	Reason string                   `json:"reason,omitempty"`
+	Roles  map[string]*dispatchRole `json:"roles"`
 }
 
 type dispatchRole struct {
@@ -79,7 +82,7 @@ func saveDispatch(path string, f *dispatchFile) error {
 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
 		return err
 	}
-	return os.WriteFile(path, data, 0o600)
+	return state.AtomicWrite(path, data, 0o600)
 }
 
 func nowStamp() string { return time.Now().UTC().Format(time.RFC3339) }
@@ -122,6 +125,20 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
 		return 2
 	}
+	// Serialize load-modify-save so concurrent start/return calls never lose
+	// an update and strand the wave short of complete.
+	code := 0
+	if err := state.WithFeatureLock(root, slug, func() error {
+		code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, stdout, stderr)
+		return nil
+	}); err != nil {
+		fmt.Fprintf(stderr, "dispatch: %v\n", err)
+		return 3
+	}
+	return code
+}
+
+func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles []string, stdout, stderr io.Writer) int {
 	f, path, err := loadDispatch(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -204,6 +221,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			}
 		}
 		if len(missing) > 0 {
+			sort.Strings(missing)
 			return fail("wave %q cannot seal: no start handle for %s", wave, strings.Join(missing, ","))
 		}
 		w.State = "sealed"
@@ -244,7 +262,8 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 
 	case "status":
 		if wave == "" {
-			for name, w := range f.Waves {
+			for _, name := range sortedKeys(f.Waves) {
+				w := f.Waves[name]
 				fmt.Fprintf(stdout, "dispatch: wave %s state=%s roles=%d\n", name, w.State, len(w.Roles))
 			}
 			if len(f.Waves) == 0 {
@@ -257,7 +276,8 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			return fail("no wave %q", wave)
 		}
 		var pending []string
-		for name, r := range w.Roles {
+		for _, name := range sortedKeys(w.Roles) {
+			r := w.Roles[name]
 			mark := "declared"
 			if r.Handle != "" {
 				mark = "started"
@@ -281,9 +301,10 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			return fail("no wave %q", wave)
 		}
 		if strings.TrimSpace(reason) == "" {
-			return fail("--reason is required (non-empty, surfaced in handoff)")
+			return fail("--reason is required (non-empty, recorded in dispatch.json)")
 		}
 		w.State = "abandoned"
+		w.Reason = reason
 		if err := saveDispatch(path, f); err != nil {
 			return fail("%v", err)
 		}

package/engine/internal/lib/manifest_union.go

@@ -48,6 +48,20 @@ func RunMergeManifest(root string, args []string, stdout, stderr io.Writer) int
 		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: %v\n", err)
 		return 3
 	}
+	code := 0
+	if err := state.WithFeatureLock(root, slug, func() error {
+		code = mergeManifestLocked(root, slug, workspace, args, stdout, stderr)
+		return nil
+	}); err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: %v\n", err)
+		return 1
+	}
+	return code
+}
+
+// mergeManifestLocked reads, unions, and rewrites touched-files.md under the
+// feature lock so a concurrent writer cannot interleave with the rewrite.
+func mergeManifestLocked(root, slug, workspace string, args []string, stdout, stderr io.Writer) int {
 	manifestPath := filepath.Join(workspace, "touched-files.md")
 	releaseRaw, err := readBoundedRegularFile(manifestPath, maxCandidateManifestBytes)
 	if err != nil {

package/engine/internal/overhaul/admit/admit_test.go

@@ -80,8 +80,16 @@ func TestReceipt(t *testing.T) {
 			r["task_id"], r["role"], r["lane"], r["outcome"] = "R-1", "reviewer", "security", "no-findings"
 			delete(r, "changed_paths")
 		}, "-", 1, "no-findings without inspected ranges is malformed"},
+		{"reviewer no-findings without domains", func(r J) {
+			r["task_id"], r["role"], r["lane"], r["outcome"], r["inspected"] = "R-1", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+		}, "-", 1, "no-findings must name its domains_checked"},
+		{"reviewer unknown domain", func(r J) {
+			r["task_id"], r["role"], r["lane"], r["outcome"], r["inspected"] = "R-1", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+			r["domains_checked"] = L{"style"}
+		}, "-", 1, "domains_checked has unknown domain 'style'"},
 		{"reviewer admissible", func(r J) {
 			r["task_id"], r["role"], r["lane"], r["outcome"], r["inspected"] = "R-1", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+			r["domains_checked"] = L{"security"}
 		}, "-", 0, "ADMISSIBLE"},
 	}
 	for _, c := range cases {
@@ -101,6 +109,32 @@ func TestReceipt(t *testing.T) {
 	}
 }
 
+// A receipt is admitted against the open working generation (g<N+1>.tmp based on
+// CURRENT) when one exists, so dispatches need not be published one by one.
+func TestReceiptAgainstOpenStage(t *testing.T) {
+	dir := newRun(t)
+	stage := filepath.Join(dir, "g0002.tmp")
+	write(t, filepath.Join(stage, ".base"), "g0001")
+	write(t, filepath.Join(stage, "run.json"), J{"run_id": "run-1",
+		"revisions": J{"plan": J{"rev": 1, "file": "revisions/plan-r1.json"}}})
+	write(t, filepath.Join(stage, "dispatch.json"), J{"attempts": L{
+		J{"task_id": "R-2", "attempt_id": "A1", "role": "reviewer", "lane": "security", "snapshot": "s1", "status": "running"},
+	}})
+	rc := writerReceipt()
+	rc["task_id"], rc["role"], rc["lane"], rc["outcome"], rc["inspected"] = "R-2", "reviewer", "security", "no-findings", L{"src/a.py:1-9"}
+	rc["domains_checked"] = L{"security"}
+	delete(rc, "changed_paths")
+	p := write(t, filepath.Join(dir, "receipts/r2.json"), rc)
+	if code, out, errs := run("receipt", dir, p); code != 0 || !strings.Contains(out, "ADMISSIBLE") {
+		t.Fatalf("open stage: %d %s%s", code, out, errs)
+	}
+	// A stage based on an older generation is stale and never consulted.
+	write(t, filepath.Join(stage, ".base"), "g0000")
+	if code, out, _ := run("receipt", dir, p); code != 1 || !strings.Contains(out, "no such dispatched attempt") {
+		t.Fatalf("stale stage consulted: %d %s", code, out)
+	}
+}
+
 func TestReceiptIOError(t *testing.T) {
 	dir := newRun(t)
 	if code, _, errs := run("receipt", dir, filepath.Join(dir, "missing.json")); code != 2 || !strings.HasPrefix(errs, "ERROR: ") {

package/engine/internal/overhaul/admit/run.go

@@ -175,12 +175,24 @@ func sortedVals(s map[string]any) []any {
 	return out
 }
 
+// workingGeneration is the open staged generation when one exists and is based on
+// CURRENT (the coordinator records dispatches there during a phase), else CURRENT.
+func workingGeneration(run, cur string) string {
+	stages, _ := filepath.Glob(join(run, "g*.tmp"))
+	if len(stages) == 1 {
+		if base, err := os.ReadFile(join(stages[0], ".base")); err == nil && strings.TrimSpace(string(base)) == cur { // #nosec G304 -- stage marker inside the operator-selected run area
+			return stages[0]
+		}
+	}
+	return join(run, cur)
+}
+
 func receipt(run, path, observed string, hasObserved bool, stdout io.Writer) (int, error) {
 	cur, err := os.ReadFile(join(run, "CURRENT"))
 	if err != nil {
 		return 0, err
 	}
-	gen := join(run, strings.TrimSpace(string(cur)))
+	gen := workingGeneration(run, strings.TrimSpace(string(cur)))
 	rj, err := ovio.LoadObject(join(gen, "run.json"))
 	if err != nil {
 		return 0, err
@@ -228,6 +240,15 @@ func receipt(run, path, observed string, hasObserved bool, stdout io.Writer) (in
 		if ovio.Str(rc["outcome"]) == "no-findings" && !ovio.Truthy(rc["inspected"]) {
 			why = append(why, "no-findings without inspected ranges is malformed")
 		}
+		checked := ovio.List(rc["domains_checked"])
+		if ovio.Str(rc["outcome"]) == "no-findings" && len(checked) == 0 {
+			why = append(why, "no-findings must name its domains_checked")
+		}
+		for _, d := range checked {
+			if !slices.Contains(ovio.Domains, ovio.Str(d)) {
+				why = append(why, "domains_checked has unknown domain "+records.Repr(d))
+			}
+		}
 		if writers[ovio.Str(x["role"])] {
 			v, err := keyed(rj, "revisions")
 			if err == nil {