devrites 2.6.1 → 3.0.0

package/engine/tests/parity_packageexistence_test.go

@@ -0,0 +1,64 @@
+package main_test
+
+import (
+	"testing"
+)
+
+// TestParityPackageExistence sets up a git repo with a committed manifest, then a
+// working-tree diff that adds a new require(), and checks the command's stdout +
+// exit against the golden snapshot. Read-only w.r.t. git.
+func TestParityPackageExistence(t *testing.T) {
+	requireGit(t)
+
+	// newRepo commits a package.json declaring lodash plus an empty source file.
+	newRepo := func(t *testing.T, manifest bool) string {
+		t.Helper()
+		work := t.TempDir()
+		initGitRepo(t, work)
+		if manifest {
+			writeFile(t, work, "package.json", "{\n  \"dependencies\": { \"lodash\": \"^4.0.0\" }\n}\n")
+		}
+		writeFile(t, work, "src/app.js", "// app\n")
+		gitCommitAll(t, work, "baseline")
+		makeFeatureDir(t, work, "feat")
+		return work
+	}
+	runCase := func(t *testing.T, work string, goArgs ...string) {
+		c := parityCase{
+			workdir: work,
+			env:     libRootEnv(work),
+			goArgs:  append([]string{"package-existence"}, goArgs...),
+		}
+		c.assertEqual(t)
+	}
+
+	t.Run("declared", func(t *testing.T) {
+		work := newRepo(t, true)
+		writeFile(t, work, "src/app.js", "// app\nconst _ = require('lodash');\n")
+		runCase(t, work, "feat")
+	})
+	t.Run("default-import-subpath", func(t *testing.T) {
+		work := newRepo(t, true)
+		writeFile(t, work, "src/app.js", "// app\nimport debounce from 'lodash/debounce';\n")
+		runCase(t, work, "feat")
+	})
+	t.Run("undeclared", func(t *testing.T) {
+		work := newRepo(t, true)
+		writeFile(t, work, "src/app.js", "// app\nconst g = require('ghostpkg');\n")
+		runCase(t, work, "feat")
+	})
+	t.Run("no-manifest", func(t *testing.T) {
+		work := newRepo(t, false)
+		writeFile(t, work, "src/app.js", "// app\nconst g = require('ghostpkg');\n")
+		runCase(t, work, "feat")
+	})
+	t.Run("ghost-workspace", func(t *testing.T) {
+		runCase(t, newRepo(t, true), "ghost")
+	})
+	t.Run("not-git", func(t *testing.T) {
+		work := t.TempDir()
+		makeFeatureDir(t, work, "feat")
+		writeFile(t, work, "package.json", "{ \"dependencies\": { \"lodash\": \"^4.0.0\" } }\n")
+		runCase(t, work, "feat")
+	})
+}

package/engine/tests/parity_reconcile_test.go

