devrites 3.2.16 → 3.2.17

package/engine/internal/lib/util.go

@@ -1,42 +1,147 @@
 package lib
 
 import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"time"
 )
 
-// gitToplevel returns the absolute path of the git working tree containing dir,
-// or "" when dir is not inside a repository. The git-backed gates
-// (test-integrity and reconcile) skip rather than block when it is empty.
-func gitToplevel(dir string) string {
-	out, err := exec.Command("git", "-C", dir, "rev-parse", "--show-toplevel").Output()
+var errNotGitRepository = errors.New("not a git repository")
+
+const (
+	gitCommandTimeout = 30 * time.Second
+	gitOutputLimit    = 16 << 20
+)
+
+type cappedGitOutput struct {
+	bytes.Buffer
+	truncated bool
+}
+
+func (w *cappedGitOutput) Write(p []byte) (int, error) {
+	remaining := gitOutputLimit - w.Len()
+	if remaining > 0 {
+		if len(p) > remaining {
+			_, _ = w.Buffer.Write(p[:remaining])
+			w.truncated = true
+		} else {
+			_, _ = w.Buffer.Write(p)
+		}
+	} else {
+		w.truncated = true
+	}
+	return len(p), nil
+}
+
+type gitCommandError struct {
+	args     []string
+	output   string
+	exitCode int
+	err      error
+}
+
+func (e *gitCommandError) Error() string {
+	detail := strings.TrimSpace(e.output)
+	if detail == "" {
+		return fmt.Sprintf("git %s: %v", strings.Join(e.args, " "), e.err)
+	}
+	return fmt.Sprintf("git %s: %v: %s", strings.Join(e.args, " "), e.err, detail)
+}
+
+func (e *gitCommandError) Unwrap() error { return e.err }
+
+func runGitCommand(dir string, env []string, args ...string) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), gitCommandTimeout)
+	defer cancel()
+	commandArgs := append([]string{"-C", dir}, args...)
+	cmd := exec.CommandContext(ctx, "git", commandArgs...)
+	cmd.WaitDelay = 2 * time.Second
+	if env == nil {
+		env = os.Environ()
+	} else {
+		env = append([]string{}, env...)
+	}
+	cmd.Env = append(
+		env,
+		"GIT_TERMINAL_PROMPT=0",
+		"GCM_INTERACTIVE=never",
+		"GIT_PAGER=cat",
+		"PAGER=cat",
+		"LC_ALL=C",
+	)
+	var output cappedGitOutput
+	cmd.Stdout = &output
+	cmd.Stderr = &output
+	err := cmd.Run()
+	if err == nil {
+		return output.Bytes(), nil
+	}
+	code := -1
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) {
+		code = exitErr.ExitCode()
+	}
+	if ctx.Err() != nil {
+		err = ctx.Err()
+	}
+	detail := output.String()
+	if output.truncated {
+		detail += "\n[git output truncated]"
+	}
+	return nil, &gitCommandError{
+		args:     args,
+		output:   detail,
+		exitCode: code,
+		err:      err,
+	}
+}
+
+func gitErrorExitCode(err error) (int, bool) {
+	var commandErr *gitCommandError
+	if !errors.As(err, &commandErr) {
+		return 0, false
+	}
+	return commandErr.exitCode, commandErr.exitCode >= 0
+}
+
+// gitToplevel returns the absolute path of the Git working tree containing dir.
+// Repository absence is distinct from Git execution failure so integrity gates
+// can fail closed on a missing binary, corrupt repository, or poisoned runtime.
+func gitToplevel(dir string) (string, error) {
+	out, err := runGitCommand(dir, nil, "rev-parse", "--show-toplevel")
 	if err != nil {
-		return ""
+		var commandErr *gitCommandError
+		if errors.As(err, &commandErr) {
+			detail := strings.ToLower(commandErr.output)
+			if strings.Contains(detail, "not a git repository") ||
+				strings.Contains(detail, "not a git work tree") {
+				return "", errNotGitRepository
+			}
+		}
+		return "", err
+	}
+	root := strings.TrimSpace(string(out))
+	if root == "" {
+		return "", fmt.Errorf("git rev-parse returned an empty top-level path")
 	}
-	return filepath.Clean(strings.TrimSpace(string(out)))
+	return filepath.Clean(root), nil
 }
 
 // gitDiffNames lists the paths that differ, relative to gitRoot. With one ref it
 // diffs the working tree against that ref; with two it diffs the two tree objects.
