devrites 3.2.27 → 4.0.0

package/engine/internal/gate/readiness_binding.go

@@ -0,0 +1,203 @@
+package gate
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"hash"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/markdowntext"
+	"github.com/devrites/devrites/internal/state"
+)
+
+const (
+	readinessBindingLabel         = "Readiness inputs SHA-256: "
+	readinessBindingDomain        = "devrites-readiness-inputs"
+	readinessBindingVersion       = "1"
+	maxReadinessInputBytes  int64 = 1 << 20
+	maxReadinessTotalBytes  int64 = 8 << 20
+)
+
+type readinessInput struct {
+	logical  string
+	required bool
+}
+
+var readinessInputs = [...]readinessInput{
+	{logical: "spec.md", required: true},
+	{logical: "decision-coverage.md", required: true},
+	{logical: "architecture.md", required: true},
+	{logical: "plan.md", required: true},
+	{logical: "tasks.md", required: true},
+	{logical: "traceability.md", required: true},
+	{logical: "test-plan.md", required: true},
+	{logical: "strategy.md"},
+	{logical: "design-brief.md"},
+	{logical: "ai-spec.md"},
+	{logical: ".devrites/principles.md"},
+}
+
+// ReadinessBinding returns the exact line Vet records in eng-review.md.
+func ReadinessBinding(root, slug string) (string, error) {
+	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return "", errors.New("readiness inputs: feature workspace is unavailable")
+	}
+
+	digest := sha256.New()
+	writeReadinessField(digest, readinessBindingDomain)
+	writeReadinessField(digest, readinessBindingVersion)
+	writeReadinessField(digest, fmt.Sprintf("%d", len(readinessInputs)))
+	var total int64
+	for _, input := range readinessInputs {
+		path := filepath.Join(workspace, filepath.FromSlash(input.logical))
+		if input.logical == ".devrites/principles.md" {
+			path = filepath.Join(root, "principles.md")
+		}
+		content, present, err := readReadinessInput(path, input.logical, input.required)
+		if err != nil {
+			return "", err
+		}
+		total += int64(len(content))
+		if total > maxReadinessTotalBytes {
+			return "", fmt.Errorf("readiness input %s exceeds the 8 MiB aggregate limit", input.logical)
+		}
+
+		writeReadinessField(digest, input.logical)
+		if present {
+			writeReadinessField(digest, "present")
+		} else {
+			writeReadinessField(digest, "absent")
+		}
+		writeReadinessLength(digest, uint64(len(content)))
+		_, _ = digest.Write(content)
+	}
+
+	return readinessBindingLabel + hex.EncodeToString(digest.Sum(nil)), nil
+}
+
+func verifyReadinessBinding(root, slug string) (string, error) {
+	expected, err := ReadinessBinding(root, slug)
+	if err != nil {
+		return "", err
+	}
+	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return "", errors.New("readiness input eng-review.md cannot be inspected")
+	}
+	content, _, err := readReadinessInput(filepath.Join(workspace, "eng-review.md"), "eng-review.md", true)
+	if err != nil {
+		return expected, err
+	}
+	structural, err := markdowntext.Structural(content)
+	if err != nil {
+		return expected, errors.New("readiness input eng-review.md is invalid Markdown")
+	}
+
+	attempts := 0
+	matches := 0
+	for _, raw := range strings.Split(string(structural), "\n") {
+		line := strings.TrimSuffix(raw, "\r")
+		if !strings.Contains(line, readinessBindingLabel) {
+			continue
+		}
+		attempts++
+		if line == expected {
+			matches++
+		}
+	}
+	if attempts != 1 || matches != 1 {
+		return expected, errors.New("eng-review.md does not contain exactly one current standalone readiness binding")
+	}
+	return expected, nil
+}
+
+func phaseRequiresReadinessBinding(phase state.Phase) bool {
+	for _, name := range state.RequiredWorkspaceFiles(phase) {
+		if name == "eng-review.md" {
+			return true
+		}
+	}
+	return false
+}
+
+func readReadinessInput(path, logical string, required bool) ([]byte, bool, error) {
+	before, err := os.Lstat(path)
+	if errors.Is(err, os.ErrNotExist) {
+		if required {
+			return nil, false, fmt.Errorf("readiness input %s is missing", logical)
+		}
+		return nil, false, nil
+	}
+	if err != nil {
+		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
+	}
+	if before.Mode()&os.ModeSymlink != 0 {
+		return nil, false, fmt.Errorf("readiness input %s is a symlink", logical)
+	}
+	if !before.Mode().IsRegular() {
+		return nil, false, fmt.Errorf("readiness input %s is not a regular file", logical)
+	}
+	if before.Size() < 0 || before.Size() > maxReadinessInputBytes {
+		return nil, false, fmt.Errorf("readiness input %s exceeds the 1 MiB limit", logical)
+	}
+
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, false, fmt.Errorf("readiness input %s cannot be opened", logical)
+	}
+	defer file.Close()
+	opened, err := file.Stat()
+	if err != nil {
+		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
+	}
+	if !opened.Mode().IsRegular() || opened.Size() != before.Size() || !os.SameFile(before, opened) {
+		return nil, false, fmt.Errorf("readiness input %s changed type while opening", logical)
+	}
+	content, err := io.ReadAll(io.LimitReader(file, maxReadinessInputBytes+1))
+	if err != nil {
+		return nil, false, fmt.Errorf("readiness input %s cannot be read", logical)
+	}
+	if int64(len(content)) > maxReadinessInputBytes {
+		return nil, false, fmt.Errorf("readiness input %s exceeds the 1 MiB limit", logical)
+	}
+	after, err := file.Stat()
+	if err != nil {
+		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
+	}
+	current, err := os.Lstat(path)
+	if err != nil {
+		return nil, false, fmt.Errorf("readiness input %s cannot be inspected", logical)
+	}
+	if current.Mode()&os.ModeSymlink != 0 ||
+		!current.Mode().IsRegular() ||
+		!after.Mode().IsRegular() ||
+		after.Size() != opened.Size() ||
+		after.Size() != int64(len(content)) ||
+		!os.SameFile(opened, after) ||
+		!os.SameFile(opened, current) {
+		return nil, false, fmt.Errorf("readiness input %s changed size or type while reading", logical)
+	}
+	if _, err := markdowntext.Structural(content); err != nil {
+		return nil, false, fmt.Errorf("readiness input %s is invalid Markdown", logical)
+	}
+	return content, true, nil
+}
+
+func writeReadinessField(digest hash.Hash, value string) {
+	writeReadinessLength(digest, uint64(len(value)))
+	_, _ = digest.Write([]byte(value))
+}
+
+func writeReadinessLength(digest hash.Hash, value uint64) {
+	var encoded [8]byte
+	binary.BigEndian.PutUint64(encoded[:], value)
+	_, _ = digest.Write(encoded[:])
+}