@@ -0,0 +1,88 @@
+package main_test
+
+import (
+	"fmt"
+	"testing"
+)
+
+// TestParityReconcile checks reconcile against the golden snapshots: snapshot
+// captures the worktree as a tree object, check diffs it and flags source changes
+// outside the claimed manifest. Runs git in a real repo, so stdout + exit are
+// captured from the live command. The .devrites/ bookkeeping is skipped by the
+// gate, so it never affects the verdict.
+func TestParityReconcile(t *testing.T) {
+	requireGit(t)
+
+	newRepo := func(t *testing.T) string {
+		t.Helper()
+		work := t.TempDir()
+		initGitRepo(t, work)
+		writeFile(t, work, "src/a.js", "console.log(1)\n")
+		writeFile(t, work, "src/b.js", "console.log(2)\n")
+		gitCommitAll(t, work, "baseline")
+		makeFeatureDir(t, work, "feat")
+		return work
+	}
+	// snapshot is also a setup step for the check-* cases, so it snapshots under a
+	// distinct key to avoid colliding with check's golden in the same subtest.
+	snapshot := func(t *testing.T, work string) {
+		out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "snapshot", "feat")
+		assertGoldenKey(t, t.Name()+"/snapshot", fmt.Sprintf("exit %d\n%s", code, out))
+	}
+	check := func(t *testing.T, work string) {
+		out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "check", "feat")
+		assertGolden(t, out, code)
+	}
+
+	t.Run("snapshot", func(t *testing.T) { snapshot(t, newRepo(t)) })
+
+	t.Run("check-clean", func(t *testing.T) {
+		work := newRepo(t)
+		snapshot(t, work)
+		writeFile(t, work, "src/a.js", "console.log(999)\n") // the wright's change
+		writeFeatureFile(t, work, "feat", ".reconcile-claimed", "src/a.js\n")
+		check(t, work)
+	})
+
+	t.Run("check-violation", func(t *testing.T) {
+		work := newRepo(t)
+		snapshot(t, work)
+		writeFile(t, work, "src/a.js", "console.log(999)\n")
+		writeFile(t, work, "src/b.js", "console.log(888)\n") // NOT claimed -> A1 breach
+		writeFeatureFile(t, work, "feat", ".reconcile-claimed", "src/a.js\n")
+		check(t, work)
+	})
+
+	t.Run("check-no-base", func(t *testing.T) {
+		work := newRepo(t)
+		writeFeatureFile(t, work, "feat", ".reconcile-claimed", "src/a.js\n")
+		check(t, work) // no snapshot -> exit 6
+	})
+
+	t.Run("check-no-claimed", func(t *testing.T) {
+		work := newRepo(t)
+		snapshot(t, work)
+		check(t, work) // base present, no claimed -> exit 6
+	})
+
+	t.Run("inline-fallback", func(t *testing.T) {
+		work := newRepo(t)
+		snapshot(t, work)
+		writeFeatureFile(t, work, "feat", ".reconcile-inline", "")
+		check(t, work) // gate skipped -> exit 0
+	})
+
+	t.Run("not-git", func(t *testing.T) {
+		work := t.TempDir()
+		makeFeatureDir(t, work, "feat")
+		check(t, work) // exit 0
+	})
+
+	t.Run("bad-mode", func(t *testing.T) {
+		work := newRepo(t)
+		(parityCase{
+			workdir: work, env: libRootEnv(work),
+			goArgs: []string{"reconcile", "bogus", "feat"},
+		}).assertEqual(t)
+	})
+}

package/engine/tests/parity_resolve_test.go

