devrites 7.3.1 → 7.3.3

package/engine/internal/install/merge.go

@@ -50,7 +50,7 @@ const (
 )
 
 func (r *runner) claudeSettingsMarkerLines() []string {
-	data, err := os.ReadFile(filepath.Join(r.target, filepath.FromSlash(hostpack.ClaudeSettingsMerge.MarkerRel)))
+	data, err := r.readConfined(filepath.Join(r.target, filepath.FromSlash(hostpack.ClaudeSettingsMerge.MarkerRel)))
 	if err != nil {
 		return nil
 	}
@@ -134,18 +134,24 @@ func (r *runner) mergeMarkerFile(merge hostpack.MarkerMerge) error {
 			}
 		}
 		fmt.Fprintf(r.opts.Stdout, "  [merge] %s (%s)\n", merge.TargetRel, verb)
-	} else {
-		dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
-		if err := r.writeConfined(dest, next, 0o644); err != nil {
-			return fmt.Errorf("cannot write %s: %w", merge.TargetRel, err)
-		}
-		// Multiple marker blocks can share one target (AGENTS.md carries both
-		// the Codex and pi blocks).
-		if err := r.refreshPreflight(merge.TargetRel); err != nil {
-			return err
-		}
+		return r.installMarker(merge.MarkerRel, merge.MarkerText)
+	}
+	if err := r.installMarker(merge.MarkerRel, merge.MarkerText); err != nil {
+		return err
+	}
+	if r.records[merge.MarkerRel] == "" {
+		return fmt.Errorf("cannot merge %s without owning %s; use --force to replace the marker", merge.TargetRel, merge.MarkerRel)
+	}
+	if err := r.recheckPath(merge.TargetRel); err != nil {
+		return err
+	}
+	dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
+	if err := r.writeConfined(dest, next, 0o644); err != nil {
+		return fmt.Errorf("cannot write %s: %w", merge.TargetRel, err)
 	}
-	return r.installMarker(merge.MarkerRel, merge.MarkerText)
+	// Multiple marker blocks can share one target (AGENTS.md carries both
+	// the Codex and pi blocks).
+	return r.refreshPreflight(merge.TargetRel)
 }
 
 // markerMergeNext returns the merged target bytes and the current bytes
@@ -156,8 +162,7 @@ func (r *runner) markerMergeNext(merge hostpack.MarkerMerge) ([]byte, []byte, er
 		return nil, nil, fmt.Errorf("read payload %s: %w", merge.PayloadRel, err)
 	}
 	dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
-	// #nosec G304 -- dest joins the operator target with a fixed manifest-relative record
-	current, readErr := os.ReadFile(dest)
+	current, readErr := r.readConfined(dest)
 	if errors.Is(readErr, fs.ErrNotExist) {
 		return block, nil, nil
 	}
@@ -208,11 +213,20 @@ func (r *runner) mergeCodexConfig() error {
 	if err != nil {
 		return err
 	}
+	if err := r.installMarker(merge.MarkerRel, merge.MarkerText); err != nil {
+		return err
+	}
+	if r.records[merge.MarkerRel] == "" {
+		return fmt.Errorf("cannot merge %s without owning %s; use --force to replace the marker", merge.TargetRel, merge.MarkerRel)
+	}
+	if err := r.recheckPath(merge.TargetRel); err != nil {
+		return err
+	}
 	dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
 	if err := r.writeConfined(dest, next, 0o644); err != nil {
 		return fmt.Errorf("cannot write %s: %w", merge.TargetRel, err)
 	}
-	return r.installMarker(merge.MarkerRel, merge.MarkerText)
+	return nil
 }
 
 // codexConfigNext returns the merged .codex/config.toml without writing it.
@@ -227,8 +241,7 @@ func (r *runner) codexConfigNext() ([]byte, error) {
 	}
 	dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
 	var current []byte