package/engine/internal/gate/readiness_binding_test.go

@@ -0,0 +1,271 @@
+package gate
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/devrites/devrites/internal/reason"
+	"github.com/devrites/devrites/internal/testutil"
+)
+
+func TestReadinessBindingBindsOnlyStableBuildInputs(t *testing.T) {
+	project := t.TempDir()
+	root := filepath.Join(project, ".devrites")
+	workspace := writeReadinessFixture(t, root, "stable", "build")
+	baseline := mustReadinessBinding(t, root, "stable")
+
+	planPath := filepath.Join(workspace, "plan.md")
+	info, err := os.Stat(planPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chtimes(planPath, info.ModTime().AddDate(0, 0, 1), info.ModTime().AddDate(0, 0, 1)); err != nil {
+		t.Fatal(err)
+	}
+	if got := mustReadinessBinding(t, root, "stable"); got != baseline {
+		t.Fatalf("mtime-only change altered binding: got %q want %q", got, baseline)
+	}
+
+	for _, name := range []string{"spec.md", "decision-coverage.md", "architecture.md", "plan.md", "tasks.md", "traceability.md", "test-plan.md"} {
+		path := filepath.Join(workspace, name)
+		body, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		testutil.WriteFile(t, path, string(body)+"changed\n")
+		if got := mustReadinessBinding(t, root, "stable"); got == baseline {
+			t.Fatalf("content change to %s did not alter binding", name)
+		}
+		testutil.WriteFile(t, path, string(body))
+	}
+
+	for _, name := range []string{"strategy.md", "design-brief.md", "ai-spec.md"} {
+		path := filepath.Join(workspace, name)
+		testutil.WriteFile(t, path, "# Optional\n\nPresent.\n")
+		present := mustReadinessBinding(t, root, "stable")
+		if present == baseline {
+			t.Fatalf("adding optional %s did not alter binding", name)
+		}
+		testutil.WriteFile(t, path, "# Optional\n\nChanged.\n")
+		if got := mustReadinessBinding(t, root, "stable"); got == present {
+			t.Fatalf("content change to optional %s did not alter binding", name)
+		}
+		if err := os.Remove(path); err != nil {
+			t.Fatal(err)
+		}
+		if got := mustReadinessBinding(t, root, "stable"); got != baseline {
+			t.Fatalf("removing optional %s did not restore binding", name)
+		}
+	}
+
+	principles := filepath.Join(root, "principles.md")
+	testutil.WriteFile(t, principles, "# Principles\n\nKeep proof deterministic.\n")
+	presentPrinciples := mustReadinessBinding(t, root, "stable")
+	if presentPrinciples == baseline {
+		t.Fatal("adding .devrites/principles.md did not alter binding")
+	}
+	testutil.WriteFile(t, principles, "# Principles\n\nChanged.\n")
+	if got := mustReadinessBinding(t, root, "stable"); got == presentPrinciples {
+		t.Fatal("content change to .devrites/principles.md did not alter binding")
+	}
+	if err := os.Remove(principles); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, name := range []string{"state.md", "questions.md", "decisions.md", "assumptions.md", "eng-review.md", "evidence.md", "review.md", "seal.md", "handoff.md", "ambient.md"} {
+		testutil.WriteFile(t, filepath.Join(workspace, name), "# Mutable\n\nChanged outside the stable contract.\n")
+		if got := mustReadinessBinding(t, root, "stable"); got != baseline {
+			t.Fatalf("excluded %s altered binding", name)
+		}
+	}
+	testutil.WriteFile(t, filepath.Join(project, ".git", "index"), "ambient git state\n")
+	if got := mustReadinessBinding(t, root, "stable"); got != baseline {
+		t.Fatal("ambient Git state altered binding")
+	}
+}
+
+func TestReadinessBindingGoldenDigest(t *testing.T) {
+	root := t.TempDir()
+	writeReadinessFixture(t, root, "golden", "build")
+	const want = "Readiness inputs SHA-256: d84b9050bd8db742c6a379a966bd7457cde04a69d6811130817729776d976ebe"
+	if got := mustReadinessBinding(t, root, "golden"); got != want {
+		t.Fatalf("ReadinessBinding()=%q, want %q", got, want)
+	}
+}
+
+func TestReadinessBindingRejectsUnsafeInputsWithoutDisclosure(t *testing.T) {
+	tests := []struct {
+		name   string
+		mutate func(*testing.T, string)
+	}{
+		{name: "missing required", mutate: func(t *testing.T, workspace string) {
+			if err := os.Remove(filepath.Join(workspace, "spec.md")); err != nil {
+				t.Fatal(err)
+			}
+		}},
+		{name: "symlink", mutate: func(t *testing.T, workspace string) {
+			path := filepath.Join(workspace, "plan.md")
+			if err := os.Remove(path); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Symlink("spec.md", path); err != nil {
+				t.Fatal(err)
+			}
+		}},
+		{name: "directory", mutate: func(t *testing.T, workspace string) {
+			path := filepath.Join(workspace, "tasks.md")
+			if err := os.Remove(path); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Mkdir(path, 0o755); err != nil {
+				t.Fatal(err)
+			}
+		}},
+		{name: "malformed utf8", mutate: func(t *testing.T, workspace string) {
+			if err := os.WriteFile(filepath.Join(workspace, "architecture.md"), []byte{0xff, 0xfe}, 0o644); err != nil {
+				t.Fatal(err)
+			}
+		}},
+		{name: "nul", mutate: func(t *testing.T, workspace string) {
+			if err := os.WriteFile(filepath.Join(workspace, "traceability.md"), []byte("secret-token\x00hidden"), 0o644); err != nil {
+				t.Fatal(err)
+			}
+		}},
+		{name: "per input limit", mutate: func(t *testing.T, workspace string) {
+			if err := os.WriteFile(filepath.Join(workspace, "test-plan.md"), bytes.Repeat([]byte("a"), int(maxReadinessInputBytes)+1), 0o644); err != nil {
+				t.Fatal(err)
+			}
+		}},
+		{name: "aggregate limit", mutate: func(t *testing.T, workspace string) {
+			content := bytes.Repeat([]byte("a"), int(maxReadinessInputBytes))
+			for _, name := range []string{"spec.md", "decision-coverage.md", "architecture.md", "plan.md", "tasks.md", "traceability.md", "test-plan.md", "strategy.md", "design-brief.md"} {
+				if err := os.WriteFile(filepath.Join(workspace, name), content, 0o644); err != nil {
+					t.Fatal(err)
+				}
+			}
+		}},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			root := t.TempDir()
+			workspace := writeReadinessFixture(t, root, "unsafe", "build")
+			test.mutate(t, workspace)
+			if _, err := ReadinessBinding(root, "unsafe"); err == nil {
+				t.Fatal("ReadinessBinding() should reject unsafe input")
+			} else if strings.Contains(err.Error(), workspace) || strings.Contains(err.Error(), "secret-token") {
+				t.Fatalf("error disclosed physical path or content: %q", err)
+			}
+		})
+	}
+}
+
+func TestVerifyReadinessBindingRequiresOneStructuralStandaloneLine(t *testing.T) {
+	root := t.TempDir()
+	workspace := writeReadinessFixture(t, root, "markers", "build")
+	expected := mustReadinessBinding(t, root, "markers")
+	tests := []struct {
+		name    string
+		content string
+		wantErr bool
+	}{
+		{name: "exact", content: "# Engineering review\n\n" + expected + "\n"},
+		{name: "exact plus fenced example", content: expected + "\n```text\n" + expected + "\n```\n"},
+		{name: "missing", content: "# Engineering review\n\nREADY\n", wantErr: true},
+		{name: "malformed", content: readinessBindingLabel + strings.Repeat("a", 63) + "\n", wantErr: true},
+		{name: "duplicate", content: expected + "\n" + expected + "\n", wantErr: true},
+		{name: "fenced only", content: "```text\n" + expected + "\n```\n", wantErr: true},
+		{name: "mismatch", content: readinessBindingLabel + strings.Repeat("0", 64) + "\n", wantErr: true},
+		{name: "not standalone", content: " " + expected + "\n", wantErr: true},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			testutil.WriteFile(t, filepath.Join(workspace, "eng-review.md"), test.content)
+			got, err := verifyReadinessBinding(root, "markers")
+			if (err != nil) != test.wantErr {
+				t.Fatalf("verifyReadinessBinding() error=%v, wantErr=%v", err, test.wantErr)
+			}
+			if got != expected {
+				t.Fatalf("expected line=%q, want %q", got, expected)
+			}
+		})
+	}
+}
+
+func TestCheckUsesReadinessBindingForBuildAndSeal(t *testing.T) {
+	for _, phase := range []string{"build", "seal"} {
+		t.Run(phase, func(t *testing.T) {
+			root := t.TempDir()
+			workspace := writeReadinessFixture(t, root, phase, phase)
+			if phase == "seal" {
+				for _, name := range []string{"evidence.md", "touched-files.md", "review.md", "seal.md"} {
+					testutil.WriteFile(t, filepath.Join(workspace, name), "# Final\n\nPresent.\n")
+				}
+			}
+			binding := mustReadinessBinding(t, root, phase)
+			testutil.AppendFile(t, filepath.Join(workspace, "eng-review.md"), "\n"+binding+"\n")
+
+			kind := Readiness
+			if phase == "seal" {
+				kind = Seal
+			}
+			result, err := Check(kind, root, phase)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if result.Blocked {
+				t.Fatalf("initial Check() blocked=true: %s", result.Render())
+			}
+
+			testutil.WriteFile(t, filepath.Join(workspace, "plan.md"), "# Plan\n\nChanged after Vet.\n")
+			expected := mustReadinessBinding(t, root, phase)
+			result, err = Check(kind, root, phase)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !result.Blocked || result.ReasonID != reason.GateReadinessStale {
+				t.Fatalf("stale Check() blocked=%v reason=%q", result.Blocked, result.ReasonID)
+			}
+			rendered := result.Render()
+			if !strings.Contains(rendered, "rerun /rite-vet") || !strings.Contains(rendered, expected) {
+				t.Fatalf("stale output lacks recovery or expected binding:\n%s", rendered)
+			}
+		})
+	}
+}
+
+func writeReadinessFixture(t *testing.T, root, slug, phase string) string {
+	t.Helper()
+	workspace := filepath.Join(root, "work", slug)
+	for name, body := range map[string]string{
+		"state.md":             "| phase | " + phase + " |\n",
+		"brief.md":             "# Brief\n\nReady.\n",
+		"spec.md":              "# Spec\n\nReady.\n",
+		"decisions.md":         "# Decisions\n\nNone.\n",
+		"assumptions.md":       "# Assumptions\n\nNone.\n",
+		"questions.md":         "# Questions\n\nNone.\n",
+		"decision-coverage.md": "# Decision coverage\n\nCLEAR\n",
+		"architecture.md":      "# Architecture\n\nReady.\n",
+		"plan.md":              "# Plan\n\nReady.\n",
+		"tasks.md":             "# Tasks\n\nReady.\n",
+		"traceability.md":      "# Traceability\n\nReady.\n",
+		"eng-review.md":        "# Engineering review\n\nREADY\n",
+		"test-plan.md":         "# Test plan\n\nReady.\n",
+	} {
+		testutil.WriteFile(t, filepath.Join(workspace, name), body)
+	}
+	return workspace
+}
+
+func mustReadinessBinding(t *testing.T, root, slug string) string {
+	t.Helper()
+	binding, err := ReadinessBinding(root, slug)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return binding
+}