@@ -0,0 +1,144 @@
+package main_test
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"testing"
+)
+
+// Golden snapshot for resolve: it MUTATES questions.md + state.md. Each case
+// snapshots the command's stdout + exit code and, for the mutating cases, the
+// resulting file bytes. The two nondeterministic timestamp fields (answered_at
+// and the Log entry) are masked out before the file content is snapshotted so the
+// golden is deterministic across runs.
+var (
+	reAnsweredAt = regexp.MustCompile(`answered_at: \S+`)
+	reLogTS      = regexp.MustCompile(`(?m)^- \S+ build: resolved`)
+)
+
+func maskResolveTS(s string) string {
+	s = reAnsweredAt.ReplaceAllString(s, "answered_at: TS")
+	s = reLogTS.ReplaceAllString(s, "- TS build: resolved")
+	return s
+}
+
+const resolveQuestions = `## q-1 blocking
+status: open
+answered_at:
+answer:
+
+## q-2 advisory
+status: open
+answered_at:
+answer:
+`
+
+const resolveState = `- Status: awaiting_human
+- Next step: wait for q-1
+
+## Awaiting human
+- qid: q-1
+
+## Log
+- 2024-01-01 spec: created
+`
+
+func TestParityResolve(t *testing.T) {
+	// setup writes the fixtures into a Go tree (.devrites/features/feat) and returns
+	// the workspace root.
+	setup := func(t *testing.T, questions, state string) (gwork string) {
+		t.Helper()
+		gwork = t.TempDir()
+		writeFile(t, gwork, filepath.Join(".devrites", "features", "feat", "questions.md"), questions)
+		writeFile(t, gwork, filepath.Join(".devrites", "features", "feat", "state.md"), state)
+		writeFile(t, gwork, filepath.Join(".devrites", "ACTIVE"), "feat\n")
+		return gwork
+	}
+	// run executes resolve in gwork and snapshots its stdout + exit code under the
+	// current subtest's golden.
+	run := func(t *testing.T, gwork string, args ...string) {
+		t.Helper()
+		out, code := runArgv(t, gwork, libRootEnv(gwork), "", binPath, append([]string{"resolve"}, args...)...)
+		assertGolden(t, out, code)
+	}
+	// assertFileGolden snapshots the masked content of a mutated file under a
+	// per-file golden key (t.Name()+"/"+name).
+	assertFileGolden := func(t *testing.T, gwork, name string) {
+		t.Helper()
+		b, err := os.ReadFile(filepath.Join(gwork, ".devrites", "features", "feat", name))
+		if err != nil {
+			t.Fatalf("reading %s: %v", name, err)
+		}
+		assertGoldenKey(t, t.Name()+"/"+name, maskResolveTS(string(b)))
+	}
+
+	t.Run("answer", func(t *testing.T) {
+		gwork := setup(t, resolveQuestions, resolveState)
+		run(t, gwork, "q-1", "use JWT with 15m expiry")
+		assertFileGolden(t, gwork, "questions.md")
+		assertFileGolden(t, gwork, "state.md")
+	})
+
+	t.Run("drop", func(t *testing.T) {
+		gwork := setup(t, resolveQuestions, resolveState)
+		run(t, gwork, "--drop", "q-2", "out of scope")
+		assertFileGolden(t, gwork, "questions.md")
+		assertFileGolden(t, gwork, "state.md")
+	})
+
+	t.Run("not-found", func(t *testing.T) {
+		gwork := setup(t, resolveQuestions, resolveState)
+		run(t, gwork, "q-99", "nope") // exit 3
+	})
+
+	t.Run("not-open", func(t *testing.T) {
+		answered := `## q-1 blocking
+status: answered
+answered_at: 2024-01-01T00:00:00Z
+answer: prior
+`
+		gwork := setup(t, answered, resolveState)
+		run(t, gwork, "q-1", "again") // exit 4
+	})
+
+	t.Run("batch", func(t *testing.T) {
+		gwork := setup(t, resolveQuestions, resolveState)
+		writeFile(t, gwork, "batch.txt", "q-1: answer one\n--drop q-2: reason two\n")
+		run(t, gwork, "--batch", "batch.txt")
+		assertFileGolden(t, gwork, "questions.md")
+	})
+
+	t.Run("batch-unterminated", func(t *testing.T) {
+		// No trailing newline: a final line without a terminating newline is not
+		// applied (q-2 stays open), so the golden captures the truncated batch.
+		gwork := setup(t, resolveQuestions, resolveState)
+		writeFile(t, gwork, "batch.txt", "q-1: answer one\n--drop q-2: reason two") // no trailing \n
+		run(t, gwork, "--batch", "batch.txt")
+		assertFileGolden(t, gwork, "questions.md")
+	})
+
+	t.Run("missing-answer", func(t *testing.T) {
+		gwork := setup(t, resolveQuestions, resolveState)
+		run(t, gwork, "q-1") // no answer text -> exit 5
+	})
+
+	t.Run("no-workspace", func(t *testing.T) {
+		// Bare tree: no ACTIVE, no questions.md -> exit 2.
+		gwork := t.TempDir()
+		run(t, gwork, "q-1", "x")
+	})
+
+	t.Run("next-qid", func(t *testing.T) {
+		// Read-only: computes the next qid for an explicit questions.md path.
+		// DEVRITES_NOW pins the clock so the golden is stable across day
+		// boundaries — without it the qid tracks the real date and the snapshot
+		// fails every day but the one it was recorded on (ADR-0006, clock seam).
+		dir := t.TempDir()
+		writeFile(t, dir, "questions.md", "## q-2024-01-01-001\nstatus: open\n")
+		qpath := filepath.Join(dir, "questions.md")
+		env := append(append([]string{}, libEnv...), "DEVRITES_NOW=2026-07-07")
+		out, code := runArgv(t, dir, env, "", binPath, "resolve", "next-qid", qpath)
+		assertGolden(t, out, code)
+	})
+}

package/engine/tests/parity_test.go

