devrites 6.0.3 → 6.1.0

package/engine/internal/install/merge.go

@@ -8,21 +8,22 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"regexp"
+	"slices"
 	"sort"
 	"strings"
 
 	"github.com/devrites/devrites/internal/hostpack"
 )
 
-func (r *runner) installClaudeSettingsMarker(ownsDefaultMode bool, managed map[string]bool) error {
-	ownership := "preexisting"
-	if ownsDefaultMode {
-		ownership = "added"
-	}
+func (r *runner) installClaudeSettingsMarker(state claudeSettingsMerge) error {
 	var b strings.Builder
-	b.WriteString(hostpack.ClaudeSettingsMerge.MarkerText + "\ndefault-mode=" + ownership)
-	rules := make([]string, 0, len(managed))
-	for rule := range managed {
+	b.WriteString(hostpack.ClaudeSettingsMerge.MarkerText + "\n" + claudeRulesAddedLine)
+	if state.created {
+		b.WriteString("\n" + claudeSettingsCreatedLine)
+	}
+	rules := make([]string, 0, len(state.added))
+	for rule := range state.added {
 		rules = append(rules, rule)
 	}
 	sort.Strings(rules)
@@ -32,26 +33,55 @@ func (r *runner) installClaudeSettingsMarker(ownsDefaultMode bool, managed map[s
 	return r.installMarker(hostpack.ClaudeSettingsMerge.MarkerRel, b.String())
 }
 
-func (r *runner) claudeDefaultModeOwned() bool {
+const (
+	// claudeRulesAddedLine marks a settings marker whose rule: lines list only
+	// the rules DevRites added; older markers listed every payload rule.
+	claudeRulesAddedLine = "rules=added"
+	// claudeSettingsCreatedLine records that DevRites created settings.json,
+	// so uninstall removes it once nothing else is left.
+	claudeSettingsCreatedLine = "settings=created"
+)
+
+func (r *runner) claudeSettingsMarkerLines() []string {
 	data, err := os.ReadFile(filepath.Join(r.target, filepath.FromSlash(hostpack.ClaudeSettingsMerge.MarkerRel)))
-	return err == nil && strings.Contains(string(data), "\ndefault-mode=added\n")
+	if err != nil {
+		return nil
+	}
+	return strings.Split(strings.ReplaceAll(string(data), "\r\n", "\n"), "\n")
+}
+
+// claudeDefaultModeOwned reports a marker from an install that set
+// permissions.defaultMode=plan itself; DevRites no longer sets a mode, so
+// update and uninstall remove that plan mode.
+func (r *runner) claudeDefaultModeOwned() bool {
+	return slices.Contains(r.claudeSettingsMarkerLines(), "default-mode=added")
+}
+
+// claudeSettingsCreated reports whether DevRites created settings.json. A
+// legacy marker (no rules=added line) predates the settings=created record,
+// so its file is treated as created: uninstall still removes it only when
+// stripping leaves nothing.
+func (r *runner) claudeSettingsCreated() bool {
+	lines := r.claudeSettingsMarkerLines()
+	return slices.Contains(lines, claudeSettingsCreatedLine) || (lines != nil && !slices.Contains(lines, claudeRulesAddedLine))
 }
 
 // managedClaudePermissionRules returns the exact non-engine allow rules
-// DevRites manages in .claude/settings.json: rules recorded in the merge
-// marker by past installs, unioned with the current payload's non-engine
-// rules so newly added and retired grants both resolve correctly. Engine
-// command rules are matched by prefix and never need listing here.
+// DevRites manages in .claude/settings.json: the rules the merge marker
+// records as DevRites-added (none before the first install). A legacy marker
+// that predates added-only recording is unioned with the current payload's non-engine rules, as
+// before. Engine command rules are matched by prefix and never need listing.
 func (r *runner) managedClaudePermissionRules() map[string]bool {
 	managed := map[string]bool{}
-	data, err := os.ReadFile(filepath.Join(r.target, filepath.FromSlash(hostpack.ClaudeSettingsMerge.MarkerRel)))
-	if err == nil {
-		for _, line := range strings.Split(string(data), "\n") {
-			if rule, ok := strings.CutPrefix(line, "rule:"); ok {
-				managed[strings.TrimSpace(rule)] = true
-			}
+	lines := r.claudeSettingsMarkerLines()
+	for _, line := range lines {
+		if rule, ok := strings.CutPrefix(line, "rule:"); ok {
+			managed[strings.TrimSpace(rule)] = true
 		}
 	}
+	if lines == nil || slices.Contains(lines, claudeRulesAddedLine) {
+		return managed
+	}
 	payload, err := readJSONFS(r.payloadFS, hostpack.ClaudeSettingsMerge.PayloadRel)
 	if err == nil {
 		for rule := range managedRulesFromPayload(payload) {
@@ -79,50 +109,26 @@ func managedRulesFromPayload(payload map[string]any) map[string]bool {
 }
 
 func (r *runner) mergeMarkerFile(merge hostpack.MarkerMerge) error {
-	block, err := fs.ReadFile(r.payloadFS, merge.PayloadRel)
-	if err != nil {
-		return 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
-	if current, readErr := os.ReadFile(dest); readErr == nil {
-		if err := hostpack.ValidateMarkerBlocks(current, r.sharedMarkerMerges(merge)...); err != nil {
-			return fmt.Errorf("%w in %s; fix it and rerun", err, merge.TargetRel)
+	if !r.opts.DryRun {
+		if err := r.recheckPath(merge.TargetRel); err != nil {
+			return err
 		}
 	}
+	next, current, err := r.markerMergeNext(merge)
+	if err != nil {
+		return err
+	}
 	if r.opts.DryRun {
 		verb := "create DevRites block"
-		// #nosec G304 -- dest joins the operator target with a fixed manifest-relative record
-		current, readErr := os.ReadFile(dest)
-		if readErr == nil {
-			if _, mergeErr := hostpack.MergeMarkerBlock(current, block, merge.Begin, merge.End); mergeErr != nil {
-				return fmt.Errorf("%w in %s; fix it and rerun", mergeErr, merge.TargetRel)
-			}
+		if current != nil {
+			verb = "append DevRites block"
 			if bytes.Contains(current, []byte(merge.Begin)) {
 				verb = "refresh DevRites block"
-			} else {
-				verb = "append DevRites block"
 			}
-		} else if !errors.Is(readErr, fs.ErrNotExist) {
-			return fmt.Errorf("cannot read %s: %w", merge.TargetRel, readErr)
 		}
 		fmt.Fprintf(r.opts.Stdout, "  [merge] %s (%s)\n", merge.TargetRel, verb)
 	} else {
-		if err := r.recheckPath(merge.TargetRel); err != nil {
-			return err
-		}
-		next := block
-		// #nosec G304 -- dest joins the operator target with a fixed manifest-relative record
-		current, readErr := os.ReadFile(dest)
-		if readErr == nil {
-			var mergeErr error
-			next, mergeErr = hostpack.MergeMarkerBlock(current, block, merge.Begin, merge.End)
-			if mergeErr != nil {
-				return fmt.Errorf("%w in %s; fix it and rerun", mergeErr, merge.TargetRel)
-			}
-		} else if !errors.Is(readErr, fs.ErrNotExist) {
-			return fmt.Errorf("cannot read %s: %w", merge.TargetRel, readErr)
-		}
+		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)
 		}
@@ -135,6 +141,32 @@ func (r *runner) mergeMarkerFile(merge hostpack.MarkerMerge) error {
 	return r.installMarker(merge.MarkerRel, merge.MarkerText)
 }
 
+// markerMergeNext returns the merged target bytes and the current bytes
+// (nil when the target is absent) without writing anything.
+func (r *runner) markerMergeNext(merge hostpack.MarkerMerge) ([]byte, []byte, error) {
+	block, err := fs.ReadFile(r.payloadFS, merge.PayloadRel)
+	if err != nil {
+		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)
+	if errors.Is(readErr, fs.ErrNotExist) {
+		return block, nil, nil
+	}
+	if readErr != nil {
+		return nil, nil, fmt.Errorf("cannot read %s: %w", merge.TargetRel, readErr)
+	}
+	if err := hostpack.ValidateMarkerBlocks(current, r.sharedMarkerMerges(merge)...); err != nil {
+		return nil, nil, fmt.Errorf("%w in %s; fix it and rerun", err, merge.TargetRel)
+	}
+	next, err := hostpack.MergeMarkerBlock(current, block, merge.Begin, merge.End)
+	if err != nil {
+		return nil, nil, fmt.Errorf("%w in %s; fix it and rerun", err, merge.TargetRel)
+	}
+	return next, current, nil
+}
+
 func (r *runner) sharedMarkerMerges(merge hostpack.MarkerMerge) []hostpack.MarkerMerge {
 	merges := []hostpack.MarkerMerge{merge}
 	for _, other := range []struct {
@@ -154,71 +186,174 @@ func (r *runner) sharedMarkerMerges(merge hostpack.MarkerMerge) []hostpack.Marke
 
 func (r *runner) mergeCodexConfig() error {
 	merge := hostpack.CodexConfigMerge
-	block, err := fs.ReadFile(r.payloadFS, merge.PayloadRel)
-	if err != nil {
-		return fmt.Errorf("read payload %s: %w", merge.PayloadRel, err)
-	}
-	dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
 	if r.opts.DryRun {
-		// #nosec G304 -- dest joins the operator target with a fixed manifest-relative record
-		if data, readErr := os.ReadFile(dest); readErr == nil {
-			if _, stripErr := hostpack.StripCodexConfigBlocks(data); stripErr != nil {
-				return fmt.Errorf("%w in %s; fix it and rerun", stripErr, merge.TargetRel)
-			}
+		if _, err := r.codexConfigNext(); err != nil {
+			return err
 		}
-		fmt.Fprintf(r.opts.Stdout, "  [merge] %s (prepend DevRites permission block)\n", merge.TargetRel)
+		fmt.Fprintf(r.opts.Stdout, "  [merge] %s (insert DevRites permission block)\n", merge.TargetRel)
 		return r.installMarker(merge.MarkerRel, merge.MarkerText)
 	}
 	if err := r.recheckPath(merge.TargetRel); err != nil {
 		return err
 	}
+	next, err := r.codexConfigNext()
+	if 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)
+}
+
+// codexConfigNext returns the merged .codex/config.toml without writing it.
+// The DevRites block ends inside its [permissions.*] table, so it goes after
+// the user's top-level keys and before their first table header; anywhere
+// earlier would re-scope those keys into the DevRites table.
+func (r *runner) codexConfigNext() ([]byte, error) {
+	merge := hostpack.CodexConfigMerge
+	block, err := fs.ReadFile(r.payloadFS, merge.PayloadRel)
+	if err != nil {
+		return nil, fmt.Errorf("read payload %s: %w", merge.PayloadRel, err)
+	}
+	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 {
-		var stripErr error
-		if data, stripErr = hostpack.StripCodexConfigBlocks(data); stripErr != nil {
-			return fmt.Errorf("%w in %s; fix it and rerun", stripErr, merge.TargetRel)
+		// 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)
+		if current, err = hostpack.StripCodexConfigBlocks(data); err != nil {
+			return nil, fmt.Errorf("%w in %s; fix it and rerun", err, merge.TargetRel)
 		}
-		current = data
 		if hasTopLevelTOMLKey(current, "default_permissions") {
-			return fmt.Errorf("%s already sets top-level default_permissions; remove that project override before installing the DevRites read-only-root profile", merge.TargetRel)
+			return nil, fmt.Errorf("%s already sets top-level default_permissions; remove that project override before installing the DevRites read-only-root profile", merge.TargetRel)
 		}
 	} else if !errors.Is(readErr, fs.ErrNotExist) {
-		return fmt.Errorf("cannot read %s: %w", merge.TargetRel, readErr)
+		return nil, fmt.Errorf("cannot read %s: %w", merge.TargetRel, readErr)
 	}
-	next := append([]byte(nil), block...)
-	if len(next) == 0 || next[len(next)-1] != '\n' {
+	if len(bytes.TrimSpace(current)) == 0 {
+		current = nil
+	}
+	split := firstTOMLTableHeader(current)
+	var next []byte
+	if split > 0 {
+		next = append(next, current[:split]...)
+		if next[len(next)-1] != '\n' {
+			next = append(next, '\n')
+		}
+		// Blank separator; StripMarkerBlock removes it with the block.
 		next = append(next, '\n')
 	}
-	if len(bytes.TrimSpace(current)) > 0 {
+	next = append(next, block...)
+	if len(next) == 0 || next[len(next)-1] != '\n' {
 		next = append(next, '\n')
-		next = append(next, current...)
 	}
-	if err := r.writeConfined(dest, next, 0o644); err != nil {
-		return fmt.Errorf("cannot write %s: %w", merge.TargetRel, err)
+	return append(next, current[split:]...), nil
+}
+
+var utf8BOM = []byte("\xef\xbb\xbf")
+
+// firstTOMLTableHeader returns the byte offset of the first [table] or
+// [[array]] header line, or len(data) when there is none.
+func firstTOMLTableHeader(data []byte) int {
+	split := len(data)
+	scanTOMLTopLevel(data, func(offset int, line string) bool {
+		if tomlTableHeader.MatchString(line) {
+			split = offset
+			return false
+		}
+		return true
+	})
+	return split
+}
+
+// scanTOMLTopLevel calls visit with the byte offset and trimmed text of each
+// line that starts outside any multi-line string or array/inline-table value
+// (a leading UTF-8 BOM is ignored), until visit returns false. Only such lines
+// can hold a table header or a key.
+func scanTOMLTopLevel(data []byte, visit func(offset int, line string) bool) {
+	depth, inString, offset := 0, "", 0
+	for i, raw := range strings.SplitAfter(string(data), "\n") {
+		line := raw
+		if i == 0 {
+			line = strings.TrimPrefix(line, string(utf8BOM))
+		}
+		lineOffset := offset
+		offset += len(raw)
+		if depth == 0 && inString == "" {
+			trimmed := strings.TrimSpace(line)
+			if !visit(lineOffset, trimmed) {
+				return
+			}
+			if tomlTableHeader.MatchString(trimmed) {
+				continue
+			}
+		}
+		depth, inString = scanTOMLLine(line, depth, inString)
 	}
-	return r.installMarker(merge.MarkerRel, merge.MarkerText)
 }
 
+// scanTOMLLine carries the open [ / { depth and any open multi-line string
+// delimiter (""" or ”') across one line, skipping strings and comments.
+func scanTOMLLine(line string, depth int, inString string) (int, string) {
+	for i := 0; i < len(line); i++ {
+		if inString != "" {
+			if inString == `"""` && line[i] == '\\' {
+				i++
+			} else if strings.HasPrefix(line[i:], inString) {
+				i += 2
+				// Up to two extra quotes still belong to the content.
+				for i+1 < len(line) && line[i+1] == inString[0] {
+					i++
+				}
+				inString = ""
+			}
+			continue
+		}
+		switch c := line[i]; c {
+		case '#':
+			return depth, ""
+		case '[', '{':
+			depth++
+		case ']', '}':
+			if depth > 0 {
+				depth--
+			}
+		case '"', '\'':
+			if delim := strings.Repeat(string(c), 3); strings.HasPrefix(line[i:], delim) {
+				inString = delim
+				i += 2
+				continue
+			}
+			for i++; i < len(line) && line[i] != c; i++ {
+				if c == '"' && line[i] == '\\' {
+					i++
+				}
+			}
+		}
+	}
+	return depth, inString
+}
+
+// tomlTableHeader matches a trimmed [table] or [[array]] header line. Quoted
+// key parts may hold any character; a bare part stops at brackets, quotes,
+// '#', '=' and ',', so array and inline-table value lines never match.
+var tomlTableHeader = regexp.MustCompile(`^\[\[?(?:[^\[\]"'#=,]|"(?:[^"\\]|\\.)*"|'[^']*')+\]\]?\s*(#.*)?$`)
+
 func (r *runner) mergeClaudeSettings(merge hostpack.JSONMerge) error {
 	dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
-	devrites, err := readJSONFS(r.payloadFS, merge.PayloadRel)
-	if err != nil {
-		return fmt.Errorf("load Claude settings payload: %w", err)
-	}
-	current := map[string]any{}
-	if data, readErr := readJSON(dest); readErr == nil {
-		current = data
-	} else if !errors.Is(readErr, fs.ErrNotExist) {
-		return fmt.Errorf("load existing Claude settings: %w", readErr)
-	}
-	next, ownsDefaultMode, err := mergeClaudeSettingsConfig(current, devrites, r.claudeDefaultModeOwned(), r.managedClaudePermissionRules())
+	next, state, err := r.claudeSettingsNext()
 	if err != nil {
 		return err
 	}
+	if permissions, _ := next["permissions"].(map[string]any); permissions["defaultMode"] == "plan" {
+		fmt.Fprintf(r.opts.Stderr, "warning: %s: permissions.defaultMode is plan, which blocks the root's .devrites writes every rite needs (ADR-0035); remove it to run the lifecycle\n", merge.TargetRel)
+	}
 	if r.opts.DryRun {
 		fmt.Fprintf(r.opts.Stdout, "  [merge] %s\n", merge.DryRunText)
-		return r.installClaudeSettingsMarker(ownsDefaultMode, managedRulesFromPayload(devrites))
+		return r.installClaudeSettingsMarker(state)
 	}
 	if err := r.recheckPath(merge.TargetRel); err != nil {
 		return err
@@ -231,7 +366,39 @@ func (r *runner) mergeClaudeSettings(merge hostpack.JSONMerge) error {
 	if err := r.writeConfined(dest, data, 0o644); err != nil {
 		return fmt.Errorf("cannot write %s: %w", merge.TargetRel, err)
 	}
-	return r.installClaudeSettingsMarker(ownsDefaultMode, managedRulesFromPayload(devrites))
+	return r.installClaudeSettingsMarker(state)
+}
+
+// claudeSettingsMerge is what the settings marker records about a merge.
+type claudeSettingsMerge struct {
+	created bool
+	added   map[string]bool
+}
+
+// claudeSettingsNext returns the merged .claude/settings.json without
+// writing it.
+func (r *runner) claudeSettingsNext() (map[string]any, claudeSettingsMerge, error) {
+	merge := hostpack.ClaudeSettingsMerge
+	dest := filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))
+	devrites, err := readJSONFS(r.payloadFS, merge.PayloadRel)
+	if err != nil {
+		return nil, claudeSettingsMerge{}, fmt.Errorf("load Claude settings payload: %w", err)
+	}
+	current := map[string]any{}
+	state := claudeSettingsMerge{created: r.claudeSettingsCreated()}
+	if data, readErr := readJSON(dest); readErr == nil {
+		current = data
+	} else if errors.Is(readErr, fs.ErrNotExist) {
+		state.created = true
+	} else {
+		return nil, claudeSettingsMerge{}, fmt.Errorf("load existing Claude settings: %w", readErr)
+	}
+	next, added, err := mergeClaudeSettingsConfig(current, devrites, r.claudeDefaultModeOwned(), r.managedClaudePermissionRules())
+	if err != nil {
+		return nil, claudeSettingsMerge{}, err
+	}
+	state.added = added
+	return next, state, nil
 }
 
 func (r *runner) seedClaudeSettings() error {
@@ -264,7 +431,7 @@ func stripHooksWith(path string, write func([]byte) error, remove func() error)
 	return write(data)
 }
 
-func (r *runner) stripClaudeSettings(path string, preserveEmpty bool) error {
+func (r *runner) stripClaudeSettings(path string) error {
 	current, err := readJSON(path)
 	if err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
@@ -273,7 +440,7 @@ func (r *runner) stripClaudeSettings(path string, preserveEmpty bool) error {
 		return fmt.Errorf("load Claude settings: %w", err)
 	}
 	next := stripDevritesSettings(current, r.claudeDefaultModeOwned(), r.managedClaudePermissionRules())
-	if len(next) == 0 && !preserveEmpty {
+	if len(next) == 0 && r.claudeSettingsCreated() {
 		return r.removeConfined(path)
 	}
 	data, err := json.MarshalIndent(next, "", "  ")
@@ -310,20 +477,20 @@ func stripMarkerWith(path, begin, end string, write func([]byte) error, remove f
 }
 
 func hasTopLevelTOMLKey(data []byte, key string) bool {
-	for _, line := range strings.Split(string(data), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		if strings.HasPrefix(line, "[") {
+	found := false
+	scanTOMLTopLevel(data, func(_ int, line string) bool {
+		if tomlTableHeader.MatchString(line) {
 			return false
 		}
 		name, _, ok := strings.Cut(line, "=")
-		if ok && strings.TrimSpace(name) == key {
-			return true
+		name = strings.TrimSpace(name)
+		if len(name) >= 2 && (name[0] == '"' || name[0] == '\'') && name[len(name)-1] == name[0] {
+			name = name[1 : len(name)-1]
 		}
-	}
-	return false
+		found = ok && name == key
+		return !found
+	})
+	return found
 }
 
 func readJSON(path string) (map[string]any, error) {
@@ -374,7 +541,7 @@ func isDevritesHooksComment(comment string) bool {
 
 func isDevritesSettingsComment(comment string) bool {
 	return isDevritesHooksComment(comment) ||
-		strings.HasPrefix(comment, "DevRites keeps the root orchestration context source-read-only.")
+		strings.HasPrefix(comment, "DevRites keeps the root orchestration context source-read-only")
 }
 
 func stripDevritesHooks(config map[string]any) map[string]any {
@@ -493,41 +660,35 @@ func stripDevritesSettings(config map[string]any, removeOwnedDefaultMode bool, m
 	return next
 }
 
-func mergeClaudeSettingsConfig(current, desired map[string]any, defaultModeOwned bool, managed map[string]bool) (map[string]any, bool, error) {
-	desiredPermissions, ok := desired["permissions"].(map[string]any)
-	if !ok || desiredPermissions["defaultMode"] != "plan" {
-		return nil, false, fmt.Errorf("DevRites Claude settings payload must declare permissions.defaultMode=plan")
-	}
+// mergeClaudeSettingsConfig also returns the non-engine payload rules the
+// merge added, i.e. those the user did not already grant themselves. It never
+// sets permissions.defaultMode; removeOwnedPlan drops a plan mode an older
+// DevRites install wrote.
+func mergeClaudeSettingsConfig(current, desired map[string]any, removeOwnedPlan bool, managed map[string]bool) (map[string]any, map[string]bool, error) {
+	desiredPermissions, _ := desired["permissions"].(map[string]any)
 	desiredAllow, ok := desiredPermissions["allow"].([]any)
 	if !ok {
-		return nil, false, fmt.Errorf("DevRites Claude settings payload permissions.allow must be an array")
+		return nil, nil, fmt.Errorf("DevRites Claude settings payload permissions.allow must be an array")
 	}
 
-	next := stripDevritesSettings(current, false, managed)
+	next := stripDevritesSettings(current, removeOwnedPlan, managed)
 	permissions := map[string]any{}
 	if raw, exists := next["permissions"]; exists {
 		var ok bool
 		permissions, ok = raw.(map[string]any)
 		if !ok {
-			return nil, false, fmt.Errorf("existing Claude permissions must be a JSON object")
+			return nil, nil, fmt.Errorf("existing Claude permissions must be a JSON object")
 		}
 	}
 
-	switch mode, exists := permissions["defaultMode"]; {
-	case !exists:
-		defaultModeOwned = true
-	case mode == "plan":
-	case mode != "plan":
-		return nil, false, fmt.Errorf("existing Claude permissions.defaultMode is %q; DevRites requires plan mode for the read-only root orchestrator", mode)
-	}
-	permissions["defaultMode"] = "plan"
 	var allow []any
 	if existingAllow, exists := permissions["allow"]; exists {
 		allow, ok = existingAllow.([]any)
 		if !ok {
-			return nil, false, fmt.Errorf("existing Claude permissions.allow must be an array")
+			return nil, nil, fmt.Errorf("existing Claude permissions.allow must be an array")
 		}
 	}
+	added := map[string]bool{}
 	seen := map[string]bool{}
 	for _, rule := range allow {
 		if value, ok := rule.(string); ok {
@@ -537,11 +698,14 @@ func mergeClaudeSettingsConfig(current, desired map[string]any, defaultModeOwned
 	for _, rule := range desiredAllow {
 		value, ok := rule.(string)
 		if !ok {
-			return nil, false, fmt.Errorf("DevRites Claude permission rules must be strings")
+			return nil, nil, fmt.Errorf("DevRites Claude permission rules must be strings")
 		}
 		if !seen[value] {
 			allow = append(allow, value)
 			seen[value] = true
+			if !strings.HasPrefix(value, "Bash(devrites-engine ") {
+				added[value] = true
+			}
 		}
 	}
 	permissions["allow"] = allow
@@ -551,7 +715,7 @@ func mergeClaudeSettingsConfig(current, desired map[string]any, defaultModeOwned
 			next["$comment"] = comment
 		}
 	}
-	return next, defaultModeOwned, nil
+	return next, added, nil
 }
 
 // isDevritesPermissionRule reports whether a permissions.allow rule is