package/engine/internal/gitenv/env.go

@@ -0,0 +1,46 @@
+package gitenv
+
+import "strings"
+
+var targetingVariables = map[string]struct{}{
+	"GIT_DIR":                          {},
+	"GIT_WORK_TREE":                    {},
+	"GIT_INDEX_FILE":                   {},
+	"GIT_COMMON_DIR":                   {},
+	"GIT_OBJECT_DIRECTORY":             {},
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES": {},
+	"GIT_QUARANTINE_PATH":              {},
+	"GIT_PREFIX":                       {},
+	"GIT_NAMESPACE":                    {},
+	"GIT_CONFIG_PARAMETERS":            {},
+	"GIT_CONFIG_COUNT":                 {},
+	"GIT_CONFIG_SYSTEM":                {},
+	"GIT_CONFIG_GLOBAL":                {},
+	"GIT_CONFIG_NOSYSTEM":              {},
+	"GIT_CEILING_DIRECTORIES":          {},
+	"GIT_DISCOVERY_ACROSS_FILESYSTEM":  {},
+	"GIT_GRAFT_FILE":                   {},
+	"GIT_SHALLOW_FILE":                 {},
+	"GIT_REPLACE_REF_BASE":             {},
+	"GIT_EXEC_PATH":                    {},
+	"GIT_LITERAL_PATHSPECS":            {},
+	"GIT_GLOB_PATHSPECS":               {},
+	"GIT_NOGLOB_PATHSPECS":             {},
+	"GIT_ICASE_PATHSPECS":              {},
+	"GIT_REFERENCE_BACKEND":            {},
+}
+
+func Sanitize(environ []string) []string {
+	sanitized := make([]string, 0, len(environ))
+	for _, entry := range environ {
+		key, _, _ := strings.Cut(entry, "=")
+		key = strings.ToUpper(key)
+		if _, blocked := targetingVariables[key]; blocked ||
+			strings.HasPrefix(key, "GIT_CONFIG_KEY_") ||
+			strings.HasPrefix(key, "GIT_CONFIG_VALUE_") {
+			continue
+		}
+		sanitized = append(sanitized, entry)
+	}
+	return sanitized
+}