@@ -0,0 +1,380 @@
+package main_test
+
+// Golden CLI harness: run `devrites-engine <args>` against a fixture and compare its
+// stdout + exit code to a recorded snapshot under testdata/golden/. The snapshots
+// were captured from the commands once they were proven correct, so a later change
+// that alters observable behaviour fails here. Regenerate them deliberately with
+// UPDATE_GOLDEN=1 (e.g. `UPDATE_GOLDEN=1 go test ./...`).
+//
+// stderr is intentionally NOT captured: it is diagnostic, not contract. Only
+// stdout (the output the hook/command consumer reads) and the exit code are.
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// parityCase describes one fixture run of the devrites-engine binary.
+type parityCase struct {
+	workdir string   // cwd the command runs in
+	env     []string // extra environment
+	stdin   string   // payload piped to stdin (hooks read stdin)
+	goArgs  []string // args to the built devrites-engine binary (binPath is prepended)
+}
+
+// assertEqual runs the command and compares its stdout + exit code to the golden
+// snapshot for the current subtest.
+func (c parityCase) assertEqual(t *testing.T) {
+	t.Helper()
+	out, code := runArgv(t, c.workdir, c.env, c.stdin, binPath, c.goArgs...)
+	assertGolden(t, out, code)
+}
+
+// assertGolden compares a command's output to the golden file for the current
+// subtest name; assertGoldenKey does the same under an explicit key (for tests
+// that snapshot more than one artifact, e.g. stdout plus a rewritten file).
+func assertGolden(t *testing.T, stdout string, code int) {
+	t.Helper()
+	assertGoldenKey(t, t.Name(), fmt.Sprintf("exit %d\n%s", code, stdout))
+}
+
+func assertGoldenKey(t *testing.T, key, got string) {
+	t.Helper()
+	path := filepath.Join(engineRoot, "testdata", "golden", key+".golden")
+	if os.Getenv("UPDATE_GOLDEN") != "" {
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(got), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		return
+	}
+	want, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("missing golden %s — regenerate with UPDATE_GOLDEN=1: %v", path, err)
+	}
+	wantText := strings.ReplaceAll(string(want), "\r\n", "\n")
+	if got != wantText {
+		t.Errorf("golden mismatch for %s\n got: %q\nwant: %q", key, got, wantText)
+	}
+}
+
+// runArgv runs one command in workdir with extra env, returning stdout and exit
+// code. A non-ExitError failure (e.g. binary not found) fails the test.
+func runArgv(t *testing.T, workdir string, env []string, stdin string, name string, args ...string) (stdout string, code int) {
+	t.Helper()
+	cmd := exec.Command(name, args...)
+	cmd.Dir = workdir
+	cmd.Env = append(os.Environ(), env...)
+	cmd.Stdin = strings.NewReader(stdin)
+	var out, errBuf bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &errBuf
+	err := cmd.Run()
+	if err != nil {
+		var ee *exec.ExitError
+		if !errors.As(err, &ee) {
+			t.Fatalf("running %s %v: %v", name, args, err)
+		}
+		code = ee.ExitCode()
+	}
+	return out.String(), code
+}
+
+// TestParityReviewerReadonly checks `hook reviewer-readonly` against golden
+// snapshots for each payload: the silent no-ops, the full enforce-mode deny, the
+// observe-mode side effect (asserted only on its empty stdout+exit), and the
+// agent-required gate. The golden check compares stdout+exit, not files.
+func TestParityReviewerReadonly(t *testing.T) {
+	cases := []struct {
+		name  string
+		env   []string
+		stdin string
+	}{
+		{"non-tool-input", nil, "not even json"},
+		{"non-bash-tool", nil, `{"tool_name":"Read","tool_input":{"file_path":"x"}}`},
+		{"safe-bash-command", nil, `{"tool_name":"Bash","tool_input":{"command":"ls -la"}}`},
+		{"enforce-deny-mutating", []string{"DEVRITES_REVIEWER_RO=enforce"}, `{"tool_name":"Bash","tool_input":{"command":"rm -rf foo"}}`},
+		{"enforce-deny-git-commit", []string{"DEVRITES_REVIEWER_RO=enforce"}, `{"tool_name":"Bash","tool_input":{"command":"git commit -m x"}}`},
+		{"observe-mutating-silent", nil, `{"tool_name":"Bash","tool_input":{"command":"rm -rf foo"}}`},
+		// The agent-required gate reads agent_type ONLY (like the bash node parse),
+		// so a subagent_type-only payload has no identity and is allowed.
+		{"agent-required-subagent-type-only-allows",
+			[]string{"DEVRITES_REVIEWER_RO=enforce", "DEVRITES_REVIEWER_AGENT_REQUIRED=1"},
+			`{"tool_name":"Bash","tool_input":{"command":"rm -rf foo"},"subagent_type":"devrites-code-reviewer"}`},
+		{"agent-required-devrites-agent-denies",
+			[]string{"DEVRITES_REVIEWER_RO=enforce", "DEVRITES_REVIEWER_AGENT_REQUIRED=1"},
+			`{"tool_name":"Bash","tool_input":{"command":"rm -rf foo"},"agent_type":"devrites-code-reviewer"}`},
+		{"agent-required-non-devrites-allows",
+			[]string{"DEVRITES_REVIEWER_RO=enforce", "DEVRITES_REVIEWER_AGENT_REQUIRED=1"},
+			`{"tool_name":"Bash","tool_input":{"command":"rm -rf foo"},"agent_type":"Explore"}`},
+	}
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			dir := t.TempDir()
+			c := parityCase{
+				workdir: dir,
+				env:     append([]string{"DEVRITES_ROOT="}, tc.env...),
+				stdin:   tc.stdin,
+				goArgs:  []string{"hook", "reviewer-readonly", "--harness=claude"},
+			}
+			c.assertEqual(t)
+		})
+	}
+}
+
+// TestParitySubagentOrient checks `hook subagent-orient` against golden snapshots
+// for each payload: a non-devrites agent (silent) and a devrites-* agent (the
+// fixed context envelope).
+func TestParitySubagentOrient(t *testing.T) {
+	cases := []struct {
+		name  string
+		stdin string
+	}{
+		{"garbage-input", "not json"},
+		{"non-devrites-agent", `{"agent_type":"Explore"}`},
+		{"devrites-agent", `{"agent_type":"devrites-code-reviewer"}`},
+		{"devrites-agent-subagent-type-key", `{"subagent_type":"devrites-security-auditor"}`},
+	}
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			dir := t.TempDir()
+			c := parityCase{
+				workdir: dir,
+				env:     []string{"DEVRITES_ROOT="},
+				stdin:   tc.stdin,
+				goArgs:  []string{"hook", "subagent-orient", "--harness=claude"},
+			}
+			c.assertEqual(t)
+		})
+	}
+}
+
+// TestParityCursor checks `hook cursor` against golden snapshots for each
+// active-feature state: the field reads, the open-questions count, the AFK line,
+// the RED warning, and the silent no-active path.
+func TestParityCursor(t *testing.T) {
+	work := t.TempDir()
+
+	writeFeatureFile(t, work, "full", "state.md",
+		"- Phase: build\n- Status: running\n- Next step: implement slice 3\n- AFK slices remaining: 2\n")
+	writeFeatureFile(t, work, "full", "questions.md",
+		"## q-1\nstatus: open\ngate: blocking\n\n## q-2\nstatus: open\ngate: advisory\n")
+	// present questions.md with ZERO open → the grep -c "0\n0" quirk.
+	writeFeatureFile(t, work, "zerogates", "state.md", "- Phase: spec\n- Status: running\n")
+	writeFeatureFile(t, work, "zerogates", "questions.md", "## q-1\nstatus: resolved\ngate: blocking\n")
+	// a RED workspace.
+	writeFeatureFile(t, work, "red", "state.md", "- Phase: prove\n- Status: running\n")
+	writeFeatureFile(t, work, "red", ".red", "npm test\n")
+	// a bare dir (no state.md / questions.md).
+	makeFeatureDir(t, work, "bare")
+
+	for _, tc := range []struct {
+		name, active string
+		afk          bool
+	}{
+		{"full-hitl", "full", false},
+		{"full-afk", "full", true},
+		{"zerogates", "zerogates", false},
+		{"red", "red", false},
+		{"bare", "bare", false},
+		{"no-active", "", false},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			setActiveAFK(t, work, tc.active, tc.afk)
+			(parityCase{
+				workdir: work,
+				env:     libRootEnv(work),
+				goArgs:  []string{"hook", "cursor", "--harness=claude"},
+			}).assertEqual(t)
+		})
+	}
+}
+
+// TestParityStatusline checks `hook statusline` against golden snapshots for each
+// active-feature state.
+func TestParityStatusline(t *testing.T) {
+	work := t.TempDir()
+
+	writeFeatureFile(t, work, "full", "state.md", "- Phase: build\n- Status: running\n")
+	writeFeatureFile(t, work, "full", "questions.md",
+		"## q-1\nstatus: open\ngate: blocking\n\n## q-2\nstatus: open\ngate: advisory\n")
+	writeFeatureFile(t, work, "nophase", "state.md", "- Status: running\n") // phase → "?"
+	writeFeatureFile(t, work, "red", "state.md", "- Phase: prove\n")
+	writeFeatureFile(t, work, "red", ".red", "npm test\n")
+
+	for _, tc := range []struct {
+		name, active string
+		afk          bool
+	}{
+		{"full-hitl", "full", false},
+		{"full-afk", "full", true},
+		{"nophase", "nophase", false},
+		{"red", "red", false},
+		{"no-active", "", false},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			setActiveAFK(t, work, tc.active, tc.afk)
+			(parityCase{
+				workdir: work,
+				env:     libRootEnv(work),
+				stdin:   `{"session":"x"}`, // statusline drains stdin
+				goArgs:  []string{"hook", "statusline", "--harness=claude"},
+			}).assertEqual(t)
+		})
+	}
+}
+
+// TestParityRedwatch checks `hook redwatch` against golden snapshots for each
+// payload: the test-command gate, the RED additionalContext, the green clear, and
+// the silent non-test / non-Bash paths. Each case uses its own slug so the .red
+// side effects don't cross-contaminate.
+func TestParityRedwatch(t *testing.T) {
+	work := t.TempDir()
+	for _, slug := range []string{"redf", "redp", "nont", "nonb"} {
+		makeFeatureDir(t, work, slug)
+	}
+
+	for _, tc := range []struct {
+		name, active, stdin string
+	}{
+		{"fail-writes-red", "redf", `{"tool_name":"Bash","tool_input":{"command":"npm test"},"tool_response":"Tests: 1 failed, 3 passed"}`},
+		{"pass-clears-red", "redp", `{"tool_name":"Bash","tool_input":{"command":"go test ./..."},"tool_response":"ok  all tests passed"}`},
+		{"non-test-command", "nont", `{"tool_name":"Bash","tool_input":{"command":"ls -la"},"tool_response":"file"}`},
+		{"non-bash-tool", "nonb", `{"tool_name":"Read","tool_input":{"file_path":"x"},"tool_response":"y"}`},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			setActiveAFK(t, work, tc.active, false)
+			(parityCase{
+				workdir: work,
+				env:     libRootEnv(work),
+				stdin:   tc.stdin,
+				goArgs:  []string{"hook", "redwatch", "--harness=claude"},
+			}).assertEqual(t)
+		})
+	}
+}
+
+// TestParityA1Guard checks `hook a1-guard` against golden snapshots for each
+// payload: it blocks a MAIN-thread source edit only when the build window is open
+// and enforce is on, and allows subagent edits, .devrites bookkeeping edits, an
+// inline-fallback window, and a closed window.
+func TestParityA1Guard(t *testing.T) {
+	work := t.TempDir()
+	makeFeatureDir(t, work, "win")
+	writeFeatureFile(t, work, "win", ".reconcile-base", "snapshot\n")
+	makeFeatureDir(t, work, "inline")
+	writeFeatureFile(t, work, "inline", ".reconcile-base", "snapshot\n")
+	writeFeatureFile(t, work, "inline", ".reconcile-inline", "")
+	makeFeatureDir(t, work, "nowin") // no .reconcile-base → window closed
+
+	enforce := []string{"DEVRITES_A1_HOOK=enforce"}
+	for _, tc := range []struct {
+		name, active string
+		env          []string
+		stdin        string
+	}{
+		{"source-edit-enforce-denies", "win", enforce, `{"tool_name":"Edit","tool_input":{"file_path":"src/app.js"}}`},
+		{"subagent-allowed", "win", enforce, `{"tool_name":"Edit","tool_input":{"file_path":"src/app.js"},"agent_id":"abc"}`},
+		{"devrites-edit-allowed", "win", enforce, `{"tool_name":"Edit","tool_input":{"file_path":".devrites/features/win/state.md"}}`},
+		{"non-edit-tool", "win", enforce, `{"tool_name":"Bash","tool_input":{"command":"ls"}}`},
+		{"observe-mode-silent", "win", nil, `{"tool_name":"Edit","tool_input":{"file_path":"src/app.js"}}`},
+		{"inline-fallback-silent", "inline", enforce, `{"tool_name":"Edit","tool_input":{"file_path":"src/app.js"}}`},
+		{"no-window-silent", "nowin", enforce, `{"tool_name":"Edit","tool_input":{"file_path":"src/app.js"}}`},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			setActiveAFK(t, work, tc.active, false)
+			(parityCase{
+				workdir: work,
+				env:     append(libRootEnv(work), tc.env...),
+				stdin:   tc.stdin,
+				goArgs:  []string{"hook", "a1-guard", "--harness=claude"},
+			}).assertEqual(t)
+		})
+	}
+}
+
+// TestParityWrightScope checks `hook wright-scope` against golden snapshots for
+// each payload: a path in touched-files.md is allowed, one outside it is denied
+// under enforce, .devrites edits and non-edit tools are allowed, and the
+// agent-required gate skips a non-wright caller.
+func TestParityWrightScope(t *testing.T) {
+	work := t.TempDir()
+	writeFeatureFile(t, work, "ws", "touched-files.md", "# touched\n- `src/app.js`\n")
+
+	enforce := []string{"DEVRITES_WRIGHT_SCOPE=enforce"}
+	for _, tc := range []struct {
+		name  string
+		env   []string
+		stdin string
+	}{
+		{"in-scope-allowed", enforce, `{"tool_name":"Edit","tool_input":{"file_path":"src/app.js"}}`},
+		{"out-of-scope-enforce-denies", enforce, `{"tool_name":"Edit","tool_input":{"file_path":"src/other.js"}}`},
+		{"devrites-edit-allowed", enforce, `{"tool_name":"Edit","tool_input":{"file_path":".devrites/x/y.md"}}`},
+		{"non-edit-tool", enforce, `{"tool_name":"Bash","tool_input":{"command":"ls"}}`},
+		{"out-of-scope-observe-silent", nil, `{"tool_name":"Edit","tool_input":{"file_path":"src/other.js"}}`},
+		{"agent-required-non-wright", append([]string{"DEVRITES_WRIGHT_AGENT_REQUIRED=1"}, enforce...),
+			`{"tool_name":"Edit","tool_input":{"file_path":"src/other.js"},"agent_type":"Explore"}`},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			setActiveAFK(t, work, "ws", false)
+			(parityCase{
+				workdir: work,
+				env:     append(libRootEnv(work), tc.env...),
+				stdin:   tc.stdin,
+				goArgs:  []string{"hook", "wright-scope", "--harness=claude"},
+			}).assertEqual(t)
+		})
+	}
+}
+
+// setActiveAFK points .devrites/ACTIVE at slug (or removes it) and toggles the
+// .devrites/AFK sentinel — the two files bash (via CWD) and the migrated Go (via
+// <root>) both read from the same shared location.
+func setActiveAFK(t *testing.T, work, slug string, afk bool) {
+	t.Helper()
+	active := filepath.Join(work, ".devrites", "ACTIVE")
+	if slug == "" {
+		_ = os.Remove(active)
+	} else if err := os.WriteFile(active, []byte(slug+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	afkPath := filepath.Join(work, ".devrites", "AFK")
+	if afk {
+		if err := os.WriteFile(afkPath, []byte("max-slices: 2\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	} else {
+		_ = os.Remove(afkPath)
+	}
+}
+
+// TestParityOrientSilentPath checks `hook orient` against a golden snapshot for
+// the common session-start case: outside any DevRites workspace (a directory with
+// no .devrites), orient must stay silent — exit 0, no stdout.
+func TestParityOrientSilentPath(t *testing.T) {
+	dir := t.TempDir() // a directory with no .devrites
+
+	c := parityCase{
+		workdir: dir,
+		// Ensure DEVRITES_ROOT does not leak in and make the Go side resolve a
+		// real workspace; it must see "not a DevRites project".
+		env:    []string{"DEVRITES_ROOT="},
+		goArgs: []string{"hook", "orient", "--harness=claude"},
+	}
+	c.assertEqual(t)
+}