-	// #nosec G304 -- dest joins the operator target with a fixed manifest-relative record
-	if data, readErr := os.ReadFile(dest); readErr == nil {
+	if data, readErr := r.readConfined(dest); readErr == nil {
 		// Drop a UTF-8 BOM: the block may go at offset 0, and a BOM after
 		// it is invalid TOML.
 		data = bytes.TrimPrefix(data, utf8BOM)
@@ -423,7 +436,7 @@ func (r *runner) claudeSettingsNext() (map[string]any, claudeSettingsMerge, erro
 	}
 	current := map[string]any{}
 	state := claudeSettingsMerge{created: r.claudeSettingsCreated()}
-	if data, readErr := readJSON(dest); readErr == nil {
+	if data, readErr := r.readJSON(dest); readErr == nil {
 		current = data
 	} else if errors.Is(readErr, fs.ErrNotExist) {
 		state.created = true
@@ -443,13 +456,13 @@ func (r *runner) seedClaudeSettings() error {
 }
 
 func (r *runner) stripHooksConfined(path string) error {
-	return stripHooksWith(path, func(data []byte) error {
+	return r.stripHooksWith(path, func(data []byte) error {
 		return r.writeConfined(path, data, 0o644)
 	}, func() error { return r.removeConfined(path) })
 }
 
-func stripHooksWith(path string, write func([]byte) error, remove func() error) error {
-	current, err := readJSON(path)
+func (r *runner) stripHooksWith(path string, write func([]byte) error, remove func() error) error {
+	current, err := r.readJSON(path)
 	if err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
 			return nil
@@ -475,7 +488,7 @@ func (r *runner) stripClaudeSettings(path string) error {
 }
 
 func (r *runner) stripClaudeSettingsWith(path string, write func([]byte) error, remove func() error) error {
-	current, err := readJSON(path)
+	current, err := r.readJSON(path)
 	if err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
 			return nil
@@ -495,14 +508,13 @@ func (r *runner) stripClaudeSettingsWith(path string, write func([]byte) error,
 }
 
 func (r *runner) stripMarkerConfined(path, begin, end string) error {
-	return stripMarkerWith(path, begin, end, func(data []byte) error {
+	return r.stripMarkerWith(path, begin, end, func(data []byte) error {
 		return r.writeConfined(path, data, 0o644)
 	}, func() error { return r.removeConfined(path) })
 }
 
-func stripMarkerWith(path, begin, end string, write func([]byte) error, remove func() error) error {
-	// #nosec G304 -- managed file path from the install manifest
-	data, err := os.ReadFile(path)
+func (r *runner) stripMarkerWith(path, begin, end string, write func([]byte) error, remove func() error) error {
+	data, err := r.readConfined(path)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil
@@ -536,9 +548,8 @@ func hasTopLevelTOMLKey(data []byte, key string) bool {
 	return found
 }
 
-func readJSON(path string) (map[string]any, error) {
-	// #nosec G304 -- engine-written workspace or metadata JSON
-	data, err := os.ReadFile(path)
+func (r *runner) readJSON(path string) (map[string]any, error) {
+	data, err := r.readConfined(path)
 	if err != nil {
 		return nil, fmt.Errorf("read %s: %w", path, err)
 	}
@@ -567,10 +578,55 @@ func isDevritesHookCommand(v any) bool {
 		return false
 	}
 	command, _ := hook["command"].(string)
-	return strings.Contains(command, "devrites-engine hook ") ||
-		strings.Contains(command, ".claude/hooks/devrites-") ||
-		strings.Contains(command, ".codex/hooks/devrites-") ||
-		(strings.Contains(command, "printf ") && strings.Contains(command, "DevRites:"))
+	// Match shipped command templates, not quoted or logged mentions in user commands.
+	switch command {
+	case `printf '%s\n' 'DevRites: this subagent is the single write-capable slice-wright. Stay within the current slice contract and touched-files.md; write no .devrites bookkeeping.'`,
+		`printf '%s\n' 'DevRites: this subagent is read-only. Inspect with read/search/test commands and return findings only; do not mutate the tree.'`,
+		`printf '%s\n' 'DevRites: reconcile this subagent result against the active DevRites skill contract before claiming completion.'`,
+		`root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"; cd "$root" && DEVRITES_REVIEWER_AGENT_REQUIRED=1 bash "$root/.codex/hooks/devrites-reviewer-readonly.sh"`,
+		`root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"; cd "$root" && DEVRITES_WRIGHT_AGENT_REQUIRED=1 bash "$root/.codex/hooks/devrites-wright-scope.sh"`:
+		return true
+	}
+	for _, prefix := range [...]string{
+		`bash "$CLAUDE_PROJECT_DIR/.claude/hooks/devrites-`,
+		`bash "${CLAUDE_PLUGIN_ROOT}/pack/.claude/hooks/devrites-`,
+		`root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"; cd "$root" && bash "$root/.codex/hooks/devrites-`,
+	} {
+		if script, ok := strings.CutPrefix(command, prefix); ok {
+			switch script {
+			case `a1-guard.sh"`, `allow.sh"`, `cursor.sh"`, `orient.sh"`,
+				`redwatch.sh"`, `refresh-indexes.sh"`, `stop-gate.sh"`:
+				return true
+			}
+			return false
+		}
+	}
+	if rest, ok := strings.CutPrefix(command, "command -v devrites-engine >/dev/null 2>&1 && exec "); ok {
+		var complete bool
+		command, complete = strings.CutSuffix(rest, " || exit 0")
+		if !complete {
+			return false
+		}
+	}
+	command = strings.TrimPrefix(command, `command -v devrites-engine >/dev/null 2>&1 || exit 0; cd "$(git rev-parse --show-toplevel 2>/dev/null || pwd)" 2>/dev/null || exit 0; exec `)
+	switch command {
+	case "env DEVRITES_REVIEWER_AGENT_REQUIRED=1 devrites-engine hook reviewer-readonly --harness=codex",
+		"env DEVRITES_WRIGHT_AGENT_REQUIRED=1 devrites-engine hook wright-scope --harness=codex":
+		return true
+	}
+	args, ok := strings.CutPrefix(command, "devrites-engine hook ")
+	if !ok {
+		return false
+	}
+	args = strings.TrimSuffix(strings.TrimSuffix(args, " --harness=claude"), " --harness=codex")
+	switch args {
+	case "a1-guard", "allow", "auq", "cursor", "event session-end", "event subagent-stop",
+		"git-guard", "handoff-snapshot", "old-gate", "orient", "redwatch", "refresh-indexes",
+		"reviewer-readonly", "source-cache-post", "source-cache-pre", "statusline",
+		"stop-gate", "subagent-orient", "wright-scope":
+		return true
+	}
+	return false
 }
 
 func isDevritesHooksComment(comment string) bool {

package/engine/internal/install/preflight.go

@@ -14,7 +14,6 @@ import (
 	"strings"
 
 	"github.com/devrites/devrites/internal/hostpack"
-	"github.com/devrites/devrites/internal/safepath"
 )
 
 func (r *runner) preflightInstall() error {
@@ -46,10 +45,15 @@ func (r *runner) preflightInstall() error {
 			return err
 		}
 		if !snapshot.missing && r.isPinnedAlias(rel) {
-			// scripts/pin.sh aliases are not in the payload; carry them
-			// forward (hashed) so prune keeps them and uninstall removes them.
+			// Carry pins without adopting edits; only legacy pins need a baseline.
+			if record.Hash == "" {
+				record.Hash = snapshot.hash
+			}
+			if kind := managedConflict(record, snapshot); kind != "" && !r.opts.Force {
+				conflicts = append(conflicts, fmt.Sprintf("%s: %s", kind, rel))
+			}
 			r.addManifest(rel)
-			r.addInstallRecord(rel, snapshot.hash)
+			r.addInstallRecord(rel, record.Hash)
 			continue
 		}
 		if !snapshot.missing {
@@ -101,23 +105,33 @@ func (r *runner) preflightMerges() error {
 		if _, _, err := r.markerMergeNext(m.merge); err != nil {
 			return fmt.Errorf("merge %s: %w", m.merge.TargetRel, err)
 		}
+		if err := r.preflightMarkerOwnership(m.merge.TargetRel, m.merge.MarkerRel, m.merge.MarkerText); err != nil {
+			return err
+		}
 	}
 	if r.opts.WithCodex {
 		if _, err := r.codexConfigNext(); err != nil {
 			return fmt.Errorf("merge %s: %w", hostpack.CodexConfigMerge.TargetRel, err)
 		}
+		merge := hostpack.CodexConfigMerge
+		if err := r.preflightMarkerOwnership(merge.TargetRel, merge.MarkerRel, merge.MarkerText); err != nil {
+			return err
+		}
 	}
 	_, settings, err := r.claudeSettingsNext()
 	if err != nil {
 		return fmt.Errorf("seed claude settings: %w", err)
 	}
-	marker := hostpack.ClaudeSettingsMerge.MarkerRel
+	merge := hostpack.ClaudeSettingsMerge
+	return r.preflightMarkerOwnership(merge.TargetRel, merge.MarkerRel, claudeSettingsMarkerText(r.pendingClaudeSettingsOwnership(settings)))
+}
+
+func (r *runner) preflightMarkerOwnership(target, marker, text string) error {
 	if snapshot := r.preflight[marker]; !snapshot.missing && !r.opts.Force {
 		if _, managed := r.prev[marker]; !managed {
-			text := claudeSettingsMarkerText(r.pendingClaudeSettingsOwnership(settings)) + "\n"
-			sum := sha256.Sum256([]byte(text))
+			sum := sha256.Sum256([]byte(text + "\n"))
 			if snapshot.hash != fmt.Sprintf("sha256:%x", sum[:]) {
-				return fmt.Errorf("cannot merge %s without owning %s; use --force to replace the marker", hostpack.ClaudeSettingsMerge.TargetRel, marker)
+				return fmt.Errorf("cannot merge %s without owning %s; use --force to replace the marker", target, marker)
 			}
 		}
 	}
@@ -249,10 +263,17 @@ func (r *runner) installMergeTargets() []string {
 
 func (r *runner) rememberPath(rel string) (pathSnapshot, error) {
 	rel = filepath.ToSlash(rel)
+	if r.targetInfo == nil {
+		info, err := os.Stat(r.target)
+		if err != nil {
+			return pathSnapshot{}, err
+		}
+		r.targetInfo = info
+	}
 	if snapshot, ok := r.preflight[rel]; ok {
 		return snapshot, nil
 	}
-	snapshot, err := inspectManagedPath(r.target, rel)
+	snapshot, err := r.inspectManagedPath(rel)
 	if err != nil {
 		return pathSnapshot{}, err
 	}
@@ -264,7 +285,7 @@ func (r *runner) rememberPath(rel string) (pathSnapshot, error) {
 // verified write (marker merge, strip). Needed when several managed merges
 // share one target such as AGENTS.md.
 func (r *runner) refreshPreflight(rel string) error {
-	snap, err := inspectManagedPath(r.target, rel)
+	snap, err := r.inspectManagedPath(rel)
 	if err != nil {
 		return err
 	}
@@ -273,12 +294,15 @@ func (r *runner) refreshPreflight(rel string) error {
 }
 
 func (r *runner) recheckPath(rel string) error {
+	if err := r.checkTargetIdentity(); err != nil {
+		return err
+	}
 	rel = filepath.ToSlash(rel)
 	before, ok := r.preflight[rel]
 	if !ok {
 		return fmt.Errorf("path %s was not preflighted", rel)
 	}
-	now, err := inspectManagedPath(r.target, rel)
+	now, err := r.inspectManagedPath(rel)
 	if err != nil {
 		return err
 	}
@@ -287,6 +311,9 @@ func (r *runner) recheckPath(rel string) error {
 	}
 	if afterRecheckPath != nil {
 		afterRecheckPath(rel)
+		if err := r.checkTargetIdentity(); err != nil {
+			return err
+		}
 	}
 	return nil
 }
@@ -295,20 +322,35 @@ func (r *runner) recheckPath(rel string) error {
 // recheck and the write that follows it.
 var afterRecheckPath func(rel string)
 
+func (r *runner) inspectManagedPath(rel string) (pathSnapshot, error) {
+	if r.targetRoot != nil {
+		return inspectManagedPathIn(r.targetRoot, rel)
+	}
+	return inspectManagedPath(r.target, rel)
+}
+
 func inspectManagedPath(target, rel string) (pathSnapshot, error) {
+	root, err := os.OpenRoot(target)
+	if err != nil {
+		return pathSnapshot{}, err
+	}
+	defer func() { _ = root.Close() }()
+	return inspectManagedPathIn(root, rel)
+}
+
+func inspectManagedPathIn(root *os.Root, rel string) (pathSnapshot, error) {
 	native := filepath.FromSlash(rel)
 	if !filepath.IsLocal(native) {
 		return pathSnapshot{}, fmt.Errorf("refusing unsafe managed path %q", rel)
 	}
-	dest := filepath.Join(target, native)
-	if !safepath.WithinResolved(dest, target) {
-		return pathSnapshot{}, fmt.Errorf("refusing managed path outside target: %s", rel)
+	if root == nil {
+		return pathSnapshot{}, fmt.Errorf("install target is not open")
 	}
-	walk := target
+	walk := ""
 	parts := strings.Split(native, string(filepath.Separator))
 	for _, part := range parts {
 		walk = filepath.Join(walk, part)
-		info, err := os.Lstat(walk)
+		info, err := root.Lstat(walk)
 		if os.IsNotExist(err) {
 			return pathSnapshot{missing: true}, nil
 		}
@@ -319,7 +361,7 @@ func inspectManagedPath(target, rel string) (pathSnapshot, error) {
 			return pathSnapshot{}, fmt.Errorf("refusing symlink or junction in managed path: %s", rel)
 		}
 	}
-	info, err := os.Lstat(dest)
+	info, err := root.Lstat(native)
 	if os.IsNotExist(err) {
 		return pathSnapshot{missing: true}, nil
 	}
@@ -329,8 +371,7 @@ func inspectManagedPath(target, rel string) (pathSnapshot, error) {
 	if !info.Mode().IsRegular() {
 		return pathSnapshot{}, fmt.Errorf("refusing non-regular managed path: %s", rel)
 	}
-	// #nosec G304 -- managed path snapshot; regular-file check above
-	f, err := os.Open(dest)
+	f, err := root.Open(native)
 	if err != nil {
 		return pathSnapshot{}, fmt.Errorf("read managed path %s: %w", rel, err)
 	}

package/engine/internal/install/uninstall.go

@@ -12,13 +12,20 @@ import (
 
 func (r *runner) uninstall() error {
 	mf := filepath.Join(r.target, ManifestName)
-	entries, err := readManifestList(mf)
+	data, err := r.readConfined(mf)
+	if err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("read manifest %s: %w", mf, err)
+	}
+	_, entries, err := parseManifestData(data)
 	if err != nil {
 		return err
 	}
 	if len(entries) == 0 {
 		return fmt.Errorf("no DevRites manifest at %s - nothing to uninstall", mf)
 	}
+	if err := r.preflightBinaryRemoval(); err != nil {
+		return err
+	}
 	fmt.Fprintln(r.opts.Stdout, "DevRites uninstaller")
 	fmt.Fprintf(r.opts.Stdout, "  target  : %s\n", r.target)
 	fmt.Fprintf(r.opts.Stdout, "  manifest: %s\n", mf)
@@ -99,6 +106,15 @@ func (r *runner) uninstall() error {
 			r.stats.missing++
 		}
 	}
+	if !r.opts.DryRun {
+		for _, d := range dirs {
+			r.pruneEmptyDirs(d)
+		}
+	}
+	// Keep ownership available for a retry if the external binary cannot be removed.
+	if err := r.removeBinary(); err != nil {
+		return fmt.Errorf("remove engine binary: %w", err)
+	}
 	if r.opts.DryRun {
 		fmt.Fprintf(r.opts.Stdout, "  [remove] %s\n", ManifestName)
 	} else {
@@ -106,13 +122,7 @@ func (r *runner) uninstall() error {
 			return err
 		}
 		_ = r.removeConfined(mf)
-		dirs = append(dirs, filepath.Dir(mf))
-		for _, d := range dirs {
-			pruneEmptyDirs(d, r.target)
-		}
-	}
-	if err := r.removeBinary(); err != nil {
-		return fmt.Errorf("remove engine binary: %w", err)
+		r.pruneEmptyDirs(filepath.Dir(mf))
 	}
 	fmt.Fprintln(r.opts.Stdout)
 	if r.opts.DryRun {
@@ -141,7 +151,7 @@ func (r *runner) dryRunStripMarker(tree map[string][]byte, merge hostpack.Manage
 	write := func(data []byte) error { tree[path] = data; return nil }
 	remove := func() error { tree[path] = nil; return nil }
 	if merge.MarkerRel == hostpack.LegacyCodexHooksMerge.MarkerRel {
-		return stripHooksWith(path, write, remove)
+		return r.stripHooksWith(path, write, remove)
 	}
 	if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
 		return r.stripClaudeSettingsWith(path, write, remove)

package/engine/internal/install/update.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/devrites/devrites/internal/hostpack"
 	"github.com/devrites/devrites/internal/release"
 )
 
@@ -65,9 +64,6 @@ func runUpdate(opts Options) error {
 	if err != nil {
 		return fmt.Errorf("resolve payload %s: %w", opts.PayloadDir, err)
 	}
-	if err := hostpack.ValidatePayload(os.DirFS(payload), true, true, true, true, true); err != nil {
-		return fmt.Errorf("local update payload under %s is invalid: %w", payload, err)
-	}
 	installFlags := manifestHeader(mf, "devrites-flags")
 	next := DefaultOptions(ModeInstall)
 	next.Stdout = opts.Stdout

package/engine/internal/lib/apply_bundle.go

@@ -437,20 +437,37 @@ func checkBundleResult(targets []*bundleTarget, retired map[string]bool) []strin
 	return problems
 }
 
-// writeBundleTargets writes every target atomically and, if one write fails,
-// restores the files already written so the workspace never holds half a
-// bundle.
+// writeBundleTargets writes every target atomically. A failed write may already
+// have published its bytes, so rollback covers every attempted target and reports
+// any restoration failures.
 func writeBundleTargets(ws *os.Root, targets []*bundleTarget) error {
+	return writeBundleTargetsWith(ws, targets, fsutil.WriteFileAtomicIn)
+}
+
+func writeBundleTargetsWith(ws *os.Root, targets []*bundleTarget, write func(*os.Root, string, []byte, fs.FileMode) error) error {
 	for i, target := range targets {
-		if err := fsutil.WriteFileAtomicIn(ws, filepath.FromSlash(target.rel), target.after, 0o644); err != nil {
-			for _, done := range targets[:i] {
+		if err := write(ws, filepath.FromSlash(target.rel), target.after, 0o644); err != nil {
+			writeErr := fmt.Errorf("write %s: %w", target.rel, err)
+			var rollbackErrors []error
+			for j := i; j >= 0; j-- {
+				done := targets[j]
+				var rollbackErr error
 				if done.existed {
-					_ = fsutil.WriteFileAtomicIn(ws, filepath.FromSlash(done.rel), done.before, 0o644)
+					rollbackErr = write(ws, filepath.FromSlash(done.rel), done.before, 0o644)
 				} else {
-					_ = ws.Remove(filepath.FromSlash(done.rel))
+					rollbackErr = ws.Remove(filepath.FromSlash(done.rel))
+					if errors.Is(rollbackErr, fs.ErrNotExist) {
+						rollbackErr = nil
+					}
 				}
+				if rollbackErr != nil {
+					rollbackErrors = append(rollbackErrors, fmt.Errorf("rollback %s: %w", done.rel, rollbackErr))
+				}
+			}
+			if len(rollbackErrors) > 0 {
+				return errors.Join(writeErr, fmt.Errorf("rollback incomplete: %w", errors.Join(rollbackErrors...)))
 			}
-			return fmt.Errorf("write %s: %w (earlier files restored)", target.rel, err)
+			return fmt.Errorf("%w (attempted files restored)", writeErr)
 		}
 	}
 	return nil