devrites 3.2.6 → 3.2.8

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to DevRites are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and DevRites adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases are generated automatically by [semantic-release](https://semantic-release.gitbook.io/) from Conventional Commits on `main`.
 
+## [3.2.8](https://github.com/ViktorsBaikers/DevRites/compare/v3.2.7...v3.2.8) (2026-07-26)
+
+### Fixed
+
+* **devrites:** prevent reconcile self-invalidation ([161ed18](https://github.com/ViktorsBaikers/DevRites/commit/161ed187e600dfc92623b22db5cd7f0824408d1a))
+
+## [3.2.7](https://github.com/ViktorsBaikers/DevRites/compare/v3.2.6...v3.2.7) (2026-07-26)
+
+### Fixed
+
+* **agents:** enforce conditional v2 dispatch ([f4169d4](https://github.com/ViktorsBaikers/DevRites/commit/f4169d41c456f352172be8d96afdcdc69800d849))
+* **ci:** satisfy staticcheck error style ([0023265](https://github.com/ViktorsBaikers/DevRites/commit/00232656283647db8d94b2ed61dccb1629091b25))
+
 ## [3.2.6](https://github.com/ViktorsBaikers/DevRites/compare/v3.2.5...v3.2.6) (2026-07-25)
 
 ### Changed

package/README.md

@@ -25,7 +25,7 @@ final commit, push, and tag, and it requires a typed `GO` confirmation.
 Unattended runs may create local WIP checkpoint commits along the way, but only
 Ship collapses and pushes them.
 
-**Status:** [`v3.2.6`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.2.6): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v3.2.8`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v3.2.8): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 ## Quick start
 

package/docs/orchestration.md

@@ -69,6 +69,16 @@ Each dispatch follows the retained-baseline sequence:
 5. After proof and decision checks pass, `reconcile close` retires the private
    window; only then does the root write canonical records.
 
+The canonical-state fingerprint excludes root-owned operational records:
+`timeline.jsonl`, feature `events.jsonl`, a valid `recovery-attempts.jsonl`,
+the redwatch sentinel, automatic handoff snapshots, and hidden hook observation
+logs. Those records cannot grant source authority or invalidate a writer result
+merely because the engine or a hook wrote them. Unknown or canonical
+`.devrites` paths remain fail-closed, and recovery ledgers must still parse
+before reconciliation can pass. Gate-authoritative operational state such as
+recovery attempts and `.red` remains enforced by its owning gate. Checks also
+normalize these paths out of retained snapshots created by older engines.
+
 On retry, the root may add only an accepted still-in-slice path, then runs
 `reconcile snapshot` again. This refreshes the dispatch boundary while
 preserving the original slice baseline. The same objective root cause has a

package/engine/hooks_agent_dispatch.go

@@ -25,6 +25,7 @@ const (
 	agentDispatchStateVersion = "devrites-agent-dispatch/v1"
 	agentDispatchStateDir     = "devrites-agent-dispatch-v1"
 	agentDispatchMetadataRole = "devrites-skill-contract-error"
+	agentDispatchSkillGuard   = "devrites-skill-dispatch-guard"
 	maxCodexRolloutLine       = 8 << 20
 )
 
@@ -309,22 +310,24 @@ func requiredAgentRolesFromSkill(path string) ([]string, error) {
 	return roles, nil
 }
 
-func requiredRolesInPrompt(root, text string) ([]string, error) {
+func requiredRolesInPrompt(root, text string) ([]string, bool, error) {
 	seen := map[string]struct{}{}
+	skillInvoked := false
 	skillsDir := filepath.Join(filepath.Dir(root), ".agents", "skills")
 	for _, match := range skillInvocationRe.FindAllStringSubmatch(text, -1) {
 		skill := strings.ToLower(match[1])
 		path := filepath.Join(skillsDir, skill, "SKILL.md")
 		if !safepath.WithinResolved(path, skillsDir) {
-			return nil, fmt.Errorf("unsafe skill path for %s", skill)
+			return nil, false, fmt.Errorf("unsafe skill path for %s", skill)
 		}
 		roles, err := requiredAgentRolesFromSkill(path)
 		if os.IsNotExist(err) {
 			continue
 		}
 		if err != nil {
-			return nil, fmt.Errorf("%s: %w", skill, err)
+			return nil, false, fmt.Errorf("%s: %w", skill, err)
 		}
+		skillInvoked = true
 		for _, role := range roles {
 			seen[role] = struct{}{}
 		}
@@ -334,7 +337,7 @@ func requiredRolesInPrompt(root, text string) ([]string, error) {
 		roles = append(roles, role)
 	}
 	sort.Strings(roles)
-	return roles, nil
+	return roles, skillInvoked, nil
 }
 
 func expectedAgentType(role string) string {
@@ -488,6 +491,19 @@ func durableCodexV2DispatchAttempts(
 	}
 	var attempts []*agentDispatchAttempt
 	for _, spawn := range spawns {
+		if !devritesAgentNameRe.MatchString(spawn.Role) || spawn.Role == agentDispatchSkillGuard {
+			if strings.TrimSpace(spawn.Result) != "" {
+				return nil, fmt.Errorf("codex V2 completed a default or non-DevRites child during a DevRites skill turn; %s", conditionalDispatchInstruction())
+			}
+			continue
+		}
+		armed[spawn.Role] = struct{}{}
+		attempt := &agentDispatchAttempt{
+			Role:      spawn.Role,
+			AgentType: spawn.Role,
+			Started:   true,
+		}
+		attempts = append(attempts, attempt)
 		if strings.TrimSpace(spawn.Result) == "" || !lineBetween(waitLines, spawn.SpawnLine, spawn.ResultLine) {
 			continue
 		}
@@ -504,24 +520,17 @@ func durableCodexV2DispatchAttempts(
 		if childID == "" || strings.TrimSpace(childResult) == "" {
 			continue
 		}
-		windowID := ""
+		attempt.AgentID = childID
+		attempt.Stopped = true
+		attempt.Waited = true
 		if spawn.Role == "devrites-slice-wright" {
-			windowID = currentReconcileWindowID()
-			if windowID == "" || !reconcileWindowPredates(spawn.SpawnedAt) {
+			attempt.WindowID = currentReconcileWindowID()
+			if attempt.WindowID == "" || !reconcileWindowPredates(spawn.SpawnedAt) {
 				continue
 			}
 		}
 		sum := sha256.Sum256([]byte(childResult))
-		attempts = append(attempts, &agentDispatchAttempt{
-			Role:         spawn.Role,
-			AgentType:    spawn.Role,
-			AgentID:      childID,
-			WindowID:     windowID,
-			Started:      true,
-			Stopped:      true,
-			Waited:       true,
-			ResultSHA256: hex.EncodeToString(sum[:]),
-		})
+		attempt.ResultSHA256 = hex.EncodeToString(sum[:])
 	}
 	return attempts, nil
 }
@@ -570,6 +579,7 @@ func readCodexV2ParentRollout(
 	spawns := map[string]*codexV2Spawn{}
 	var waitLines []int
 	metaSeen := false
+	_, guarded := armed[agentDispatchSkillGuard]
 	scanner := bufio.NewScanner(file)
 	scanner.Buffer(make([]byte, 64<<10), maxCodexRolloutLine)
 	for lineNumber := 1; scanner.Scan(); lineNumber++ {
@@ -604,9 +614,9 @@ func readCodexV2ParentRollout(
 			if json.Unmarshal([]byte(record.Payload.Arguments), &args) != nil {
 				continue
 			}
-			if _, required := armed[args.AgentType]; !required ||
-				args.TaskName == "" || strings.Contains(args.TaskName, "/") ||
-				args.ForkTurns != "none" {
+			_, required := armed[args.AgentType]
+			if (!required && !guarded) || args.TaskName == "" ||
+				strings.Contains(args.TaskName, "/") || args.ForkTurns != "none" {
 				continue
 			}
 			spawnedAt, err := time.Parse(time.RFC3339Nano, record.Timestamp)
@@ -797,9 +807,23 @@ func roleSatisfied(role, windowID string, attempts []*agentDispatchAttempt) bool
 	return false
 }
 
+func dispatchInstruction(role string) string {
+	return fmt.Sprintf(
+		"On MultiAgent V2 call spawn_agent with agent_type=%s, a unique task_name, and fork_turns=\"none\" so Codex loads .codex/agents/%s.toml natively. GPT-5.6 V2 may omit agent_type from the visible tool schema even though the runtime accepts it; send agent_type anyway rather than using a default child. On V1 use agent_type=%s with fork_turns=\"none\" and name that role TOML in the message. Wait for the returned child and use its non-empty result. Do not call wait before spawn_agent and do not synthesize the agent result.",
+		role, role, expectedAgentType(role),
+	)
+}
+
+func conditionalDispatchInstruction() string {
+	return "CONDITIONAL DISPATCH RULE — If this skill reaches a child-agent step, call spawn_agent with the exact named agent_type=devrites-<role> specified by the skill, a unique task_name, and fork_turns=\"none\". GPT-5.6 V2 may omit agent_type from the visible tool schema; send agent_type anyway and never use a default child. Wait for the returned child and use its non-empty result."
+}
+
 func incompleteDispatchReason(armed map[string]struct{}, attempts []*agentDispatchAttempt) string {
 	roles := make([]string, 0, len(armed))
 	for role := range armed {
+		if role == agentDispatchSkillGuard {
+			continue
+		}
 		if !roleSatisfied(role, "", attempts) {
 			roles = append(roles, role)
 		}
@@ -812,10 +836,7 @@ func incompleteDispatchReason(armed map[string]struct{}, attempts []*agentDispat
 	if role == agentDispatchMetadataRole {
 		return "DevRites could not determine this skill's required agents because its installed required-agent-roles contract is invalid. Reinstall or repair the DevRites skill pack before continuing."
 	}
-	return fmt.Sprintf(
-		"DevRites dispatch for %s is not complete. On MultiAgent V2 call spawn_agent with agent_type=%s, a unique task_name, and fork_turns=\"none\" so Codex loads .codex/agents/%s.toml natively. GPT-5.6 V2 may omit agent_type from the visible tool schema even though the runtime accepts it; send agent_type anyway rather than using a default child. On V1 use agent_type=%s with fork_turns=\"none\" and name that role TOML in the message. Wait for the returned child and use its non-empty result. Do not call wait before spawn_agent and do not synthesize the agent result.",
-		role, role, role, expectedAgentType(role),
-	)
+	return fmt.Sprintf("DevRites dispatch for %s is not complete. %s", role, dispatchInstruction(role))
 }
 
 func preToolDeny(h harness.Harness, reason string, stdout, stderr io.Writer) int {
@@ -888,7 +909,7 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 
 	switch in.HookEventName {
 	case "UserPromptSubmit":
-		roles, rolesErr := requiredRolesInPrompt(root, in.Prompt)
+		roles, skillInvoked, rolesErr := requiredRolesInPrompt(root, in.Prompt)
 		if rolesErr != nil {
 			if err := appendAgentDispatchEvent(root, in.SessionID, agentDispatchEvent{
 				Event:  "armed",
@@ -899,6 +920,15 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 			}
 			return stopDispatchBlock(h, "DevRites could not read the required agent roles: "+rolesErr.Error(), stdout, stderr)
 		}
+		if skillInvoked {
+			if err := appendAgentDispatchEvent(root, in.SessionID, agentDispatchEvent{
+				Event:  "armed",
+				TurnID: in.TurnID,
+				Role:   agentDispatchSkillGuard,
+			}); err != nil {
+				return stopDispatchBlock(h, "DevRites could not arm the skill dispatch guard: "+err.Error(), stdout, stderr)
+			}
+		}
 		for _, role := range roles {
 			if err := appendAgentDispatchEvent(root, in.SessionID, agentDispatchEvent{
 				Event:  "armed",
@@ -909,7 +939,21 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 			}
 		}
 		if len(roles) > 0 {
-			fmt.Fprintf(stdout, "DevRites: this turn requires a confirmed %s subagent start, wait, and non-empty result; a success phrase is not evidence.", strings.Join(roles, ", "))
+			instructions := make([]string, 0, len(roles))
+			for _, role := range roles {
+				instructions = append(instructions, dispatchInstruction(role))
+			}
+			fmt.Fprintf(
+				stdout,
+				"MANDATORY DISPATCH THIS TURN — At the skill's dispatch step, execute every required child before finishing or claiming completion; a success phrase is not evidence.\n%s",
+				strings.Join(instructions, "\n"),
+			)
+		}
+		if skillInvoked {
+			if len(roles) > 0 {
+				fmt.Fprintln(stdout)
+			}
+			fmt.Fprint(stdout, conditionalDispatchInstruction())
 		}
 		return exitOK
 
@@ -949,7 +993,8 @@ func hookAgentDispatch(h harness.Harness, stdin io.Reader, stdout, stderr io.Wri
 			return stopDispatchBlock(h, "DevRites could not verify the required agent dispatch: "+err.Error(), stdout, stderr)
 		}
 		armed, attempts := dispatchTurnState(events, in.TurnID)
-		if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+		_, guarded := armed[agentDispatchSkillGuard]
+		if reason := incompleteDispatchReason(armed, attempts); reason != "" || guarded && len(attempts) == 0 {
 			durable, durableErr := durableCodexV2DispatchAttempts(
 				root, in.SessionID, in.TurnID, armed,
 			)
@@ -979,10 +1024,17 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 	if isAgentDispatchTool(in.ToolName) {
 		agentType := in.ToolInput.AgentType
 		if agentType == "" {
-			if len(armed) == 0 {
-				return exitOK
+			roles := explicitRolesInText(in.ToolInput.Message + "\n" + in.ToolInput.TaskName)
+			if len(roles) == 1 {
+				return preToolDeny(h, "DevRites conditional dispatch requires the exact named specialist. "+dispatchInstruction(roles[0]), stdout, stderr)
+			}
+			if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+				return preToolDeny(h, reason, stdout, stderr)
 			}
-			return preToolDeny(h, "DevRites MultiAgent V2 dispatch requires the exact named agent_type=devrites-<role>; omitting agent_type does not load the specialist role contract.", stdout, stderr)
+			if _, guarded := armed[agentDispatchSkillGuard]; guarded {
+				return preToolDeny(h, conditionalDispatchInstruction(), stdout, stderr)
+			}
+			return exitOK
 		}
 		role := ""
 		if strings.HasPrefix(agentType, "devrites-") {
@@ -995,11 +1047,20 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 		}
 		if role == "" {
 			if agentType == "explorer" || agentType == "worker" {
-				if len(armed) == 0 {
+				if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+					return preToolDeny(h, reason, stdout, stderr)
+				}
+				if _, guarded := armed[agentDispatchSkillGuard]; !guarded {
 					return exitOK // Unrelated generic subagent in a DevRites repository.
 				}
 				return preToolDeny(h, "DevRites generic dispatch must name exactly one .codex/agents/devrites-<role>.toml contract.", stdout, stderr)
 			}
+			if reason := incompleteDispatchReason(armed, attempts); reason != "" {
+				return preToolDeny(h, reason, stdout, stderr)
+			}
+			if _, guarded := armed[agentDispatchSkillGuard]; guarded {
+				return preToolDeny(h, conditionalDispatchInstruction(), stdout, stderr)
+			}
 			return exitOK
 		}
 		instructions, contractErr := agentRoleDeveloperInstructions(root, role)
@@ -1016,7 +1077,7 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 			return preToolDeny(h, "devrites-slice-wright requires the generic worker identity and exact wright allowlist.", stdout, stderr)
 		}
 		if agentType != "" && agentType != role && agentType != expectedAgentType(role) {
-			return preToolDeny(h, fmt.Sprintf("DevRites role %s requires agent_type=%s or its exposed named role.", role, expectedAgentType(role)), stdout, stderr)
+			return preToolDeny(h, fmt.Sprintf("DevRites role %s requires agent_type=%s or its exposed named role. %s", role, expectedAgentType(role), dispatchInstruction(role)), stdout, stderr)
 		}
 		if in.ToolUseID == "" {
 			return preToolDeny(h, "DevRites cannot bind a spawn without tool_use_id.", stdout, stderr)
@@ -1057,7 +1118,11 @@ func hookAgentDispatchPreTool(h harness.Harness, root string, in agentDispatchHo
 			}
 		}
 		if len(started) == 0 {
-			return preToolDeny(h, incompleteDispatchReason(armed, attempts), stdout, stderr)
+			reason := incompleteDispatchReason(armed, attempts)
+			if reason == "" {
+				reason = conditionalDispatchInstruction()
+			}
+			return preToolDeny(h, reason, stdout, stderr)
 		}
 		targets := in.ToolInput.ReceiverThreadIDs
 		if len(targets) == 0 {

package/engine/internal/lib/reconcile.go

@@ -215,6 +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
 		}
+		beforeDevrites = withoutRootOwnedOperationalState(beforeDevrites)
 		afterDevrites, err := captureReconcileDevritesState(root, devritesSnapshot, objects, checked)
 		if err != nil {
 			fmt.Fprintf(stderr, "reconcile: cannot compare .devrites: %v\n", err)
@@ -465,6 +466,13 @@ func captureDevritesState(root string, ignoredPaths ...string) ([]devritesStateE
 			}
 			return nil
 		}
+		operational, err := reconcileRootOwnedOperationalFile(filename, rel, entry)
+		if err != nil {
+			return err
+		}
+		if operational {
+			return nil
+		}
 
 		fingerprint, err := devritesFingerprint(filename, entry)
 		if err != nil {
@@ -483,6 +491,61 @@ func captureDevritesState(root string, ignoredPaths ...string) ([]devritesStateE
 	return state, nil
 }
 
+// reconcileRootOwnedOperationalFile excludes engine/root-owned operational
+// records from the writer delta. Their owning hooks/gates validate them where
+// needed; root activity must not be attributed to the slice writer.
+func reconcileRootOwnedOperationalFile(filename, rel string, entry os.DirEntry) (bool, error) {
+	if !entry.Type().IsRegular() || !reconcileRootOwnedOperationalPath(rel) {
+		return false, nil
+	}
+	rel = filepath.ToSlash(filepath.Clean(rel))
+	parts := strings.Split(rel, "/")
+	if len(parts) == 3 && parts[2] == recoveryAttemptsFile {
+		if _, err := readRecoveryAttempts(filename); err != nil {
+			return false, fmt.Errorf("validate root-owned recovery ledger %s: %w", rel, err)
+		}
+	}
+	return true, nil
+}
+
+func reconcileRootOwnedOperationalPath(rel string) bool {
+	rel = filepath.ToSlash(filepath.Clean(rel))
+	if rel == "timeline.jsonl" {
+		return true
+	}
+	parts := strings.Split(rel, "/")
+	if len(parts) != 3 ||
+		(parts[0] != "work" && parts[0] != "features") ||
+		!slugToken.MatchString(parts[1]) {
+		return false
+	}
+	switch parts[2] {
+	case "events.jsonl",
+		recoveryAttemptsFile,
+		".red",
+		"handoff.md",
+		".a1-guard.log",
+		".reviewer-ro.log",
+		".stop-gate.log",
+		".wright-scope.log":
+		return true
+	default:
+		return false
+	}
+}
+
+func withoutRootOwnedOperationalState(state []devritesStateEntry) []devritesStateEntry {
+	filtered := state[:0]
+	for _, item := range state {
+		if strings.HasPrefix(item.Fingerprint, "file:") &&
+			reconcileRootOwnedOperationalPath(item.Path) {
+			continue
+		}
+		filtered = append(filtered, item)
+	}
+	return filtered
+}
+
 func devritesFingerprint(filename string, entry os.DirEntry) (string, error) {
 	info, err := entry.Info()
 	if err != nil {

package/engine/internal/lib/reconcile_test.go

@@ -361,6 +361,158 @@ func TestReconcileRejectsDevritesMutation(t *testing.T) {
 	}
 }
 
+func TestReconcileAllowsRootOwnedOperationalFiles(t *testing.T) {
+	newGitRepo(t)
+	root := workspace(t, "feat")
+	dir := featureDir(root, "feat")
+	writeWrightAllowlist(t, root, "feat", "seed.go")
+	if code := Stuck(root, []string{"log", "feat", "dispatch", "SLICE-010"}, &bytes.Buffer{}, &bytes.Buffer{}); code != 0 {
+		t.Fatalf("stuck log = %d, want 0", code)
+	}
+	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
+		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
+	}
+
+	writeFile(t, filepath.Join(root, "timeline.jsonl"), "telemetry\n")
+	writeFile(t, filepath.Join(dir, "events.jsonl"), "telemetry\n")
+	writeFile(t, filepath.Join(dir, ".a1-guard.log"), "WOULD-BLOCK\n")
+	writeFile(t, filepath.Join(dir, ".reviewer-ro.log"), "WOULD-BLOCK\n")
+	writeFile(t, filepath.Join(dir, ".stop-gate.log"), "WOULD-BLOCK\n")
+	writeFile(t, filepath.Join(dir, ".wright-scope.log"), "WOULD-BLOCK\n")
+	writeFile(t, filepath.Join(dir, ".red"), "npm test\n")
+	writeFile(t, filepath.Join(dir, "handoff.md"), "## Handoff snapshot\n")
+	if code := RecoveryAttempts(
+		root,
+		[]string{"record", "--class", "proof_tool_defect", "reconcile telemetry", "changed logs", "feat"},
+		&bytes.Buffer{},
+		&bytes.Buffer{},
+	); code != 0 {
+		t.Fatalf("recovery record = %d, want 0", code)
+	}
+
+	if code, out := runReconcile(t, root, "check", "feat"); code != 0 {
+		t.Fatalf("check = %d, want 0\n%s", code, out)
+	}
+	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
+		t.Fatalf("refresh = %d, want 0\n%s", code, out)
+	}
+
+	writeFile(t, filepath.Join(dir, ".unknown.log"), "not engine-owned\n")
+	code, out := runReconcile(t, root, "check", "feat")
+	if code != 5 {
+		t.Fatalf("check after canonical mutation = %d, want 5\n%s", code, out)
+	}
+	if !strings.Contains(out, ".devrites/work/feat/.unknown.log") {
+		t.Fatalf("canonical mutation missing from output:\n%s", out)
+	}
+}
+
+func TestReconcileAcceptsLegacyOperationalFingerprints(t *testing.T) {
+	newGitRepo(t)
+	root := workspace(t, "feat")
+	dir := featureDir(root, "feat")
+	writeWrightAllowlist(t, root, "feat", "seed.go")
+	writeFile(t, filepath.Join(root, "timeline.jsonl"), "before\n")
+	writeFile(t, filepath.Join(dir, "events.jsonl"), "before\n")
+	writeFile(t, filepath.Join(dir, ".a1-guard.log"), "before\n")
+	writeFile(t, filepath.Join(dir, ".red"), "before\n")
+	writeFile(t, filepath.Join(dir, "handoff.md"), "before\n")
+	if code := RecoveryAttempts(
+		root,
+		[]string{"record", "--class", "proof_tool_defect", "reconcile telemetry", "first failure", "feat"},
+		&bytes.Buffer{},
+		&bytes.Buffer{},
+	); code != 0 {
+		t.Fatalf("initial recovery record = %d, want 0", code)
+	}
+	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
+		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
+	}
+
+	snapshotPath := filepath.Join(dir, reconcileDevritesName)
+	state, err := readDevritesState(snapshotPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	have := make(map[string]bool, len(state))
+	for _, item := range state {
+		have[item.Path] = true
+	}
+	for _, path := range []string{
+		"timeline.jsonl",
+		"work/feat/events.jsonl",
+		"work/feat/.a1-guard.log",
+		"work/feat/.red",
+		"work/feat/handoff.md",
+		"work/feat/recovery-attempts.jsonl",
+	} {
+		if !have[path] {
+			state = append(state, devritesStateEntry{Path: path, Fingerprint: "file:0600:legacy"})
+		}
+	}
+	if err := writeDevritesState(snapshotPath, state); err != nil {
+		t.Fatal(err)
+	}
+
+	writeFile(t, filepath.Join(root, "timeline.jsonl"), "after\n")
+	writeFile(t, filepath.Join(dir, "events.jsonl"), "after\n")
+	writeFile(t, filepath.Join(dir, ".a1-guard.log"), "after\n")
+	writeFile(t, filepath.Join(dir, ".red"), "after\n")
+	writeFile(t, filepath.Join(dir, "handoff.md"), "after\n")
+	if code := RecoveryAttempts(
+		root,
+		[]string{"record", "--class", "proof_tool_defect", "reconcile telemetry", "second failure", "feat"},
+		&bytes.Buffer{},
+		&bytes.Buffer{},
+	); code != 0 {
+		t.Fatalf("second recovery record = %d, want 0", code)
+	}
+
+	if code, out := runReconcile(t, root, "check", "feat"); code != 0 {
+		t.Fatalf("check = %d, want 0\n%s", code, out)
+	}
+}
+
+func TestReconcileRejectsCorruptRootOwnedRecoveryLedger(t *testing.T) {
+	newGitRepo(t)
+	root := workspace(t, "feat")
+	writeWrightAllowlist(t, root, "feat", "seed.go")
+	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
+		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
+	}
+	writeFile(t, filepath.Join(featureDir(root, "feat"), recoveryAttemptsFile), "{not-json}\n")
+
+	code, out := runReconcile(t, root, "check", "feat")
+	if code != 6 {
+		t.Fatalf("check = %d, want 6\n%s", code, out)
+	}
+	if !strings.Contains(out, "validate root-owned recovery ledger") {
+		t.Fatalf("corrupt recovery ledger missing from output:\n%s", out)
+	}
+}
+
+func TestReconcileRootOwnedOperationalPathsAreExact(t *testing.T) {
+	for _, path := range []string{
+		"timeline.jsonl",
+		"work/feat/.red",
+		"features/feat/events.jsonl",
+	} {
+		if !reconcileRootOwnedOperationalPath(path) {
+			t.Errorf("%q should be root-owned operational state", path)
+		}
+	}
+	for _, path := range []string{
+		"work/feat/.unknown.log",
+		"work/feat/action.log",
+		"work/feat/footprint.log",
+		"work/feat/state.md",
+	} {
+		if reconcileRootOwnedOperationalPath(path) {
+			t.Errorf("%q must remain fingerprinted", path)
+		}
+	}
+}
+
 func TestReconcileCheckFailsClosedWhenObjectDatabaseIsMissing(t *testing.T) {
 	newGitRepo(t)
 	root := workspace(t, "feat")

package/engine/tests/hook_test.go

@@ -899,6 +899,18 @@ func writeCodexSkillContract(t *testing.T, root, skill, roles string) {
 	}
 }
 
+func writeCodexConditionalSkillContract(t *testing.T, root, skill, role string) {
+	t.Helper()
+	dir := filepath.Join(filepath.Dir(root), ".agents", "skills", skill)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	contract := "---\nname: " + skill + "\ndescription: Test skill.\nrequired-agent-roles: none\n---\n\nConditionally dispatch `" + role + "` when needed.\n"
+	if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte(contract), 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func writeCodexV2Rollouts(
 	t *testing.T,
 	codeHome, projectRoot, sessionID, turnID, role, taskName string,
@@ -1096,6 +1108,156 @@ func TestCodexAgentDispatchArmsInstalledSkillRequirements(t *testing.T) {
 	}
 }
 
+func TestCodexAgentDispatchPromptGivesExactNamedCallBeforeCompletion(t *testing.T) {
+	root := newWorkspace(t)
+	role := "devrites-plan-drafter"
+	writeCodexAgentContract(t, root, role)
+	writeCodexSkillContract(t, root, "rite-plan", role)
+
+	out, stderr, code := runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "UserPromptSubmit",
+		"session_id":      "session-plan-drafter-guidance",
+		"turn_id":         "turn-plan-drafter-guidance",
+		"prompt":          "$rite-plan repair",
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+	if code != 0 {
+		t.Fatalf("arm exit=%d stderr=%s", code, stderr)
+	}
+	for _, want := range []string{
+		"MANDATORY DISPATCH THIS TURN",
+		"spawn_agent",
+		"agent_type=" + role,
+		"unique task_name",
+		`fork_turns="none"`,
+		".codex/agents/" + role + ".toml",
+		"send agent_type anyway",
+		"Wait for the returned child",
+	} {
+		if !strings.Contains(out, want) {
+			t.Fatalf("initial dispatch guidance omitted %q:\n%s", want, out)
+		}
+	}
+}
+
+func TestCodexConditionalAgentDispatchRejectsDefaultAndArmsNamedRole(t *testing.T) {
+	root := newWorkspace(t)
+	role := "devrites-proof-runner"
+	writeCodexAgentContract(t, root, role)
+	writeCodexConditionalSkillContract(t, root, "rite-polish", role)
+	sessionID, turnID := "session-conditional-role", "turn-conditional-role"
+
+	out, stderr, code := runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "UserPromptSubmit",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"prompt":          "$rite-polish",
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+	if code != 0 {
+		t.Fatalf("arm exit=%d stderr=%s", code, stderr)
+	}
+	for _, want := range []string{
+		"CONDITIONAL DISPATCH RULE",
+		"exact named agent_type=devrites-<role>",
+		`fork_turns="none"`,
+		"send agent_type anyway",
+		"never use a default child",
+	} {
+		if !strings.Contains(out, want) {
+			t.Fatalf("conditional dispatch guidance omitted %q:\n%s", want, out)
+		}
+	}
+
+	for _, agentType := range []string{"", "default"} {
+		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":     "default-" + agentType,
+			"tool_input": map[string]any{
+				"agent_type": agentType,
+				"task_name":  "conditional_default",
+				"fork_turns": "none",
+				"message":    "Run the conditional DevRites check.",
+			},
+		}), nil, "hook", "agent-dispatch", "--harness=codex")
+		if code != 0 {
+			t.Fatalf("default spawn exit=%d stderr=%s", code, stderr)
+		}
+		if decision, reason := parsePermissionDecision(t, out); decision != "deny" ||
+			!strings.Contains(reason, "exact named agent_type=devrites-<role>") {
+			t.Fatalf("conditional default child not denied: decision=%q reason=%q out=%s", decision, reason, out)
+		}
+	}
+
+	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":     "missing-named-type",
+		"tool_input": map[string]any{
+			"task_name":  "conditional_missing_type",
+			"fork_turns": "none",
+			"message":    "Read .codex/agents/" + role + ".toml and run the check.",
+		},
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+	if code != 0 {
+		t.Fatalf("missing type spawn exit=%d stderr=%s", code, stderr)
+	}
+	if decision, reason := parsePermissionDecision(t, out); decision != "deny" ||
+		!strings.Contains(reason, "agent_type="+role) ||
+		!strings.Contains(reason, "send agent_type anyway") {
+		t.Fatalf("missing named type did not get exact retry: decision=%q reason=%q out=%s", decision, reason, out)
+	}
+
+	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":     "named-conditional",
+		"tool_input": map[string]any{
+			"agent_type": role,
+			"task_name":  "conditional_proof",
+			"fork_turns": "none",
+			"message":    "Run the conditional DevRites check.",
+		},
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+	if code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("named conditional spawn rejected: exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+
+	out, stderr, code = runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "Stop",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+	if code != 0 || !strings.Contains(out, "DevRites dispatch for "+role+" is not complete") {
+		t.Fatalf("named conditional spawn was not armed: exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+}
+
+func TestCodexAgentDispatchAllowsDefaultChildOutsideSkillTurn(t *testing.T) {
+	root := newWorkspace(t)
+	out, stderr, code := runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "PreToolUse",
+		"session_id":      "session-unrelated-default",
+		"turn_id":         "turn-unrelated-default",
+		"tool_name":       "spawn_agent",
+		"tool_use_id":     "unrelated-default",
+		"tool_input": map[string]any{
+			"agent_type": "default",
+			"task_name":  "unrelated",
+			"fork_turns": "all",
+			"message":    "Handle an unrelated bounded task.",
+		},
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+	if code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("unrelated default child was rejected: exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+}
+
 func TestCodexAgentDispatchRejectsInvalidInstalledSkillRequirements(t *testing.T) {
 	root := newWorkspace(t)
 	writeCodexSkillContract(t, root, "rite-vet", "root-inline-reviewer")
@@ -1406,6 +1568,79 @@ func TestCodexAgentDispatchConfirmsDurableV2NamedRole(t *testing.T) {
 	}
 }
 
+func TestCodexAgentDispatchConfirmsConditionalDurableV2NamedRole(t *testing.T) {
+	root := newWorkspace(t)
+	codeHome := t.TempDir()
+	sessionID, turnID := "session-v2-conditional", "turn-v2-conditional"
+	role := "devrites-security-auditor"
+	writeCodexAgentContract(t, root, role)
+	writeCodexConditionalSkillContract(t, root, "devrites-audit", role)
+
+	runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "UserPromptSubmit",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"prompt":          "$devrites-audit security",
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+
+	writeCodexV2Rollouts(
+		t, codeHome, filepath.Dir(root), sessionID, turnID, role,
+		"devrites_security_auditor_conditional", true, true, true,
+	)
+	stop := hookPayload(t, map[string]any{
+		"hook_event_name": "Stop",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+	})
+	if out, stderr, code := runDevritesIO(t, root, stop,
+		[]string{"CODEX_HOME=" + codeHome},
+		"hook", "agent-dispatch", "--harness=codex"); code != 0 || strings.TrimSpace(out) != "" {
+		t.Fatalf("conditional durable v2 stop exit=%d out=%s stderr=%s", code, out, stderr)
+	}
+}
+
+func TestCodexAgentDispatchRejectsConditionalDurableV2DefaultChild(t *testing.T) {
+	root := newWorkspace(t)
+	codeHome := t.TempDir()
+	sessionID, turnID := "session-v2-default", "turn-v2-default"
+	writeCodexConditionalSkillContract(t, root, "devrites-audit", "devrites-security-auditor")
+
+	runDevritesIO(t, root, hookPayload(t, map[string]any{
+		"hook_event_name": "UserPromptSubmit",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+		"prompt":          "$devrites-audit security",
+	}), nil, "hook", "agent-dispatch", "--harness=codex")
+
+	writeCodexV2Rollouts(
+		t, codeHome, filepath.Dir(root), sessionID, turnID, "default",
+		"default_conditional_child", true, true, true,
+	)
+	stop := hookPayload(t, map[string]any{
+		"hook_event_name": "Stop",
+		"session_id":      sessionID,
+		"turn_id":         turnID,
+	})
+	out, stderr, code := runDevritesIO(t, root, stop,
+		[]string{"CODEX_HOME=" + codeHome},
+		"hook", "agent-dispatch", "--harness=codex")
+	if code != 0 {
+		t.Fatalf("conditional default stop exit=%d stderr=%s", code, stderr)
+	}
+	var decision struct {
+		Decision string `json:"decision"`
+		Reason   string `json:"reason"`
+	}
+	if err := json.Unmarshal([]byte(strings.TrimSpace(out)), &decision); err != nil {
+		t.Fatalf("invalid conditional default response: %v\n%s", err, out)
+	}
+	if decision.Decision != "block" ||
+		!strings.Contains(decision.Reason, "default or non-DevRites child") ||
+		!strings.Contains(decision.Reason, "never use a default child") {
+		t.Fatalf("conditional V2 default child passed: %#v", decision)
+	}
+}
+
 func TestCodexAgentDispatchRejectsIncompleteDurableV2(t *testing.T) {
 	for _, tc := range []struct {
 		name          string

package/pack/.claude/skills/rite-build/reference/wright-dispatch.md

@@ -26,8 +26,8 @@ only the source-write lifecycle.
 4. Immediately before a serial dispatch:
 
    ```bash
-   devrites-engine reconcile snapshot
    devrites-engine stuck log "$(cat .devrites/ACTIVE 2>/dev/null)" dispatch "<slice id>"
+   devrites-engine reconcile snapshot
    ```
 
    A Forge slice runs `forge plan` first, then takes this same snapshot; see

package/pack/generated/claude/skills/rite-build/reference/wright-dispatch.md

@@ -26,8 +26,8 @@ only the source-write lifecycle.
 4. Immediately before a serial dispatch:
 
    ```bash
-   devrites-engine reconcile snapshot
    devrites-engine stuck log "$(cat .devrites/ACTIVE 2>/dev/null)" dispatch "<slice id>"
+   devrites-engine reconcile snapshot
    ```
 
    A Forge slice runs `forge plan` first, then takes this same snapshot; see

package/pack/generated/codex/skills/rite-build/reference/wright-dispatch.md

@@ -26,8 +26,8 @@ only the source-write lifecycle.
 4. Immediately before a serial dispatch:
 
    ```bash
-   devrites-engine reconcile snapshot
    devrites-engine stuck log "$(cat .devrites/ACTIVE 2>/dev/null)" dispatch "<slice id>"
+   devrites-engine reconcile snapshot
    ```
 
    A Forge slice runs `forge plan` first, then takes this same snapshot; see

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "3.2.6",
+  "version": "3.2.8",
   "description": "DevRites: a disciplined senior-engineer workflow pack for Claude Code and Codex",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",