package/engine/internal/gitenv/env_test.go

@@ -0,0 +1,48 @@
+package gitenv
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSanitizeRemovesGitTargetingVariables(t *testing.T) {
+	blocked := []string{
+		"GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR",
+		"GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_QUARANTINE_PATH",
+		"GIT_PREFIX", "GIT_NAMESPACE", "GIT_CONFIG_PARAMETERS", "GIT_CONFIG_COUNT",
+		"GIT_CONFIG_SYSTEM", "GIT_CONFIG_GLOBAL", "GIT_CONFIG_NOSYSTEM",
+		"GIT_CEILING_DIRECTORIES", "GIT_DISCOVERY_ACROSS_FILESYSTEM", "GIT_GRAFT_FILE",
+		"GIT_SHALLOW_FILE", "GIT_REPLACE_REF_BASE", "GIT_EXEC_PATH", "GIT_LITERAL_PATHSPECS",
+		"GIT_GLOB_PATHSPECS", "GIT_NOGLOB_PATHSPECS", "GIT_ICASE_PATHSPECS",
+		"GIT_REFERENCE_BACKEND",
+	}
+	environ := []string{"PATH=/bin", "GIT_AUTHOR_NAME=DevRites Test", "git_custom_keep=retained"}
+	for _, key := range blocked {
+		environ = append(environ, key+"=poison")
+	}
+	environ = append(environ,
+		"Git_Config_Key_12=core.worktree",
+		"git_config_value_12=/poison",
+		"git_dir=/case-insensitive-poison",
+	)
+	original := append([]string(nil), environ...)
+
+	got := Sanitize(environ)
+	want := []string{"PATH=/bin", "GIT_AUTHOR_NAME=DevRites Test", "git_custom_keep=retained"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("Sanitize() = %q, want %q", got, want)
+	}
+	if !reflect.DeepEqual(environ, original) {
+		t.Fatalf("Sanitize mutated input: got %q, want %q", environ, original)
+	}
+	got[0] = "PATH=/changed"
+	if environ[0] != "PATH=/bin" {
+		t.Fatal("Sanitize returned storage backed by the input slice")
+	}
+}
+
+func TestSanitizeNilReturnsNewEmptySlice(t *testing.T) {
+	if got := Sanitize(nil); got == nil || len(got) != 0 {
+		t.Fatalf("Sanitize(nil) = %#v, want a new empty slice", got)
+	}
+}