-func gitDiffNames(gitRoot string, refs ...string) []string {
-	args := append([]string{"-C", gitRoot, "diff", "--name-only"}, refs...)
-	out, err := exec.Command("git", args...).Output()
+func gitDiffNames(gitRoot string, refs ...string) ([]string, error) {
+	args := append([]string{"diff", "--name-only"}, refs...)
+	out, err := runGitCommand(gitRoot, nil, args...)
 	if err != nil {
-		return nil
+		return nil, err
 	}
-	return splitLinesNoTrailing(out)
-}
-
-// stripASCIISpace removes every whitespace character from s (used to normalise an
-// ACTIVE pointer before comparing it to a slug).
-func stripASCIISpace(s string) string {
-	return strings.Map(func(r rune) rune {
-		if strings.ContainsRune(spaceChars, r) {
-			return -1
-		}
-		return r
-	}, s)
+	return splitLinesNoTrailing(out), nil
 }
 
 // isAllDigits reports whether s is a non-empty run of ASCII digits.

package/engine/main.go

@@ -56,7 +56,8 @@ Usage:
   devrites-engine mutation-gate [slug]     Advisory: detect the mutation runner and scope it
   devrites-engine test-integrity [slug]    Gate: no test deleted, skipped, or de-asserted
   devrites-engine review-integrity [slug]  Gate: no adversarial review axis is silent (zero findings, no justification)
-  devrites-engine reconcile <sub> [slug]   A1 gate: snapshot|check|close the wright's source writes
+  devrites-engine dispatch-waive <reason>  Record a deterministic pre-dispatch STOP reason
+  devrites-engine reconcile <sub> [slug]   A1 gate: snapshot|check|restore-check|close the wright's source writes
   devrites-engine resolve <qid> "<ans>"    Resolve an open question; keep state.md consistent
   devrites-engine close-out <slug>         Archive a shipped feature and clear ACTIVE
   devrites-engine archive-search "<nouns>" Find prior shipped specs that overlap the query
@@ -238,6 +239,8 @@ func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		return lib.TestIntegrity(root, args[1:], stdout, stderr)
 	case "review-integrity":
 		return lib.ReviewIntegrity(root, args[1:], stdout, stderr)
+	case "dispatch-waive":
+		return lib.DispatchWaive(args[1:], stdout, stderr)
 	case "reconcile":
 		return lib.Reconcile(root, args[1:], stdout, stderr)
 	case "resolve":

package/engine/testdata/golden/TestParityReconcile/close-window.golden

@@ -1,2 +1,3 @@
 exit 0
+reconcile: OK: every slice change matches the orchestrator allowlist; baseline retained for post-slice gates (run "reconcile close" afterward).
 reconcile: closed slice window for feat.

package/engine/testdata/golden/TestParityReconcile/not-git.golden

@@ -1 +1 @@
-exit 0
+exit 6

package/engine/testdata/golden/TestParityTestIntegrity/not-git.golden

@@ -1 +1 @@
-exit 0
+exit 2

package/engine/tests/hook_test.go

@@ -236,6 +236,18 @@ func parsePermissionDecision(t *testing.T, stdout string) (decision, reason stri
 	return env.HookSpecificOutput.PermissionDecision, env.HookSpecificOutput.PermissionDecisionReason
 }
 
+func parseStopDecision(t *testing.T, stdout string) (decision, reason string) {
+	t.Helper()
+	var env struct {
+		Decision string `json:"decision"`
+		Reason   string `json:"reason"`
+	}
+	if err := json.Unmarshal([]byte(strings.TrimSpace(stdout)), &env); err != nil {
+		t.Fatalf("stdout is not a valid Stop decision: %v\n%s", err, stdout)
+	}
+	return env.Decision, env.Reason
+}
+
 func TestHookReviewerReadonlyEnforceDeniesMutatingBash(t *testing.T) {
 	for _, h := range []string{"claude", "codex"} {
 		h := h
@@ -260,14 +272,22 @@ func TestHookReviewerReadonlyEnforceDeniesMutatingBash(t *testing.T) {
 
 func TestHookReviewerReadonlyAllowsSafeBash(t *testing.T) {
 	root := newWorkspace(t)
-	in := `{"tool_name":"Bash","tool_input":{"command":"grep -rn foo ."}}`
-	out, _, code := runDevritesIO(t, root, in, []string{"DEVRITES_REVIEWER_RO=enforce"},
-		"hook", "reviewer-readonly", "--harness=claude")
-	if code != 0 {
-		t.Fatalf("exit = %d, want 0", code)
-	}
-	if strings.TrimSpace(out) != "" {
-		t.Errorf("stdout = %q, want silent for a read-only command", out)
+	for _, command := range []string{
+		"grep -rn foo .",
+		`cd "` + filepath.Dir(root) + `" && git diff --binary --full-index --no-renames HEAD HEAD --`,
+	} {
+		in := hookPayload(t, map[string]any{
+			"tool_name":  "Bash",
+			"tool_input": map[string]any{"command": command},
+		})
+		out, _, code := runDevritesIO(t, root, in, []string{"DEVRITES_REVIEWER_RO=enforce"},
+			"hook", "reviewer-readonly", "--harness=claude")
+		if code != 0 {
+			t.Fatalf("%q exit = %d, want 0", command, code)
+		}
+		if strings.TrimSpace(out) != "" {
+			t.Errorf("%q stdout = %q, want silent for a read-only command", command, out)
+		}
 	}
 }
 
@@ -440,20 +460,87 @@ func TestHookReviewerReadonlyActiveLeafDeniesEveryMutationSurface(t *testing.T)
 
 func TestHookReviewerReadonlyActiveLeafAllowsBoundedProof(t *testing.T) {
 	root := newWorkspace(t)
-	in := `{"tool_name":"Bash","tool_input":{"command":"go test ./... -count=1"}}`
-	out, _, code := runDevritesIO(t, root, in, []string{
+	env := []string{
 		"DEVRITES_AGENT_RUN=1",
 		"DEVRITES_ACTIVE_AGENT=devrites-proof-runner",
-	}, "hook", "reviewer-readonly", "--harness=claude")
+	}
+	for _, command := range []string{
+		"go test ./... -count=1",
+		"command -v devrites-engine",
+		"devrites-engine conventions orient",
+		"devrites-engine learnings mine",
+	} {
+		in := fmt.Sprintf(`{"tool_name":"Bash","tool_input":{"command":%q}}`, command)
+		out, _, code := runDevritesIO(t, root, in, env,
+			"hook", "reviewer-readonly", "--harness=claude")
+		if code != 0 || strings.TrimSpace(out) != "" {
+			t.Fatalf("%q should be allowed: exit=%d out=%q", command, code, out)
+		}
+	}
+	in := `{"tool_name":"Bash","tool_input":{"command":"go test ./... -count=1"}}`
+	out, _, code := runDevritesIO(t, root, in, env,
+		"hook", "wright-scope", "--harness=claude")
 	if code != 0 || strings.TrimSpace(out) != "" {
-		t.Fatalf("bounded proof should be allowed: exit=%d out=%q", code, out)
+		t.Fatalf("wright hook must not shadow reviewer policy: exit=%d out=%q", code, out)
 	}
-	out, _, code = runDevritesIO(t, root, in, []string{
+}
+
+func TestHookReviewerReadonlyProofRunnerKeepsArtifactProofRootOwned(t *testing.T) {
+	root := newWorkspace(t)
+	env := []string{
 		"DEVRITES_AGENT_RUN=1",
 		"DEVRITES_ACTIVE_AGENT=devrites-proof-runner",
-	}, "hook", "wright-scope", "--harness=claude")
+	}
+	for _, command := range []string{
+		"npm run build",
+		"npm run test:e2e -- tests/admin-locations.e2e.spec.ts",
+		"go build ./...",
+		"bash scripts/mutate-repository.sh",
+		"npm run deploy",
+		"make deploy",
+		"docker compose up -d",
+		"printf x > src/app.go",
+		"npm install left-pad",
+		"python -c 'open(\"src/app.go\", \"w\").write(\"x\")'",
+	} {
+		in := fmt.Sprintf(`{"tool_name":"Bash","tool_input":{"command":%q}}`, command)
+		out, errOut, code := runDevritesIO(t, root, in, env,
+			"hook", "reviewer-readonly", "--harness=claude")
+		if code != 0 {
+			t.Fatalf("root-owned proof command guard exit=%d stderr=%q", code, errOut)
+		}
+		if decision, _ := parsePermissionDecision(t, out); decision != "deny" {
+			t.Fatalf("proof leaf command was not denied: command=%q out=%q", command, out)
+		}
+	}
+}
+
+func TestHookRedwatchRecognizesCodexShellAliases(t *testing.T) {
+	root := newWorkspace(t)
+	writeActive(t, root, "auth-tokens")
+	red := filepath.Join(root, "features", "auth-tokens", ".red")
+
+	fail := `{"tool_name":"functions.exec_command","tool_input":{"cmd":"npm test"},"tool_response":"Tests: 1 failed, 3 passed"}`
+	out, errOut, code := runDevritesIO(t, root, fail, nil,
+		"hook", "redwatch", "--harness=codex")
+	if code != 0 {
+		t.Fatalf("failing exec_command exit=%d stderr=%q", code, errOut)
+	}
+	if !strings.Contains(out, "tests/build are RED") {
+		t.Fatalf("failing exec_command omitted RED context: %q", out)
+	}
+	if _, err := os.Stat(red); err != nil {
+		t.Fatalf("failing exec_command did not create .red: %v", err)
+	}
+
+	pass := `{"tool_name":"exec_command","tool_input":{"cmd":"npm test"},"tool_response":"PASS: all tests passed"}`
+	out, errOut, code = runDevritesIO(t, root, pass, nil,
+		"hook", "redwatch", "--harness=codex")
 	if code != 0 || strings.TrimSpace(out) != "" {
-		t.Fatalf("wright hook must not shadow reviewer policy: exit=%d out=%q", code, out)
+		t.Fatalf("passing exec_command exit=%d out=%q stderr=%q", code, out, errOut)
+	}
+	if _, err := os.Stat(red); !os.IsNotExist(err) {
+		t.Fatalf("passing exec_command retained .red: %v", err)
 	}
 }
 
@@ -502,7 +589,7 @@ func TestHookWrightScopeUsesExactOrchestratorAllowlist(t *testing.T) {
 	}
 }
 
-func TestHookWrightScopeBindsCodexWorkerDuringReconcileWindow(t *testing.T) {
+func TestHookWrightScopeRequiresBoundCodexWorkerDuringReconcileWindow(t *testing.T) {
 	root := newWorkspace(t)
 	writeActive(t, root, "auth-tokens")
 	workspace := filepath.Join(root, "features", "auth-tokens")
@@ -519,7 +606,7 @@ func TestHookWrightScopeBindsCodexWorkerDuringReconcileWindow(t *testing.T) {
 		input string
 		deny  bool
 	}{
-		{"listed edit", `{"tool_name":"Edit","tool_input":{"file_path":"src/app.go"},"agent_type":"worker"}`, false},
+		{"unbound listed edit", `{"tool_name":"Edit","tool_input":{"file_path":"src/app.go"},"agent_type":"worker"}`, true},
 		{"unlisted edit", `{"tool_name":"Edit","tool_input":{"file_path":"src/other.go"},"agent_type":"worker"}`, true},
 	} {
 		t.Run(test.name, func(t *testing.T) {
@@ -549,6 +636,90 @@ func TestHookWrightScopeBindsCodexWorkerDuringReconcileWindow(t *testing.T) {
 	}
 }
 
+func TestHookWrightScopeAllowsOnlyBoundCodexV1WorkerPaths(t *testing.T) {
+	root := newWorkspace(t)
+	writeActive(t, root, "auth-tokens")
+	workspace := filepath.Join(root, "features", "auth-tokens")
+	for name, body := range map[string]string{
+		".wright-allowlist":    "src/app.go\n",
+		".reconcile-base":      "snapshot\n",
+		".reconcile-allowlist": "src/app.go\n",
+		".reconcile-devrites":  "[]\n",
+	} {
+		if err := os.WriteFile(filepath.Join(workspace, name), []byte(body), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.MkdirAll(filepath.Join(workspace, ".reconcile-objects"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	sessionID, turnID := "session-bound-worker", "turn-bound-worker"
+	writeCodexAgentContract(t, root, "devrites-slice-wright")
+	writeCodexSkillContract(t, root, "rite-build", "devrites-slice-wright")
+	runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "UserPromptSubmit",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"prompt":          "$rite-build",
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+	if out, stderr, code := runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "PreToolUse",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"tool_name":       "spawn_agent",
+		"tool_use_id":     "spawn-bound-worker",
+		"tool_input": map[string]any{
+			"agent_type": "worker",
+			"fork_turns": "none",
+			"message":    "Read .codex/agents/devrites-slice-wright.toml.",
+		},
+	}), nil, "hook", "agent-dispatch", "--harness=codex"); code != 0 {
+		t.Fatalf("spawn exit=%d out=%s stderr=%s", code, out, stderr)
+	} else if decision, reason := parsePermissionDecision(t, out); decision != "allow" {
+		t.Fatalf("spawn denied: %s (%s)", decision, reason)
+	}
+	if out, stderr, code := runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "SubagentStart",
+		"session_id":      sessionID,
+		"turn_id":         "child-turn",
+		"agent_id":        "bound-worker",
+		"agent_type":      "worker",
+	}), nil, "hook", "subagent-orient", "--harness=codex"); code != 0 ||
+		!strings.Contains(out, "Confirmed role") {
+		t.Fatalf("start exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+
+	env := []string{"DEVRITES_CODEX_GENERIC_AGENT_COMPAT=1", "DEVRITES_HOOK_PROFILE=strict"}
+	for _, test := range []struct {
+		path string
+		deny bool
+	}{
+		{"src/app.go", false},
+		{"src/other.go", true},
+	} {
+		input := hookPayload(t, map[string]any{
+			"hook_event_name": "PreToolUse",
+			"session_id":      sessionID,
+			"agent_id":        "bound-worker",
+			"agent_type":      "worker",
+			"tool_name":       "Edit",
+			"tool_input":      map[string]any{"file_path": test.path},
+		})
+		out, stderr, code := runDevritesIO(t, root, input, env,
+			"hook", "wright-scope", "--harness=codex")
+		if code != 0 {
+			t.Fatalf("%s exit=%d stderr=%s", test.path, code, stderr)
+		}
+		if test.deny {
+			if decision, _ := parsePermissionDecision(t, out); decision != "deny" {
+				t.Fatalf("%s should be denied: %s", test.path, out)
+			}
+		} else if strings.TrimSpace(out) != "" {
+			t.Fatalf("%s should be allowed: %s", test.path, out)
+		}
+	}
+}
+
 func TestHookWrightScopeAcceptsCodexV2NamedRole(t *testing.T) {
 	root := newWorkspace(t)
 	writeActive(t, root, "auth-tokens")
@@ -629,6 +800,8 @@ func TestHookWrightScopeRequiresSpawnedCodexWorkerForSourceWrites(t *testing.T)
 	runGuard(`{"tool_name":"Write","tool_input":{"file_path":"src/app.go"}}`, true)
 	runGuard(`{"tool_name":"Bash","tool_input":{"command":"printf x > src/app.go"}}`, true)
 	runGuard(`{"tool_name":"js","tool_input":{"code":"writeFile()"}}`, true)
+	runGuard(`{"tool_name":"Bash","tool_input":{"command":"devrites-engine reconcile restore-check auth-tokens"}}`, false)
+	runGuard(`{"tool_name":"Bash","tool_input":{"command":"devrites-engine reconcile restore-check auth-tokens && printf x > src/app.go"}}`, true)
 	out, errOut, code := runDevritesIO(t, root,
 		`{"tool_name":"Bash","tool_input":{"command":"printf x > src/app.go"}}`,
 		nil, "hook", "wright-scope", "--harness=claude")
@@ -1544,6 +1717,74 @@ func TestCodexAgentDispatchBlocksFalseWaitAndStop(t *testing.T) {
 	}
 }
 
+func TestCodexAgentDispatchRequiresSuccessfulReasonBoundWaiver(t *testing.T) {
+	root := newWorkspace(t)
+	role := "devrites-plan-reviewer"
+	writeCodexAgentContract(t, root, role)
+	writeCodexSkillContract(t, root, "rite-vet", role)
+	sessionID, turnID := "session-waiver", "turn-waiver"
+	runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "UserPromptSubmit",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"prompt":          "$rite-vet",
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+
+	invalid := hookPayload(t, map[string]any{
+		"hook_event_name": "PreToolUse",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"tool_name":       "functions.exec_command",
+		"tool_input":      map[string]any{"cmd": "devrites-engine dispatch-waive wrong-phase && true"},
+	})
+	out, _, _ := runDevritesIO(t, root, invalid, nil,
+		"hook", "agent-dispatch", "--harness=codex")
+	if decision, _ := parsePermissionDecision(t, out); decision != "deny" {
+		t.Fatalf("chained waiver was not denied: %s", out)
+	}
+
+	command := "devrites-engine dispatch-waive wrong-phase"
+	pre := hookPayload(t, map[string]any{
+		"hook_event_name": "PreToolUse",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"tool_name":       "functions.exec_command",
+		"tool_input":      map[string]any{"cmd": command},
+	})
+	if out, stderr, code := runDevritesIO(t, root, pre, nil,
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("waiver pre exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+
+	stop := hookPayload(t, map[string]any{
+		"hook_event_name": "Stop",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+	})
+	out, _, _ = runDevritesIO(t, root, stop, nil,
+		"hook", "agent-dispatch", "--harness=codex")
+	if decision, _ := parseStopDecision(t, out); decision != "block" {
+		t.Fatalf("PreToolUse waiver falsely satisfied dispatch: %s", out)
+	}
+
+	post := hookPayload(t, map[string]any{
+		"hook_event_name": "PostToolUse",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"tool_name":       "functions.exec_command",
+		"tool_input":      map[string]any{"cmd": command},
+		"tool_response":   "dispatch-waive: accepted wrong-phase",
+	})
+	if out, stderr, code := runDevritesIO(t, root, post, nil,
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("waiver post exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+	if out, stderr, code := runDevritesIO(t, root, stop, nil,
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("waived stop exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+}
+
 func TestCodexAgentDispatchConfirmsGenericRoleAndResult(t *testing.T) {
 	root := newWorkspace(t)
 	sessionID, turnID := "session-complete", "turn-complete"
@@ -1664,12 +1905,99 @@ func TestCodexAgentDispatchConfirmsGenericRoleAndResult(t *testing.T) {
 		t.Fatalf("wait exit=%d out=%s stderr=%s", code, out, stderr)
 	}
 
+	if out, stderr, code := runDevritesIO(t, root, stop, nil,
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 {
+		t.Fatalf("pre-wait stop exit=%d out=%s stderr=%s", code, out, stderr)
+	} else if decision, _ := parseStopDecision(t, out); decision != "block" {
+		t.Fatalf("PreToolUse wait falsely satisfied dispatch: %s", out)
+	}
+
+	waitTimeout := hookPayload(t, map[string]any{
+		"hook_event_name": "PostToolUse",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"tool_name":       "wait",
+		"tool_input":      map[string]any{"ids": []string{"agent-1"}},
+		"tool_response":   map[string]any{"timed_out": true},
+	})
+	if out, stderr, code := runDevritesIO(t, root, waitTimeout, nil,
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("timed-out wait post exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+	if out, stderr, code := runDevritesIO(t, root, stop, nil,
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 {
+		t.Fatalf("post-timeout stop exit=%d out=%s stderr=%s", code, out, stderr)
+	} else if decision, _ := parseStopDecision(t, out); decision != "block" {
+		t.Fatalf("timed-out wait falsely satisfied dispatch: %s", out)
+	}
+
+	waitDone := hookPayload(t, map[string]any{
+		"hook_event_name": "PostToolUse",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"tool_name":       "wait",
+		"tool_input":      map[string]any{"ids": []string{"agent-1"}},
+		"tool_response":   map[string]any{"status": "completed"},
+	})
+	if out, stderr, code := runDevritesIO(t, root, waitDone, nil,
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("wait post exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+
 	if out, stderr, code := runDevritesIO(t, root, stop, nil,
 		"hook", "agent-dispatch", "--harness=codex"); code != 0 || strings.TrimSpace(out) != "" {
 		t.Fatalf("resolved stop exit=%d out=%s stderr=%s", code, out, stderr)
 	}
 }
 
+func TestCodexAgentDispatchRefusesAmbiguousGenericStart(t *testing.T) {
+	root := newWorkspace(t)
+	sessionID, turnID := "session-ambiguous-start", "turn-ambiguous-start"
+	roles := []string{"devrites-security-auditor", "devrites-plan-reviewer"}
+	for _, role := range roles {
+		writeCodexAgentContract(t, root, role)
+	}
+	writeCodexSkillContract(t, root, "devrites-audit", strings.Join(roles, ","))
+	runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "UserPromptSubmit",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"prompt":          "$devrites-audit",
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+
+	for i, role := range roles {
+		out, stderr, code := runDevritesIO(t, root, hookPayload(t, map[string]any{
+			"hook_event_name": "PreToolUse",
+			"session_id":      sessionID,
+			"turn_id":         turnID,
+			"tool_name":       "spawn_agent",
+			"tool_use_id":     fmt.Sprintf("spawn-%d", i),
+			"tool_input": map[string]any{
+				"agent_type": "explorer",
+				"fork_turns": "none",
+				"message":    "Read .codex/agents/" + role + ".toml.",
+			},
+		}), nil, "hook", "agent-dispatch", "--harness=codex")
+		if code != 0 {
+			t.Fatalf("spawn %s exit=%d out=%s stderr=%s", role, code, out, stderr)
+		}
+	}
+
+	out, stderr, code := runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "SubagentStart",
+		"session_id":      sessionID,
+		"turn_id":         "child-turn",
+		"agent_id":        "ambiguous-agent",
+		"agent_type":      "explorer",
+	}), nil, "hook", "subagent-orient", "--harness=codex")
+	if code != 0 {
+		t.Fatalf("start exit=%d stderr=%s", code, stderr)
+	}
+	if !strings.Contains(out, "Dispatch binding failed") {
+		t.Fatalf("ambiguous generic start was bound to an arbitrary role: %s", out)
+	}
+}
+
 func TestCodexAgentDispatchConfirmsDurableV2NamedRole(t *testing.T) {
 	root := newWorkspace(t)
 	codeHome := t.TempDir()
@@ -1960,6 +2288,14 @@ func TestCodexAgentDispatchGatesReconcileCloseOnBoundWrightResult(t *testing.T)
 			"tool_name":       "wait",
 			"tool_input":      map[string]any{"ids": []string{"agent-wright"}},
 		},
+		{
+			"hook_event_name": "PostToolUse",
+			"session_id":      sessionID,
+			"turn_id":         turnID,
+			"tool_name":       "wait",
+			"tool_input":      map[string]any{"ids": []string{"agent-wright"}},
+			"tool_response":   map[string]any{"status": "completed"},
+		},
 	} {
 		hook := "agent-dispatch"
 		if payload["hook_event_name"] == "SubagentStart" {

package/engine/tests/parity_reconcile_test.go

@@ -71,6 +71,9 @@ func TestParityReconcile(t *testing.T) {
 	t.Run("close-window", func(t *testing.T) {
 		work := newRepo(t)
 		snapshot(t, work)
+		if out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "check", "feat"); code != 0 {
+			t.Fatalf("pre-close reconcile check = %d, want 0\n%s", code, out)
+		}
 		out, code := runArgv(t, work, libRootEnv(work), "", binPath, "reconcile", "close", "feat")
 		assertGolden(t, out, code)
 	})
@@ -78,7 +81,7 @@ func TestParityReconcile(t *testing.T) {
 	t.Run("not-git", func(t *testing.T) {
 		work := t.TempDir()
 		makeFeatureDir(t, work, "feat")
-		check(t, work) // exit 0
+		check(t, work) // fail closed outside Git
 	})
 
 	t.Run("bad-mode", func(t *testing.T) {