devrites 3.2.2 → 3.2.4

package/engine/hooks_workspace.go

@@ -465,14 +465,10 @@ func hookA1Guard(h harness.Harness, stdin io.Reader, stdout, stderr io.Writer) i
 	if !ok {
 		return exitOK
 	}
-	// The guard is active between a reconcile snapshot and its check. Inline
-	// fallback makes the orchestrator the expected writer.
+	// The guard is active between a reconcile snapshot and its check.
 	if !wsIsFile(filepath.Join(dir, ".reconcile-base")) {
 		return exitOK
 	}
-	if wsIsFile(filepath.Join(dir, ".reconcile-inline")) {
-		return exitOK
-	}
 
 	in := h.ParseGuardInput(bytes.NewReader(data))
 	if !isEditTool(in.ToolName) {
@@ -562,9 +558,15 @@ func hookWrightScope(h harness.Harness, stdin io.Reader, stdout, stderr io.Write
 		return exitOK
 	}
 	in := h.ParseGuardInput(bytes.NewReader(data))
-	kind := devritesAgent(in.AgentType)
+	kind := devritesAgentForGuard(h, in)
+	genericCompat := os.Getenv("DEVRITES_CODEX_GENERIC_AGENT_COMPAT") == "1"
+	if in.AgentType == "" && in.AgentID == "" {
+		if code, handled := guardRootBuildWindow(h, data, in, stdout, stderr); handled {
+			return code
+		}
+	}
 	if kind == devritesAgentNone &&
-		os.Getenv("DEVRITES_CODEX_GENERIC_AGENT_COMPAT") == "1" &&
+		genericCompat &&
 		in.AgentType == "" {
 		return exitOK
 	}
@@ -617,9 +619,6 @@ func hookWrightScope(h harness.Harness, stdin io.Reader, stdout, stderr io.Write
 		if !wsIsFile(filepath.Join(dir, ".reconcile-base")) {
 			return exitOK
 		}
-		if wsIsFile(filepath.Join(dir, ".reconcile-inline")) {
-			return denyWright(h, stdout, stderr, wrightForbiddenReason, drvreason.HookWrightForbiddenDenied)
-		}
 		active = true
 	}
 
@@ -1009,6 +1008,75 @@ func denyOrObserveWright(h harness.Harness, stdout, stderr io.Writer, dir string
 	return exitOK
 }
 
+func guardRootBuildWindow(h harness.Harness, data []byte, in harness.GuardInput, stdout, stderr io.Writer) (int, bool) {
+	root, _, dir, ok := resolveWorkspace()
+	if !ok || !wsIsFile(filepath.Join(dir, ".reconcile-base")) {
+		return exitOK, false
+	}
+
+	if isAgentDispatchTool(in.ToolName) {
+		return exitOK, true
+	}
+
+	projectDir := filepath.Dir(root)
+	if isOpaqueExecutionTool(in.ToolName) {
+		return denyWright(h, stdout, stderr, a1DenyReason, drvreason.HookA1Denied), true
+	}
+	targets, suspicious := rootMutationTargets(data, in)
+	for _, target := range targets {
+		abs := target
+		if !filepath.IsAbs(abs) {
+			abs = filepath.Join(projectDir, abs)
+		}
+		abs = filepath.Clean(abs)
+		resolved, err := resolveRootMutationTarget(abs)
+		if err != nil {
+			return denyWright(h, stdout, stderr, a1DenyReason, drvreason.HookA1Denied), true
+		}
+		if !underDevrites(resolved, root) {
+			return denyWright(h, stdout, stderr, a1DenyReason, drvreason.HookA1Denied), true
+		}
+	}
+	if suspicious {
+		return denyWright(h, stdout, stderr, a1DenyReason, drvreason.HookA1Denied), true
+	}
+	if len(targets) > 0 {
+		return exitOK, true
+	}
+	return exitOK, false
+}
+
+func resolveRootMutationTarget(filename string) (string, error) {
+	info, err := os.Lstat(filename)
+	if err == nil && info.Mode()&os.ModeSymlink != 0 {
+		target, err := os.Readlink(filename)
+		if err != nil {
+			return "", err
+		}
+		if !filepath.IsAbs(target) {
+			target = filepath.Join(filepath.Dir(filename), target)
+		}
+		return safepath.ResolveExisting(target)
+	}
+	return safepath.ResolveExisting(filename)
+}
+
+func rootMutationTargets(data []byte, in harness.GuardInput) ([]string, bool) {
+	switch {
+	case isEditTool(in.ToolName):
+		targets := mutationToolPaths(data, in)
+		return targets, len(targets) == 0
+	case isShellTool(in.ToolName):
+		targets, opaque := wrightShellWritePaths(in.Command)
+		if len(targets) > 0 {
+			return targets, false
+		}
+		return nil, opaque && (reviewerMutateRe.MatchString(in.Command) || opaqueInterpreterRe.MatchString(in.Command))
+	default:
+		return nil, false
+	}
+}
+
 func denyWright(h harness.Harness, stdout, stderr io.Writer, message string, reasonID drvreason.ID) int {
 	out, err := h.PreToolDeny(message)
 	if err != nil {

package/engine/internal/forge/forge.go

@@ -256,8 +256,6 @@ type strategyFlags struct {
 	values map[CandidateID]string
 }
 
-func (s *strategyFlags) String() string { return "" }
-
 func (s *strategyFlags) Set(value string) error {
 	idText, text, ok := strings.Cut(value, "=")
 	id := CandidateID(idText)

package/engine/internal/harness/compliance.go

@@ -66,7 +66,7 @@ var complianceMatrix = []Surface{
 	{"Stop gate", Conditional, Conditional, "all rest points", "observe-only finding + manual host-specific rite-status", "yes", "high", "Both deliver Stop; stop-gate blocks with DEVRITES_STOP_GATE=enforce or DEVRITES_HOOK_PROFILE=strict."},
 	{"SubagentStart discipline injection", Native, Native, "review/build fan-out", "agent file preamble", "yes", "high", "subagent-orient wired on both."},
 	{"Skill invocation", Native, Adapter, "all public rites", "explicit file read", "yes", "high", "Claude: native /rite. Codex: $rite over the mirrored .agents/skills tree."},
-	{"Reviewer subagent dispatch", Native, Instruction, "review/seal confidence", "labelled inline pass", "partial", "medium", "Codex under-fires embedded spawns (openai/codex#23496); falls back to .codex/agents + a labelled inline pass."},
+	{"Reviewer subagent dispatch", Native, Adapter, "review/seal confidence", "HITL stop; no root inline review", "yes", "high", "Codex V2 requires the exact named role and verifies its durable parent/child rollout because V2 collaboration lifecycle calls bypass hooks; V1 keeps the guarded explorer fallback."},
 	{"Standards step-0 load", Native, Instruction, "all phases", "explicit standards read", "partial", "medium", "Claude: skill Reads core.md. Codex: an AGENTS.md directive to read it."},
 	{"Project activation", Native, Conditional, "Codex-only startup", "inspect hooks/config, decide trust, then rerun doctor", "yes", "medium", "Codex silently skips every .codex/ layer in an untrusted project; trust remains an operator decision after inspection."},
 }

package/engine/internal/harness/harness.go

@@ -199,6 +199,7 @@ type GuardInput struct {
 	ToolName     string
 	Command      string
 	FilePath     string
+	SessionID    string
 	AgentType    string
 	AgentID      string
 	ToolResponse string
@@ -209,6 +210,7 @@ type GuardInput struct {
 // way the shell hooks' `JSON.stringify` node parse does.
 func (h Harness) ParseGuardInput(r io.Reader) GuardInput {
 	var raw struct {
+		SessionID string `json:"session_id"`
 		ToolName  string `json:"tool_name"`
 		ToolInput struct {
 			Command  string `json:"command"`
@@ -237,6 +239,7 @@ func (h Harness) ParseGuardInput(r io.Reader) GuardInput {
 		ToolName:     raw.ToolName,
 		Command:      raw.ToolInput.Command,
 		FilePath:     firstNonEmpty(raw.ToolInput.FilePath, raw.ToolInput.Path),
+		SessionID:    raw.SessionID,
 		AgentType:    raw.AgentType,
 		AgentID:      raw.AgentID,
 		ToolResponse: resp,

package/engine/internal/lib/doubtcoverage.go

@@ -22,7 +22,7 @@ import (
 //
 // base is the project directory that contains the .devrites tree.
 //
-//	0  doubt covered, or not assessable (no log / no wright / inline build) → pass
+//	0  doubt covered, or not assessable (no log / no wright) → pass
 //	1  wright dispatch(es) but ZERO doubt → verify against decisions.md
 //	2  usage (no slug)
 //	3  decisions.md records a stood decision with `doubt: MISSING`
@@ -39,23 +39,13 @@ func DoubtCoverage(root string, args []string, stdout, stderr io.Writer) int {
 	dir := featureDir(root, slug)
 
 	// A recorded stood decision that was never doubted is the unambiguous
-	// failure: checked first, and on every path (it survives the inline-build
-	// case below, where the footprint heuristic cannot apply).
+	// failure: checked first, and on every path.
 	if dec, ok := readFileOK(filepath.Join(dir, "decisions.md")); ok && strings.Contains(dec, "doubt: MISSING") {
 		fmt.Fprintln(stdout, "doubt-coverage: SKIPPED: a '## Decisions stood' entry in decisions.md has doubt: MISSING.")
 		fmt.Fprintln(stdout, "A decision was stood and recorded but never doubted. Re-dispatch doubt or escalate.")
 		return 3
 	}
 
-	// Inline build (Task tool unavailable): the wright + doubt ran in-context,
-	// dispatching nothing, so the footprint heuristic does not apply: the
-	// decisions.md check above is the assessment.
-	if isFile(filepath.Join(dir, ".reconcile-inline")) {
-		fmt.Fprintln(stdout, "doubt-coverage: inline build (.reconcile-inline): footprint heuristic n/a; no MISSING")
-		fmt.Fprintln(stdout, "verdict recorded. Verify by hand that each stood decision carries a devrites-doubt verdict.")
-		return 0
-	}
-
 	f, err := os.Open(filepath.Join(dir, "footprint.log"))
 	if err != nil {
 		fmt.Fprintln(stdout, "doubt-coverage: no footprint log: nothing to assess (pass)")

package/engine/internal/lib/reconcile.go

@@ -22,10 +22,7 @@ const (
 	reconcileAllowlistName      = ".reconcile-allowlist"
 	reconcileCheckedName        = ".reconcile-checked"
 	reconcileDevritesName       = ".reconcile-devrites"
-	reconcileInlineName         = ".reconcile-inline"
 	reconcileObjectsName        = ".reconcile-objects"
-	reconcileObjectMarkerName   = ".devrites-baseline"
-	reconcileLegacyClaimedName  = ".reconcile-claimed"
 	defaultWrightAllowlistName  = ".wright-allowlist"
 	wrightAllowlistFileEnv      = "DEVRITES_WRIGHT_ALLOWLIST_FILE"
 	reconcileDevritesPathPrefix = ".devrites/"
@@ -63,14 +60,12 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 	base := filepath.Join(d, reconcileBaseName)
 	capturedAllowlist := filepath.Join(d, reconcileAllowlistName)
 	devritesSnapshot := filepath.Join(d, reconcileDevritesName)
-	inline := filepath.Join(d, reconcileInlineName)
 	objects := filepath.Join(d, reconcileObjectsName)
-	legacyClaimed := filepath.Join(d, reconcileLegacyClaimedName)
 	checked := filepath.Join(d, reconcileCheckedName)
 
 	closeWindow := func() error {
 		var failures []string
-		for _, privateFile := range []string{base, capturedAllowlist, devritesSnapshot, inline, legacyClaimed, checked} {
+		for _, privateFile := range []string{base, capturedAllowlist, devritesSnapshot, checked} {
 			if err := os.Remove(privateFile); err != nil && !os.IsNotExist(err) {
 				failures = append(failures, fmt.Sprintf("%s: %v", filepath.Base(privateFile), err))
 			}
@@ -136,7 +131,7 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 				fmt.Fprintf(stderr, "reconcile: cannot refresh wright allowlist: %v\n", err)
 				return 6
 			}
-			state, err := captureReconcileDevritesState(root, devritesSnapshot, activeObjects, checked, inline)
+			state, err := captureReconcileDevritesState(root, devritesSnapshot, activeObjects, checked)
 			if err != nil {
 				fmt.Fprintf(stderr, "reconcile: cannot refresh .devrites snapshot: %v\n", err)
 				return 6
@@ -180,17 +175,12 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 			fmt.Fprintf(stderr, "reconcile: cannot write snapshot: %v\n", err)
 			return 6
 		}
-		if err := os.WriteFile(filepath.Join(objects, reconcileObjectMarkerName), []byte(tree+"\n"), 0o600); err != nil {
-			_ = closeWindow()
-			fmt.Fprintf(stderr, "reconcile: cannot seal snapshot object database: %v\n", err)
-			return 6
-		}
 		if err := os.WriteFile(capturedAllowlist, renderWrightAllowlist(allowed), 0o600); err != nil {
 			_ = closeWindow()
 			fmt.Fprintf(stderr, "reconcile: cannot capture wright allowlist: %v\n", err)
 			return 6
 		}
-		state, err := captureReconcileDevritesState(root, devritesSnapshot, objects, checked, inline)
+		state, err := captureReconcileDevritesState(root, devritesSnapshot, objects, checked)
 		if err != nil {
 			_ = closeWindow()
 			fmt.Fprintf(stderr, "reconcile: cannot snapshot .devrites: %v\n", err)
@@ -225,7 +215,7 @@ func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
 			fmt.Fprintf(stderr, "reconcile: invalid .devrites snapshot: %v\n", err)
 			return 6
 		}
-		afterDevrites, err := captureReconcileDevritesState(root, devritesSnapshot, objects, checked, inline)
+		afterDevrites, err := captureReconcileDevritesState(root, devritesSnapshot, objects, checked)
 		if err != nil {
 			fmt.Fprintf(stderr, "reconcile: cannot compare .devrites: %v\n", err)
 			return 6
@@ -743,21 +733,6 @@ func loadReconcileBaseline(gitRoot, workspace string) (baseTree string, env []st
 	if baseTree == "" || strings.ContainsAny(baseTree, " \t\r\n") {
 		return "", nil, "", false, fmt.Errorf("%s does not contain one tree id", reconcileBaseName)
 	}
-	markerPath := filepath.Join(objectDir, reconcileObjectMarkerName)
-	markerInfo, err := os.Lstat(markerPath)
-	if err != nil {
-		return "", nil, "", false, fmt.Errorf("%s is not a sealed object database: %w", reconcileObjectsName, err)
-	}
-	if !markerInfo.Mode().IsRegular() {
-		return "", nil, "", false, fmt.Errorf("%s marker is not a regular file", reconcileObjectsName)
-	}
-	marker, err := os.ReadFile(markerPath)
-	if err != nil {
-		return "", nil, "", false, fmt.Errorf("read %s marker: %w", reconcileObjectsName, err)
-	}
-	if strings.TrimSpace(string(marker)) != baseTree {
-		return "", nil, "", false, fmt.Errorf("%s marker does not match %s", reconcileObjectsName, reconcileBaseName)
-	}
 	env, err = reconcileGitEnv(gitRoot, objectDir)
 	if err != nil {
 		return "", nil, "", false, err

package/engine/internal/lib/reconcile_test.go

@@ -207,9 +207,8 @@ func TestReconcileCheckFlagsUnauthorizedChange(t *testing.T) {
 	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
 		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
 	}
-	// A writer cannot self-authorize a path by reporting it after dispatch.
+	// A writer cannot change a path that was not authorized at dispatch.
 	writeFile(t, filepath.Join(gitRoot, "rogue.go"), "package main\n")
-	writeFile(t, filepath.Join(root, "work", "feat", reconcileLegacyClaimedName), "rogue.go\n")
 
 	code, out := runReconcile(t, root, "check", "feat")
 	if code != 5 {
@@ -383,14 +382,20 @@ func TestReconcileCheckFailsClosedWhenObjectDatabaseIsMissing(t *testing.T) {
 }
 
 func TestReconcileCheckFailsClosedWhenObjectDatabaseIsCorrupt(t *testing.T) {
-	newGitRepo(t)
+	gitRoot := newGitRepo(t)
 	root := workspace(t, "feat")
 	writeWrightAllowlist(t, root, "feat", "seed.go")
+	writeFile(t, filepath.Join(gitRoot, "seed.go"), "package seed\n")
 	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
 		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
 	}
-	marker := filepath.Join(featureDir(root, "feat"), reconcileObjectsName, reconcileObjectMarkerName)
-	if err := os.Remove(marker); err != nil {
+	baseData, err := os.ReadFile(filepath.Join(featureDir(root, "feat"), reconcileBaseName))
+	if err != nil {
+		t.Fatal(err)
+	}
+	baseTree := strings.TrimSpace(string(baseData))
+	treeObject := filepath.Join(featureDir(root, "feat"), reconcileObjectsName, baseTree[:2], baseTree[2:])
+	if err := os.Remove(treeObject); err != nil {
 		t.Fatal(err)
 	}
 
@@ -398,7 +403,7 @@ func TestReconcileCheckFailsClosedWhenObjectDatabaseIsCorrupt(t *testing.T) {
 	if code != 6 {
 		t.Fatalf("check = %d, want 6\n%s", code, out)
 	}
-	if !strings.Contains(out, "not a sealed object database") {
+	if !strings.Contains(out, "tree is unavailable") {
 		t.Fatalf("missing corrupt-object diagnostic:\n%s", out)
 	}
 }
@@ -502,23 +507,22 @@ func TestReconcileRefreshRequiresPriorCleanCheck(t *testing.T) {
 	}
 }
 
-func TestReconcileCloseSupportsInlineFallback(t *testing.T) {
+func TestReconcileCloseClearsPrivateWindowState(t *testing.T) {
 	newGitRepo(t)
 	root := workspace(t, "feat")
 	writeFile(t, filepath.Join(root, "work", "feat", reconcileBaseName), "stale\n")
-	writeFile(t, filepath.Join(root, "work", "feat", reconcileInlineName), "")
 	if err := os.MkdirAll(filepath.Join(root, "work", "feat", reconcileObjectsName), 0o755); err != nil {
 		t.Fatal(err)
 	}
 
 	code, out := runReconcile(t, root, "close", "feat")
 	if code != 0 {
-		t.Fatalf("inline fallback close = %d, want 0\n%s", code, out)
+		t.Fatalf("close = %d, want 0\n%s", code, out)
 	}
 	if !strings.Contains(out, "closed slice window") {
 		t.Errorf("expected close message:\n%s", out)
 	}
 	if isFile(filepath.Join(featureDir(root, "feat"), reconcileBaseName)) || isDir(filepath.Join(featureDir(root, "feat"), reconcileObjectsName)) {
-		t.Fatal("inline fallback close retained private baseline state")
+		t.Fatal("close retained private baseline state")
 	}
 }

package/engine/main.go

@@ -93,7 +93,8 @@ Hooks:
   hook orient             Emit SessionStart orientation for the active feature
   hook stop-gate          Refuse to end a turn at a provably inconsistent rest point
   hook reviewer-readonly  Deny every mutation/dispatch surface for read-only DevRites agents
-  hook subagent-orient    Inject the DevRites discipline into a spawned devrites-* subagent
+  hook agent-dispatch     Bind Codex spawn, start, wait, result, and reconcile receipts
+  hook subagent-orient    Inject DevRites discipline and bind a spawned specialist role
   hook cursor             Re-inject the active feature's cursor (UserPromptSubmit)
   hook statusline         One-line workspace HUD (settings.json statusLine)
   hook redwatch           Fail-on-red sentinel: set/clear .red after a test/build command
@@ -510,6 +511,8 @@ func cmdHook(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		return hookStopGate(h, stdin, stdout, stderr)
 	case "reviewer-readonly":
 		return hookReviewerReadonly(h, stdin, stdout, stderr)
+	case "agent-dispatch":
+		return hookAgentDispatch(h, stdin, stdout, stderr)
 	case "subagent-orient":
 		return hookSubagentOrient(h, stdin, stdout, stderr)
 	case "cursor":