package/engine/internal/hostpack/hostpack.go

@@ -80,16 +80,17 @@ var ClaudeSettingsMerge = JSONMerge{
 	PayloadRel: "claude/settings.json",
 	TargetRel:  ".claude/settings.json",
 	MarkerRel:  ".claude/devrites.claude-hooks-merge",
-	MarkerText: ".claude/settings.json contains DevRites managed hook entries.",
-	DryRunText: ".claude/settings.json (DevRites hooks)",
+	MarkerText: ".claude/settings.json contains DevRites managed permissions.",
+	DryRunText: ".claude/settings.json (DevRites permissions)",
 }
 
-var CodexHooksMerge = JSONMerge{
-	PayloadRel: "codex/hooks.json",
-	TargetRel:  ".codex/hooks.json",
-	MarkerRel:  ".claude/devrites.codex-hooks-merge",
-	MarkerText: ".codex/hooks.json contains DevRites managed hook entries.",
-	DryRunText: ".codex/hooks.json (DevRites hooks)",
+var CodexConfigMerge = MarkerMerge{
+	TargetRel:  ".codex/config.toml",
+	PayloadRel: "codex/config.toml",
+	Begin:      "# BEGIN DEVRITES CODEX PERMISSIONS",
+	End:        "# END DEVRITES CODEX PERMISSIONS",
+	MarkerRel:  ".claude/devrites.codex-config-merge",
+	MarkerText: ".codex/config.toml contains the DevRites read-only-root permission profile.",
 }
 
 var managedMerges = []ManagedMerge{
@@ -101,21 +102,16 @@ var managedMerges = []ManagedMerge{
 		DryRun:    "AGENTS.md DevRites block",
 	},
 	{
-		MarkerRel: ".claude/devrites.codex-config-merge",
-		TargetRel: ".codex/config.toml",
-		Begin:     "# BEGIN DEVRITES CODEX MCP",
-		End:       "# END DEVRITES CODEX MCP",
-		DryRun:    ".codex/config.toml DevRites MCP block",
+		MarkerRel: CodexConfigMerge.MarkerRel,
+		TargetRel: CodexConfigMerge.TargetRel,
+		Begin:     CodexConfigMerge.Begin,
+		End:       CodexConfigMerge.End,
+		DryRun:    ".codex/config.toml DevRites permission block",
 	},
 	{
 		MarkerRel: ClaudeSettingsMerge.MarkerRel,
 		TargetRel: ClaudeSettingsMerge.TargetRel,
-		DryRun:    ".claude/settings.json DevRites hooks",
-	},
-	{
-		MarkerRel: CodexHooksMerge.MarkerRel,
-		TargetRel: CodexHooksMerge.TargetRel,
-		DryRun:    ".codex/hooks.json DevRites hooks",
+		DryRun:    ".claude/settings.json DevRites permissions",
 	},
 }
 
@@ -130,7 +126,7 @@ func RequiredPayload(withCodex bool) []string {
 			"codex/skills",
 			"codex/agents",
 			"codex/AGENTS.md",
-			"codex/hooks.json",
+			"codex/config.toml",
 		)
 	}
 	return required

