devrites 7.3.1 → 7.3.2

package/engine/internal/install/apply.go

@@ -16,6 +16,10 @@ import (
 )
 
 func (r *runner) install() error {
+	if err := r.openTargetRoot(); err != nil {
+		return err
+	}
+	defer r.closeTargetRoot()
 	fmt.Fprintln(r.opts.Stdout, "DevRites installer")
 	fmt.Fprintf(r.opts.Stdout, "  target : %s\n", r.target)
 	fmt.Fprintf(r.opts.Stdout, "  payload: %s\n", r.payload)
@@ -43,6 +47,10 @@ func (r *runner) install() error {
 	if err := r.preflightInstall(); err != nil {
 		return err
 	}
+	// Complete binary installation before changing payload ownership or version.
+	if err := r.installBinary(); err != nil {
+		return fmt.Errorf("install engine binary: %w", err)
+	}
 
 	for _, tree := range hostpack.InstallTrees(r.opts.WithSkills, r.opts.WithAgents, r.opts.WithCodex, r.opts.WithOmp, r.opts.WithPi, r.opts.WithDevin, r.opts.WithDsh) {
 		if err := r.installTree(tree.PayloadPrefix, tree.TargetPrefix); err != nil {
@@ -106,9 +114,6 @@ func (r *runner) install() error {
 			return fmt.Errorf("write manifest: %w", err)
 		}
 	}
-	if err := r.installBinary(); err != nil {
-		return fmt.Errorf("install engine binary: %w", err)
-	}
 
 	fmt.Fprintln(r.opts.Stdout)
 	if r.opts.DryRun {
@@ -218,19 +223,32 @@ func (r *runner) installData(data []byte, rel string) error {
 	return nil
 }
 
-// writeConfined writes dest, which must lie under the install target, through
-// a root opened on the target so a directory component replaced by a symlink
-// after the path recheck cannot redirect the write.
-func (r *runner) writeConfined(dest string, data []byte, perm fs.FileMode) error {
-	rel, err := filepath.Rel(r.target, dest)
+func (r *runner) readConfined(path string) ([]byte, error) {
+	rel, err := filepath.Rel(r.target, path)
 	if err != nil {
-		return err
+		return nil, err
+	}
+	if r.targetRoot != nil {
+		return r.targetRoot.ReadFile(rel)
 	}
 	root, err := os.OpenRoot(r.target)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	defer func() { _ = root.Close() }()
+	return root.ReadFile(rel)
+}
+
+// writeConfined uses the operation's validated root, not its mutable pathname.
+func (r *runner) writeConfined(dest string, data []byte, perm fs.FileMode) error {
+	rel, err := filepath.Rel(r.target, dest)
+	if err != nil {
+		return err
+	}
+	root := r.targetRoot
+	if root == nil {
+		return fmt.Errorf("install target is not open")
+	}
 	if info, err := root.Stat(rel); err == nil {
 		perm = info.Mode().Perm()
 	} else if !os.IsNotExist(err) {
@@ -239,18 +257,16 @@ func (r *runner) writeConfined(dest string, data []byte, perm fs.FileMode) error
 	return fsutil.WriteFileAtomicIn(root, rel, data, perm)
 }
 
-// removeConfined removes dest, which must lie under the install target,
-// through a root opened on the target.
+// removeConfined uses the same retained root as writes and managed reads.
 func (r *runner) removeConfined(dest string) error {
 	rel, err := filepath.Rel(r.target, dest)
 	if err != nil {
 		return err
 	}
-	root, err := os.OpenRoot(r.target)
-	if err != nil {
-		return err
+	root := r.targetRoot
+	if root == nil {
+		return fmt.Errorf("install target is not open")
 	}
-	defer func() { _ = root.Close() }()
 	return root.Remove(rel)
 }
 
@@ -285,11 +301,10 @@ func (r *runner) seedDevrites() error {
 		fmt.Fprintln(r.opts.Stdout, "  [seed] .devrites/ACTIVE (runtime state - preserved on uninstall)")
 		return nil
 	}
-	if err := os.MkdirAll(filepath.Dir(active), 0o755); err != nil {
+	if err := r.targetRoot.MkdirAll(".devrites", 0o755); err != nil {
 		return fmt.Errorf("create %s: %w", filepath.Dir(active), err)
 	}
-	// #nosec G304 -- active path is the operator-selected install dir (O_EXCL create)
-	f, err := os.OpenFile(active, os.O_CREATE|os.O_EXCL, 0o644)
+	f, err := r.targetRoot.OpenFile(filepath.Join(".devrites", "ACTIVE"), os.O_CREATE|os.O_EXCL, 0o644)
 	if err != nil {
 		if os.IsExist(err) {
 			return nil
@@ -342,7 +357,7 @@ func (r *runner) relinquishEditedHostConfigs() (map[string]bool, error) {
 func (r *runner) seedHostConfig(config hostpack.HostConfig) error {
 	if _, managed := r.prev[config.Rel]; !managed {
 		// #nosec G304 -- fixed host config path under the operator target
-		data, err := os.ReadFile(filepath.Join(r.target, filepath.FromSlash(config.Rel)))
+		data, err := r.readConfined(filepath.Join(r.target, filepath.FromSlash(config.Rel)))
 		if err == nil && string(data) != config.Content {
 			if !strings.Contains(string(data), config.Applied) {
 				fmt.Fprintf(r.opts.Stderr, "warning: %s exists and was not changed; to hide duplicate DevRites skills in %s, add: %s\n", config.Rel, config.Host, config.Advice)
@@ -408,7 +423,7 @@ func (r *runner) pruneDropped() error {
 			if err := r.removeConfined(dead); err != nil && !os.IsNotExist(err) {
 				return fmt.Errorf("remove %s: %w", rel, err)
 			}
-			pruneEmptyDirs(filepath.Dir(dead), r.target)
+			r.pruneEmptyDirs(filepath.Dir(dead))
 			fmt.Fprintf(r.opts.Stdout, "  [%s] %s\n", action, rel)
 		}
 		r.stats.pruned++

package/engine/internal/install/binary.go

@@ -63,11 +63,20 @@ func (r *runner) installBinary() error {
 	if err != nil {
 		return err
 	}
+	removeBackup := true
 	if backup != "" {
-		defer func() { _ = os.Remove(backup) }()
+		defer func() {
+			if removeBackup {
+				_ = os.Remove(backup)
+			}
+		}()
 	}
 	if err := fsutil.WriteFileAtomic(dest, data, 0o755); err != nil {
 		if restoreErr := restoreBinary(dest, backup, oldMode, hadOld); restoreErr != nil {
+			removeBackup = false
+			if backup != "" {
+				restoreErr = fmt.Errorf("%w (previous binary retained at %s)", restoreErr, backup)
+			}
 			return fmt.Errorf("install binary: %v; restore previous binary: %w", err, restoreErr)
 		}
 		return err
@@ -75,6 +84,10 @@ func (r *runner) installBinary() error {
 	_ = os.Chmod(dest, 0o755)
 	if _, err := verifyEngineBinary(dest, tag, 30*time.Second); err != nil {
 		if restoreErr := restoreBinary(dest, backup, oldMode, hadOld); restoreErr != nil {
+			removeBackup = false
+			if backup != "" {
+				restoreErr = fmt.Errorf("%w (previous binary retained at %s)", restoreErr, backup)
+			}
 			return fmt.Errorf("verify installed engine binary: %v; restore previous binary: %w", err, restoreErr)
 		}
 		if hadOld {
@@ -173,6 +186,44 @@ func (r *runner) acquireBinary(tag string) (string, func(), error) {
 	return path, func() {}, nil
 }
 
+func (r *runner) preflightBinaryRemoval() error {
+	if runtime.GOOS != "windows" || r.opts.DryRun || r.opts.KeepBinary || !r.opts.WithBinary || os.Getenv("DEVRITES_NO_BINARY") == "1" {
+		return nil
+	}
+	for _, path := range binaryCandidates() {
+		info, err := os.Lstat(path)
+		if os.IsNotExist(err) {
+			continue
+		}
+		if err != nil {
+			return fmt.Errorf("inspect engine binary %s: %w", path, err)
+		}
+		if info.Mode()&os.ModeSymlink != 0 {
+			info, err = os.Stat(path)
+			if os.IsNotExist(err) {
+				return nil
+			}
+			if err != nil {
+				return fmt.Errorf("inspect engine binary %s: %w", path, err)
+			}
+		}
+		executable, err := os.Executable()
+		if err != nil {
+			return fmt.Errorf("locate running engine binary: %w", err)
+		}
+		running, err := os.Stat(executable)
+		if err != nil {
+			return fmt.Errorf("inspect running engine binary %s: %w", executable, err)
+		}
+		if os.SameFile(info, running) {
+			return fmt.Errorf("cannot remove running engine binary %s on Windows; use npx devrites@latest uninstall --target %q or --keep-binary", path, r.target)
+		}
+		// Removal stops at the first existing candidate, even if another is running.
+		return nil
+	}
+	return nil
+}
+
 func (r *runner) removeBinary() error {
 	if r.opts.KeepBinary {
 		fmt.Fprintln(r.opts.Stdout, "  kept the global devrites-engine binary (--keep-binary).")
@@ -187,17 +238,24 @@ func (r *runner) removeBinary() error {
 		return nil
 	}
 	for _, p := range binaryCandidates() {
-		if p == "" || !exists(p) {
-			continue
-		}
 		if r.opts.DryRun {
+			if _, err := os.Lstat(p); err != nil {
+				if os.IsNotExist(err) {
+					continue
+				}
+				return fmt.Errorf("inspect engine binary %s: %w", p, err)
+			}
 			fmt.Fprintf(r.opts.Stdout, "  [remove] %s (global engine binary)\n", p)
 			continue
 		}
-		if err := os.Remove(p); err == nil {
-			fmt.Fprintf(r.opts.Stdout, "  [remove] %s\n", p)
-			return nil
+		if err := os.Remove(p); err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return fmt.Errorf("remove %s: %w", p, err)
 		}
+		fmt.Fprintf(r.opts.Stdout, "  [remove] %s\n", p)
+		return nil
 	}
 	return nil
 }
@@ -220,10 +278,10 @@ func engineBinaryName() string {
 }
 
 func binaryCandidates() []string {
-	candidates := []string{}
 	if dir := os.Getenv("DEVRITES_BIN_DIR"); dir != "" {
-		candidates = append(candidates, filepath.Join(dir, engineBinaryName()))
+		return []string{filepath.Join(dir, engineBinaryName())}
 	}
+	candidates := []string{}
 	home, _ := os.UserHomeDir()
 	if home != "" {
 		candidates = append(candidates, filepath.Join(home, ".local", "bin", engineBinaryName()))

package/engine/internal/install/install.go

@@ -61,6 +61,8 @@ type stats struct {
 type runner struct {
 	opts              Options
 	target            string
+	targetInfo        fs.FileInfo
+	targetRoot        *os.Root
 	payload           string
 	payloadFS         fs.FS
 	source            string
@@ -246,6 +248,10 @@ func Apply(opts Options) error {
 		return fmt.Errorf("prepare installer: %w", err)
 	}
 	if opts.Mode == ModeUninstall {
+		if err := r.openTargetRoot(); err != nil {
+			return err
+		}
+		defer r.closeTargetRoot()
 		return r.uninstall()
 	}
 	if err := r.install(); err != nil {
@@ -297,27 +303,75 @@ func newRunner(opts Options) (*runner, error) {
 		}
 	}
 	r := &runner{
-		opts:      opts,
-		target:    target,
-		payload:   payload,
-		payloadFS: os.DirFS(payload),
-		source:    source,
-		prev:      map[string]managedRecord{},
-		records:   map[string]string{},
-		preflight: map[string]pathSnapshot{},
+		opts:       opts,
+		target:     target,
+		targetInfo: info,
+		payload:    payload,
+		payloadFS:  os.DirFS(payload),
+		source:     source,
+		prev:       map[string]managedRecord{},
+		records:    map[string]string{},
+		preflight:  map[string]pathSnapshot{},
 	}
 	if opts.Mode != ModeUninstall {
 		if err := r.validatePayload(); err != nil {
 			return nil, fmt.Errorf("validate payload: %w", err)
 		}
 	}
-	r.prev, err = readManifest(filepath.Join(target, ManifestName))
+	if err := r.openTargetRoot(); err != nil {
+		return nil, err
+	}
+	defer r.closeTargetRoot()
+	data, err := r.readConfined(filepath.Join(target, ManifestName))
+	if err != nil && !os.IsNotExist(err) {
+		return nil, fmt.Errorf("read manifest %s: %w", ManifestName, err)
+	}
+	r.prev, _, err = parseManifestData(data)
 	if err != nil {
 		return nil, err
 	}
 	return r, nil
 }
 
+func (r *runner) openTargetRoot() error {
+	root, err := os.OpenRoot(r.target)
+	if err != nil {
+		return err
+	}
+	info, err := root.Stat(".")
+	if err != nil || r.targetInfo == nil || !os.SameFile(r.targetInfo, info) {
+		_ = root.Close()
+		return fmt.Errorf("install target changed before operation: %s", r.target)
+	}
+	r.targetRoot = root
+	return nil
+}
+
+func (r *runner) closeTargetRoot() {
+	if r.targetRoot != nil {
+		_ = r.targetRoot.Close()
+		r.targetRoot = nil
+	}
+}
+
+func (r *runner) checkTargetIdentity() error {
+	info, err := os.Stat(r.target)
+	if err != nil || r.targetInfo == nil || !os.SameFile(r.targetInfo, info) {
+		return fmt.Errorf("install target changed during operation: %s", r.target)
+	}
+	return nil
+}
+
+func (r *runner) pruneEmptyDirs(start string) {
+	for start != r.target && start != filepath.Dir(start) {
+		rel, err := filepath.Rel(r.target, start)
+		if err != nil || r.targetRoot == nil || r.targetRoot.Remove(rel) != nil {
+			return
+		}
+		start = filepath.Dir(start)
+	}
+}
+
 func inferSourceDir() string {
 	if v := os.Getenv("DEVRITES_SOURCE_DIR"); v != "" {
 		return v
@@ -390,18 +444,6 @@ func isGlobalTarget(target string) bool {
 	return false
 }
 
-func pruneEmptyDirs(start, stop string) {
-	for {
-		if start == stop || start == filepath.Dir(start) || start == string(os.PathSeparator) {
-			return
-		}
-		if err := os.Remove(start); err != nil {
-			return
-		}
-		start = filepath.Dir(start)
-	}
-}
-
 func exists(path string) bool {
 	// #nosec G703 -- existence probe on managed install paths
 	_, err := os.Lstat(path)

package/engine/internal/install/manifest.go

@@ -19,11 +19,6 @@ func readManifest(path string) (map[string]managedRecord, error) {
 	return records, err
 }
 
-func readManifestList(path string) ([]string, error) {
-	_, entries, err := parseManifest(path)
-	return entries, err
-}
-
 func parseManifest(path string) (map[string]managedRecord, []string, error) {
 	// #nosec G304 -- install manifest under the operator-selected target
 	data, err := os.ReadFile(path)
@@ -33,6 +28,10 @@ func parseManifest(path string) (map[string]managedRecord, []string, error) {
 		}
 		return nil, nil, fmt.Errorf("read manifest %s: %w", path, err)
 	}
+	return parseManifestData(data)
+}
+
+func parseManifestData(data []byte) (map[string]managedRecord, []string, error) {
 	hashes := map[string]string{}
 	var out []string
 	for _, line := range strings.Split(string(data), "\n") {

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 {