package/engine/internal/hostpack/hostpack_test.go

@@ -16,15 +16,15 @@ func TestValidatePayloadRequiresClaudeAndCodexFiles(t *testing.T) {
 		"codex/skills/rite/SKILL.md":               {},
 		"codex/agents/devrites-code-reviewer.toml": {},
 		"codex/AGENTS.md":                          {},
-		"codex/hooks.json":                         {},
+		"codex/config.toml":                        {},
 	}
 	if err := ValidatePayload(payload, true); err != nil {
 		t.Fatal(err)
 	}
-	delete(payload, "codex/hooks.json")
+	delete(payload, "codex/config.toml")
 	err := ValidatePayload(payload, true)
-	if err == nil || !strings.Contains(err.Error(), "missing codex/hooks.json") {
-		t.Fatalf("ValidatePayload error = %v, want missing codex/hooks.json", err)
+	if err == nil || !strings.Contains(err.Error(), "missing codex/config.toml") {
+		t.Fatalf("ValidatePayload error = %v, want missing codex/config.toml", err)
 	}
 	if err := ValidatePayload(payload, false); err != nil {
 		t.Fatalf("claude-only payload should not require codex files: %v", err)
@@ -79,8 +79,8 @@ func TestMergeMarkerBlockIsIdempotent(t *testing.T) {
 }
 
 func TestUninstallAndPruneClassification(t *testing.T) {
-	entries := []string{".claude/devrites.agents-merge", ".claude/devrites.codex-hooks-merge"}
-	for _, rel := range []string{"AGENTS.md", ".codex/hooks.json"} {
+	entries := []string{CodexAgentsMerge.MarkerRel, CodexConfigMerge.MarkerRel}
+	for _, rel := range []string{CodexAgentsMerge.TargetRel, CodexConfigMerge.TargetRel} {
 		if ShouldRemoveOnUninstall(rel, entries) {
 			t.Fatalf("%s should be preserved because its merge marker is manifest-managed", rel)
 		}