devrites 7.3.5 → 7.3.6

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 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`.
 
+## [7.3.6](https://github.com/ViktorsBaikers/DevRites/compare/v7.3.5...v7.3.6) (2026-11-06)
+
+### Fixed
+
+* **devrites:** enforce native prebuild preparation admission ([#209](https://github.com/ViktorsBaikers/DevRites/issues/209)) ([2aba0a0](https://github.com/ViktorsBaikers/DevRites/commit/2aba0a0e0828f25c90e3021ca2c29ddebb291bf9))
+
 ## [7.3.5](https://github.com/ViktorsBaikers/DevRites/compare/v7.3.4...v7.3.5) (2026-11-05)
 
 ### Fixed
@@ -53,6 +59,16 @@ All notable changes to DevRites are documented here. The format follows [Keep a
 
 ### Fixed
 
+- Guard Autocomplete's early phase context and dispatch, not only Build writers,
+  against unstarted successor preparation. Keep normalization research reachable
+  and bound successor preparation before its first wave without recursively
+  requiring the rest of the roadmap.
+- Keep Clarify required when decision coverage is missing or empty despite an
+  empty question queue.
+- Preserve preparation intent and the selected host tree in suggested context
+  reruns; reject repeated parent flags before writes and retain settled history
+  without rebinding active preparation actors.
+
 - Give an explicitly identified Autocomplete controller structural writer-admission
   checks for actual successor preparation and source-qualified mixed reservations.
   Surface fresh global scheduling after returns and prioritize unresolved global

package/README.md

@@ -31,7 +31,7 @@ history can't lose it. After you clear the conversation, switch hosts, or hand
 the feature to another engineer, the next session reads the same plan,
 decisions, and evidence before it continues.
 
-**Status:** [`v7.3.5`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.3.5): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
+**Status:** [`v7.3.6`](https://github.com/ViktorsBaikers/DevRites/releases/tag/v7.3.6): see [`CHANGELOG.md`](CHANGELOG.md) for release notes.
 
 This is the latest published release; `main` may contain unreleased work.
 

package/docs/adr/0040-early-preparation-admission.md

@@ -0,0 +1,76 @@
+# ADR-0040: Early preparation admission without recursive roadmap blocking
+
+- **Status:** Accepted
+- **Date:** 2026-11-06
+
+## Context
+
+ADR-0039 guarded Build-wright admission. A subsequent consumer trace entered
+Temper and launched native review without starting its recorded successor;
+it consumed a context bundle before any dispatch account. Writer-only checks
+therefore left the earlier preparation path unguarded.
+
+Requiring every source to prepare its successor immediately would also recurse
+through the entire roadmap: preparing B for A would demand C before A's own
+work. Sequence normalization needs a read-only bootstrap that cannot itself
+be blocked by the authority it investigates.
+
+## Decision
+
+Extend ADR-0039's deterministic admission boundary to ordinary local
+Temper/Define/Plan/Vet context generation and dispatch opening in Autocomplete
+at effective capacity greater than one. Both use one validation owner, before
+workflow writes. Context does not require an open account: reviewer context
+and packet construction precede wave opening. Build keeps its full admission.
+
+- Internal `--prepare-for <parent-source>` identifies existing immediate-successor
+  preparation. Canonical identity, parent binding, adjacent positions and both
+  chains must agree. Only supported preparation phases/roles qualify; root
+  context may omit a role. Dispatch records optional `preparation_for`; context
+  records no account. Neither permits product writes or Build.
+- Internal `--sequence-research` permits only exact-source, read-only
+  `evidence-scout` investigation in preparation phases before the authority gate.
+  It is mutually exclusive with `--prepare-for`. Dispatch records optional
+  `sequence_research`. The exception grants no scope, approval, phase advancement,
+  successor creation, writer admission, readiness or upstream preparation credit.
+- Derive preparatory-only B from its validated immediate nonterminal parent A,
+  absence of ordinary forward/Build-wright admission and absence of normal handoff to B.
+  This applies before the first marked wave. Observe B's continuation without
+  making C an actionable prerequisite for A. Ordinary B admission still checks
+  C before publication; that admission, terminal A or normal ordered handoff
+  releases the routing boundary. ACTIVE selection represents native handoff,
+  not proof of implementation or approval.
+  Read-only Build accounts do not release it. Explicit descendant `next` and
+  `check continuation` honor inherited waiting instead of mandating a local cursor;
+  other actionable global work and independently admitted proof remain visible.
+- Preserve completed account history and existing pending/abandoned actor and
+  unfinished writer integration protection. Settled purpose bindings remain
+  historical after authorized replanning, not current-parent authority or new
+  preparation credit; unsettled mismatches still fail closed.
+- A resolved finite tail needs no successor. New-opening opt-out or budget
+  exhaustion does not erase an already-created child. Existing narrow deferrals,
+  human gates, claims, capacity, isolation and protected proof remain authoritative.
+
+No new user Autocomplete flag, model client, launch bridge, receipt or queue.
+Standalone/cap1 and initial Spec/Clarify/bootstrap behavior remain unchanged.
+Actual native launches still require registered host handles; declared purpose
+metadata does not prove profile, checkout or semantic progress.
+
+## Alternatives considered
+
+| Option | Why rejected |
+| --- | --- |
+| Keep the gate only on Build waves | Earlier context and native planning can bypass it. |
+| Require an open account before producing context | Reviewer opening requires a packet built from that context. |
+| Require B's successor before admitting B's preparation for A | Recurses through the roadmap instead of pipelining one successor. |
+| Use a preparation marker as the only routing boundary | The creation/context interval precedes the first marked wave. |
+| Treat normalization research as ordinary planning admission | Conflicting authority blocks its own investigation. |
+
+## Consequences
+
+The engine rejects the observed early CLI path, not merely its eventual writer.
+Native hosts retain semantic scope, ordered handoff, exact profile/model/cwd,
+result reconciliation and publication authority. Arbitrary host compliance is
+not an engine guarantee.
+
+Guard regressions: `engine/internal/lib/frontier_preparation_test.go`.

package/docs/adr/README.md

@@ -85,3 +85,4 @@ architecture; per-feature `decisions.md` files stay scoped to that feature.
 | [0037](0037-autocomplete-lands-local-checkpoints.md) | Autocomplete lands local checkpoints and self-resolves own scratch | Accepted; supersedes the ADR-0022 local-commit approval clause | `tests/authority-drift-test.sh` |
 | [0038](0038-engine-flags-unattributed-root-edits.md) | The engine flags unattributed root edits | Accepted; narrows the ADR-0018 no-replacement-enforcement clause for root-edit attribution | `engine/internal/lib/treebaseline_test.go` |
 | [0039](0039-autocomplete-structural-admission.md) | Structural admission for native Autocomplete | Accepted; narrowly amends 0022/0024 for observable writer admission, retains native dispatch and semantic authority | `engine/internal/lib/frontier_controller_test.go`, `engine/internal/lib/frontier_roadmap_test.go`, `engine/tests/autocomplete_global_test.go` |
+| [0040](0040-early-preparation-admission.md) | Early preparation admission without recursive roadmap blocking | Accepted; extends 0039 to context and pre-Build native dispatch, preserves native execution and semantic authority | `engine/internal/lib/frontier_preparation_test.go` |

package/docs/engine/commands.md

@@ -59,6 +59,10 @@ workflow strategy.
 | `overhaul <records\|admit\|snapshot\|score\|bench\|render> ...` | Deterministic tools behind the standalone `/overhaul` skill: run-record generations and cross-record validation, worker-receipt admission and quote anchoring, index-safe baseline snapshots and per-attempt deltas, exact-rational readiness scoring, benchmark ratio intervals, and escaped offline review/report views. Operates only on explicit run-area and repository paths. See [Overhaul tools](#overhaul-tools). |
 | `version` | Print the engine version. |
 
+`next` skips zero-question Clarify only when its required artifacts are present
+and nonempty. Missing or empty `decision-coverage.md` still routes to Clarify;
+an empty question queue does not establish decision coverage.
+
 Under AFK, `next`, `handoff`, and `check continuation` include the sequence
 frontier without replacing the source-local cursor. Reporting actionable work
 does not authorize Build or Ship, and cannot guarantee native-host compliance.
@@ -71,12 +75,50 @@ archived/related owners absent from the local context read-next bundle.
 Native `/rite-autocomplete` automatically upserts AFK `mode: autocomplete`
 (no new flag), preserving other fields except an explicit `--parallel N` capacity
 update. Missing mode retains standalone AFK behavior; invalid/duplicate mode
-fails closed. With mode and global cap >1, Build wright `dispatch open` checks
-global scheduling before claims/history/round writes: prepare one immediate
-recorded successor per source, with actual pending planning/review handles,
-current native readiness, or a concrete human/dependency hold; placeholders do
-not count. Opt-out, exhausted opening budgets, and source human/question holds
-remain binding. Unresolved authority requires native normalization.
+fails closed. With mode and effective global cap >1, ordinary local
+Temper/Define/Plan/Vet `context` and `dispatch open` check immediate-successor
+preparation before bundle/account/claim/history writes. The context check also
+applies to `--skill rite-<phase>`; it does not require an already-open wave.
+Build-wright admission retains its additional mixed-cohort and writer checks.
+Actual pending native planning/review handles, current readiness/completion, or
+a concrete human/dependency hold satisfy preparation; placeholders do not.
+Valid finite tails have no successor obligation. Opt-out and exhausted opening
+budgets prevent new openings, not planning an existing child. Standalone/cap1
+and initial Spec/Clarify/bootstrap reads retain their existing behavior.
+
+Both commands accept internal preparation intents, not new Autocomplete flags:
+
+| Option | Meaning |
+| --- | --- |
+| `--prepare-for <parent-source>` | Prepare the existing exact immediate successor of that parent. Validates canonical identity, parent binding, adjacent positions and both chains. Only supported preparation phases/roles qualify; controlling-root context may omit a role, dispatch may not. Never Build/writers or product-write authority. |
+| `--sequence-research` | Read-only normalization investigation by `evidence-scout` in Spec/Clarify/Temper/Define/Plan/Vet, bound to the exact existing source. Can inspect conflicting/malformed sequence authority; grants no normalization acceptance, scope, phase advancement, successor creation, writer admission, readiness or upstream preparation credit. |
+
+The options are mutually exclusive; dispatch accepts them on `open` only.
+Repeated `--prepare-for` is a syntax error, even with the same parent.
+Syntax/combination errors exit `2`; refused preparation/authority exits `3`
+before workflow writes. Successful admission uses the existing `0` convention.
+Dispatch retains optional wave fields `preparation_for` (string) and
+`sequence_research` (boolean); context creates no account or receipt. Old
+accounts need neither field. These fields record intent, not host execution.
+Keep context → packet → open → native launch → start order; register actual
+host handles before resuming the parent's ordinary phase.
+Suggested trigger-rerun commands preserve the preparation intent and explicitly
+selected skills root, including shell-safe quoting of that path.
+
+A newly created preparatory child B of nonterminal A does not recursively
+require C before A can proceed, even before B's first marked wave. Completed
+preparation history retains that routing boundary. Ordinary unmarked forward
+or Build-wright admission for B still checks C; such admission, terminal A, or normal
+ordered handoff selecting B restores B's own successor obligation. Pending
+actors, unfinished writer integration and other independent work remain visible.
+Read-only Build accounts do not release the bound. When an inherited descendant
+waits, explicit `next <descendant>` emits no local phase command and
+`check continuation <descendant>` emits `continuation: clear`, unless other
+actionable global work takes priority. Observing a source does not change ACTIVE.
+Purpose history stays immutable and does not make completed actors live again.
+Settled purpose bindings remain historical after an authorized replan; they
+neither bind the current parent nor supply new preparation credit. Unsettled
+mismatched actors still fail closed.
 
 Source `evidence.md` may retain `frontier-blocked: <successor-slug> — <specific constraint>`
 or `frontier-blocked: sequence — <specific constraint>` as a visible scheduling

package/engine/internal/lib/context.go

@@ -40,7 +40,7 @@ type loadsManifest struct {
 
 const loadsMarker = "<!-- loads:"
 
-const contextUsage = `usage: devrites-engine context [slug] (--phase <p> | --skill <name>) [--role <r>] [--slice <SLICE-###>] [--recheck <inventory>] [--trigger a,b] [--inline-contract] [--whole] [--skills-root <dir>] [--out <path>]
+const contextUsage = `usage: devrites-engine context [slug] (--phase <p> | --skill <name>) [--role <r>] [--prepare-for <parent-source> | --sequence-research] [--slice <SLICE-###>] [--recheck <inventory>] [--trigger a,b] [--inline-contract] [--whole] [--skills-root <dir>] [--out <path>]
 
 Emits one deduplicated context bundle for a phase or standalone skill
 (+ optional dispatch role) into .devrites/work/<slug>/ctx/ so an agent
@@ -65,6 +65,12 @@ build or autocomplete bundle (no --role, no --slice) defaults to --slice
 bounded recheck bundle: the inventory file (relative to the workspace)
 and core.md are inlined; every other pack file becomes a by-reference
 index plus the sections the inventory cites as "<file>.md § <heading>".
+Autocomplete at effective cap>1 gates Temper/Define/Plan/Vet bundles, including
+--skill rite-<phase>, on immediate-successor preparation before writing.
+--prepare-for binds native preparation to its exact immediate parent; roleless
+controlling-root context is allowed. --sequence-research permits only exact
+evidence-scout investigation of sequence authority. Neither creates an account
+or grants product-write authority; research does not satisfy successor preparation.
 `
 
 // coreStandard is the universal floor every bundle inlines whole.
@@ -73,12 +79,27 @@ const coreStandard = "devrites-lib/reference/standards/core.md"
 // RunContext emits one deduplicated context bundle for a phase (+ optional
 // dispatch role) so an agent reads a single file instead of selecting files.
 //
-//	context <slug> --phase <p> [--role <r>] [--slice <SLICE-###>] [--recheck <inventory>] [--trigger a,b] [--skills-root <dir>] [--out <path>]
+//	context <slug> --phase <p> [--role <r>] [--prepare-for <parent-source> | --sequence-research] [--slice <SLICE-###>] [--recheck <inventory>] [--trigger a,b] [--skills-root <dir>] [--out <path>]
 func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 	opts, code := parseContextArgs(args, stderr)
 	if code != 0 {
 		return code
 	}
+	phase := opts.phase
+	if opts.skill != "" {
+		phase = ""
+		if strings.HasPrefix(opts.skill, "rite-") {
+			phase = strings.TrimPrefix(opts.skill, "rite-")
+		}
+	}
+	var roles []string
+	if opts.role != "" {
+		roles = []string{opts.role}
+	}
+	if err := opts.purpose.validate(phase, roles, true); err != nil {
+		fmt.Fprintf(stderr, "context: %v\n", err)
+		return 2
+	}
 	// A Build reviewer judges one slice; an unscoped bundle inlines whole
 	// plan/tasks/architecture into every dispatch.
 	if opts.phase == "build" && opts.role != "" && roleBase(opts.role) != "slice-wright" && opts.slice == "" {
@@ -94,6 +115,19 @@ func RunContext(root string, args []string, stdout, stderr io.Writer) int {
 			return 2
 		}
 	}
+	if opts.slug != "" {
+		notices, err := preparationAdmission(root, opts.slug, phase, opts.purpose, nil)
+		if err != nil {
+			fmt.Fprintf(stderr, "context: BLOCKED: %v\n", err)
+			return 3
+		}
+		for _, notice := range notices {
+			fmt.Fprintln(stdout, notice)
+		}
+	} else if opts.purpose.parent != "" || opts.purpose.research {
+		fmt.Fprintln(stderr, "context: preparation purpose requires an exact existing source")
+		return 2
+	}
 	sources := contextSources{dir: featureDir}
 	// One active slice per bundle, except a parallel batch: the root has to
 	// see the other slices to start them. Whole tasks/plan/decisions ride
@@ -791,6 +825,7 @@ type contextOpts struct {
 	recheck        string
 	inlineContract bool
 	whole          bool
+	purpose        preparationPurpose
 }
 
 func parseContextArgs(args []string, stderr io.Writer) (contextOpts, int) {
@@ -799,6 +834,19 @@ func parseContextArgs(args []string, stderr io.Writer) (contextOpts, int) {
 	for i := 0; i < len(args); i++ {
 		value := argAt(args, i+1)
 		switch args[i] {
+		case "--prepare-for":
+			if opts.purpose.parent != "" {
+				fmt.Fprintln(stderr, "context: duplicate --prepare-for")
+				return opts, 2
+			}
+			if value == "" || strings.HasPrefix(value, "-") {
+				fmt.Fprintln(stderr, "context: --prepare-for requires a parent source")
+				return opts, 2
+			}
+			opts.purpose.parent = value
+		case "--sequence-research":
+			opts.purpose.research = true
+			continue
 		case "--phase":
 			opts.phase = value
 		case "--skill":

package/engine/internal/lib/continuation.go

@@ -59,6 +59,8 @@ func RunCheckContinuation(root string, args []string, stdout, stderr io.Writer)
 		}
 		if mode && frontierGlobalPriority(slug, frontier) || !mode && !verdict.Required && len(frontier) > 0 && frontier[0] == "frontier: actionable" {
 			verdict = continuationVerdict{Required: true, Invoke: "/rite-autocomplete", Source: slug, Reason: "global frontier requires native preparation, authority review, or selection; no Ship approval"}
+		} else if mode && frontierSourcePreparationWait(slug, frontier) {
+			verdict = continuationVerdict{Reason: frontierInheritedPreparationWait}
 		}
 	}
 	writeContinuation(stdout, verdict)

package/engine/internal/lib/dispatch.go

@@ -27,9 +27,9 @@ import (
 // fan-out cannot silently degrade to serial (open -> every role started ->
 // seal -> returns -> complete). start/return also auto-record metrics events.
 //
-//	devrites-engine dispatch <slug> <sub> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>] [--contract <file>] [--packet <file>] [--outcome findings|no-findings|gap] [--result <file>] [--all] [--claim-session <id> --claim <path>... [--claim-ttl <minutes>]] [--release] [--path <path>...]
+//	devrites-engine dispatch <slug> <sub> [--phase p] [--wave w] [--role r] [--prepare-for <parent-source> | --sequence-research] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>] [--contract <file>] [--packet <file>] [--outcome findings|no-findings|gap] [--result <file>] [--all] [--claim-session <id> --claim <path>... [--claim-ttl <minutes>]] [--release] [--path <path>...]
 
-const dispatchUsage = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon|attribute> [--phase p] [--wave w] [--role r] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>] [--contract <file>] [--packet <file>] [--outcome findings|no-findings|gap] [--result <file>] [--all] [--claim-session <id> --claim <path>... [--claim-ttl <minutes>]] [--release] [--path <path>...]
+const dispatchUsage = `usage: devrites-engine dispatch <slug> <open|start|seal|return|status|abandon|attribute> [--phase p] [--wave w] [--role r] [--prepare-for <parent-source> | --sequence-research] [--handle h] [--reason s] [--slice SLICE-###] [--reslice-review <DRIFT-ID>] [--contract <file>] [--packet <file>] [--outcome findings|no-findings|gap] [--result <file>] [--all] [--claim-session <id> --claim <path>... [--claim-ttl <minutes>]] [--release] [--path <path>...]
 
 Wave barrier for parallel agent dispatch: seal fails until every declared
 role has a distinct handle; return fails before seal. The start that gives
@@ -40,6 +40,12 @@ completes the wave releases it, and abandon keeps it unless --release (any
 host-confirmed terminal path without a completing return, such as a stop or a
 refused launch). Wave IDs are single-use, including abandoned waves; retries
 need a fresh ID and never inherit or release an earlier wave's claim.
+Autocomplete at effective cap>1 checks immediate-successor preparation before
+ordinary Temper/Define/Plan/Vet open writes. Open-only --prepare-for binds allowed
+native preparation roles to an exact immediate parent without recursively
+requiring another successor. Open-only --sequence-research admits exact
+evidence-scout authority investigation, never successor preparation or writers.
+Both require an existing source and persist their purpose on the wave.
 Native starts, returns and abandonment retain subsecond timestamps. abandon
 --release also retains host-terminal confirmation, even without a claim or when
 its owned claim was already released; a failed release does not certify termination.
@@ -105,20 +111,22 @@ type dispatchFile struct {
 }
 
 type dispatchWave struct {
-	Phase           string                   `json:"phase"`
-	State           string                   `json:"state"` // open, sealed, abandoned, complete
-	Reason          string                   `json:"reason,omitempty"`
-	AbandonedAt     string                   `json:"abandoned_at,omitempty"`
-	TerminalAt      string                   `json:"terminal_at,omitempty"`
-	Roles           map[string]*dispatchRole `json:"roles"`
-	Slices          []string                 `json:"slices,omitempty"`
-	ResliceReview   string                   `json:"reslice_review,omitempty"`
-	ResliceReviewed []string                 `json:"reslice_reviewed,omitempty"`
-	Claim           string                   `json:"claim,omitempty"`
-	ClaimSession    string                   `json:"claim_session,omitempty"`
-	Tree            string                   `json:"tree,omitempty"`             // work tree at a build wright open, for check windows --since-dispatch
-	ControllerBatch string                   `json:"controller_batch,omitempty"` // cohort admission identity, not evidence of actor checkout
-	AdmittedPaths   map[string][]string      `json:"admitted_paths,omitempty"`   // immutable normalized write sets, keyed by source-local slice
+	Phase            string                   `json:"phase"`
+	State            string                   `json:"state"` // open, sealed, abandoned, complete
+	Reason           string                   `json:"reason,omitempty"`
+	AbandonedAt      string                   `json:"abandoned_at,omitempty"`
+	TerminalAt       string                   `json:"terminal_at,omitempty"`
+	Roles            map[string]*dispatchRole `json:"roles"`
+	Slices           []string                 `json:"slices,omitempty"`
+	ResliceReview    string                   `json:"reslice_review,omitempty"`
+	ResliceReviewed  []string                 `json:"reslice_reviewed,omitempty"`
+	Claim            string                   `json:"claim,omitempty"`
+	ClaimSession     string                   `json:"claim_session,omitempty"`
+	Tree             string                   `json:"tree,omitempty"`             // work tree at a build wright open, for check windows --since-dispatch
+	ControllerBatch  string                   `json:"controller_batch,omitempty"` // cohort admission identity, not evidence of actor checkout
+	AdmittedPaths    map[string][]string      `json:"admitted_paths,omitempty"`   // immutable normalized write sets, keyed by source-local slice
+	PreparationFor   string                   `json:"preparation_for,omitempty"`
+	SequenceResearch bool                     `json:"sequence_research,omitempty"`
 }
 
 // dispatchClaim carries the wave-claim flags; ttl 0 means unset.
@@ -179,6 +187,16 @@ func decodeDispatch(data []byte) (*dispatchFile, error) {
 			!slices.Contains([]string{"open", "sealed", "complete", "abandoned"}, w.State) {
 			return nil, fmt.Errorf("wave %q is malformed (invalid phase, state or roles)", name)
 		}
+		purpose := preparationPurpose{parent: w.PreparationFor, research: w.SequenceResearch}
+		if purpose.parent != "" || purpose.research {
+			roles := make([]string, 0, len(w.Roles))
+			for role := range w.Roles {
+				roles = append(roles, role)
+			}
+			if err := purpose.validate(w.Phase, roles, false); err != nil {
+				return nil, fmt.Errorf("wave %q has invalid preparation purpose: %w", name, err)
+			}
+		}
 		handles := map[string]bool{}
 		allStarted, allReturned := true, true
 		for role, r := range w.Roles {
@@ -254,16 +272,33 @@ func saveDispatch(path string, f *dispatchFile) error {
 func nowStamp() string { return time.Now().UTC().Format(time.RFC3339Nano) }
 
 // RunDispatch implements the dispatch wave state machine.
+//
+// Preparation-purpose flags apply to open only; ordinary early-phase admission
+// and context generation share immediate-successor validation.
 func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 	var slug, sub, phase, wave, role, handle, reason, review, contract, packet, outcome, result string
 	var roles, sliceIDs []string
 	var positional []string
 	all := false
+	var purpose preparationPurpose
 	var claim dispatchClaim
 	var attributed []string
 	for i := 0; i < len(args); i++ {
 		value := argAt(args, i+1)
 		switch args[i] {
+		case "--prepare-for":
+			if purpose.parent != "" {
+				fmt.Fprintln(stderr, "dispatch: duplicate --prepare-for")
+				return 2
+			}
+			if value == "" || strings.HasPrefix(value, "-") {
+				fmt.Fprintln(stderr, "dispatch: --prepare-for requires a parent source")
+				return 2
+			}
+			purpose.parent = value
+		case "--sequence-research":
+			purpose.research = true
+			continue
 		case "--phase":
 			phase = value
 		case "--wave":
@@ -321,6 +356,16 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 		return 2
 	}
 	slug, sub = positional[0], positional[1]
+	if purpose.parent != "" || purpose.research {
+		if sub != "open" {
+			fmt.Fprintln(stderr, "dispatch: preparation purpose applies to open only")
+			return 2
+		}
+		if err := purpose.validate(phase, roles, false); err != nil {
+			fmt.Fprintf(stderr, "dispatch: %v\n", err)
+			return 2
+		}
+	}
 	if sub != "open" && (claim.session != "" || len(claim.paths) > 0 || claim.ttl != 0) {
 		fmt.Fprintln(stderr, "dispatch: --claim-session, --claim, and --claim-ttl apply to open only")
 		return 2
@@ -348,7 +393,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 		return state.WithFeatureLock(root, slug, func() error {
 			// Controller → feature → claims; never acquire another feature.
 			return state.WithLock(claimsPath(root)+".lock", func() error {
-				code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, sliceIDs, review, contract, packet, outcome, result, all, claim, stdout, stderr, &recordedReturn)
+				code = dispatchLocked(root, slug, sub, phase, wave, role, handle, reason, roles, sliceIDs, review, contract, packet, outcome, result, all, claim, purpose, stdout, stderr, &recordedReturn)
 				return nil
 			})
 		})
@@ -359,13 +404,16 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 			controllerOpen = controllerOpen || strings.Contains(candidate, "wright")
 		}
 	}
+	if sub == "open" && (earlyPreparationPhase(phase) || purpose.parent != "" || purpose.research) {
+		controllerOpen = true
+	}
 	if controllerOpen {
 		mode, err := autocompleteMode(root)
 		if err != nil {
 			fmt.Fprintf(stderr, "dispatch: BLOCKED: %v\n", err)
 			return 3
 		}
-		controllerOpen = mode
+		controllerOpen = mode || purpose.parent != "" || purpose.research
 	}
 	var lockErr error
 	if controllerOpen {
@@ -397,7 +445,7 @@ func RunDispatch(root string, args []string, stdout, stderr io.Writer) int {
 	return code
 }
 
-func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles, sliceIDs []string, review, contract, packet, outcome, result string, all bool, claim dispatchClaim, stdout, stderr io.Writer, recordedReturn *bool) int {
+func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, roles, sliceIDs []string, review, contract, packet, outcome, result string, all bool, claim dispatchClaim, purpose preparationPurpose, stdout, stderr io.Writer, recordedReturn *bool) int {
 	f, path, err := loadDispatch(root, slug)
 	if err != nil {
 		fmt.Fprintf(stderr, "dispatch: %v\n", err)
@@ -425,7 +473,7 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if prev := getWave(); prev != nil {
 			return fail("wave %q already exists (state %s)", wave, prev.State)
 		}
-		w := &dispatchWave{Phase: phase, State: "open", Roles: map[string]*dispatchRole{}, Slices: sliceIDs}
+		w := &dispatchWave{Phase: phase, State: "open", Roles: map[string]*dispatchRole{}, Slices: sliceIDs, PreparationFor: purpose.parent, SequenceResearch: purpose.research}
 		for _, r := range roles {
 			if w.Roles[r] != nil {
 				return fail("duplicate role %q in wave", r)
@@ -435,6 +483,13 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 		if err := lintKnownRoles(root, phase, roles); err != nil {
 			return fail("BLOCKED: %v", err)
 		}
+		notices, err := preparationAdmission(root, slug, phase, purpose, f)
+		if err != nil {
+			return fail("BLOCKED: %v", err)
+		}
+		for _, notice := range notices {
+			fmt.Fprintln(stdout, notice)
+		}
 		if isBuildWrightWave(w) {
 			binding, notices, err := autocompleteWriterAdmission(root, slug, w, f)
 			if err != nil {

package/engine/internal/lib/frontier.go

@@ -301,7 +301,7 @@ func FrontierLines(root, slug string) ([]string, error) {
 		return []string{
 			"frontier: blocked", "frontier-source: " + slug,
 			fmt.Sprintf("frontier-workspace: %s location=%s action=repair reason=%s", slug, source.location, chainErr),
-			"frontier-review-sequence: " + artifact + " reason=native authority-normalization required: " + chainErr.Error(),
+			"frontier-review-sequence: reason=native authority-normalization required: " + chainErr.Error() + " artifacts=" + artifact,
 		}, nil
 	}
 	ordered, related := frontierRelated(nodes, chain)
@@ -351,7 +351,7 @@ func FrontierLines(root, slug string) ([]string, error) {
 	}
 	maps, artifacts, mapProblem, invalidCanonical := frontierRoadmap(nodes, ordered)
 	if invalidCanonical {
-		return []string{"frontier: blocked", "frontier-source: " + slug, "frontier-review-sequence: " + strings.Join(artifacts, ",") + " reason=native authority-normalization required: invalid canonical authority: " + mapProblem}, nil
+		return []string{"frontier: blocked", "frontier-source: " + slug, "frontier-review-sequence: reason=native authority-normalization required: invalid canonical authority: " + mapProblem + " artifacts=" + strings.Join(artifacts, ",")}, nil
 	}
 	if len(maps) > 0 && mapProblem == "" {
 		lines = append(lines, "frontier-authority: "+strings.Join(artifacts, ","))
@@ -368,12 +368,24 @@ func FrontierLines(root, slug string) ([]string, error) {
 		if sequenceDeferred {
 			lines = append(lines, "frontier-blocked: sequence — "+records.blocked["sequence"]+"; scheduling deferred, not normalized")
 		} else {
-			lines = append(lines, "frontier-review-sequence: "+strings.Join(artifacts, ",")+" reason=native authority-normalization required: "+mapProblem)
+			lines = append(lines, "frontier-review-sequence: reason=native authority-normalization required: "+mapProblem+" artifacts="+strings.Join(artifacts, ","))
 			blocked = true
 		}
 	}
 	deferred := map[string]string{}
 	prepared := map[string]bool{}
+	var preparatory map[string]bool
+	var preparationAccounts map[string]*dispatchFile
+	if mode && capN > 1 {
+		preparatory = make(map[string]bool, len(ordered))
+		preparationAccounts = make(map[string]*dispatchFile, len(ordered))
+		for _, name := range ordered {
+			preparatory[name], preparationAccounts[name], err = frontierPreparatoryOnly(root, nodes[name], nodes, maps, mapProblem)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
 	for _, name := range ordered {
 		n := nodes[name]
 		action, reason := "complete", "archived predecessor; no writer admission"
@@ -386,17 +398,21 @@ func FrontierLines(root, slug string) ([]string, error) {
 		} else if gateReason != "" {
 			action, reason, held, blocked = "wait", gateReason, true, true
 		} else if n.location == "live" {
-			action, reason, err = frontierLocal(root, controller, n, &candidates)
+			action, reason, err = frontierLocal(root, controller, n, &candidates, preparationAccounts[name])
 			if err != nil {
 				action, reason, n.selectionHeld = "repair", err.Error(), true
 			}
 			if mode && action == "prepare" && deferred[name] != "" {
 				action, reason, n.selectionHeld = "wait", "frontier-blocked: "+name+" — "+deferred[name], true
 			}
+			inheritedPreparation := preparatory[name] && preparatory[n.parent] && (n.phase == "frame" || preparationPhase(n.phase)) && action == "prepare"
+			if inheritedPreparation {
+				action, reason, n.selectionHeld = "wait", frontierInheritedPreparationWait, true
+			}
 			if !n.selectionHeld {
 				live = append(live, name)
 			}
-			held = action == "blocked" || err != nil || mode && action == "wait" && deferred[name] != ""
+			held = inheritedPreparation || action == "blocked" || err != nil || mode && action == "wait" && deferred[name] != ""
 			switch action {
 			case "inspect", "prepare", "repair":
 				actionable = true
@@ -411,6 +427,9 @@ func FrontierLines(root, slug string) ([]string, error) {
 			}
 		}
 		lines = append(lines, fmt.Sprintf("frontier-workspace: %s location=%s action=%s reason=%s", name, n.location, action, reason))
+		if preparatory[name] {
+			continue
+		}
 		if invalid != nil || held || !allowFuture || n.hasRemaining && n.remaining == 0 || n.status == "awaiting_human" || n.status == "blocked" || n.question != "" {
 			continue
 		}
@@ -425,12 +444,12 @@ func FrontierLines(root, slug string) ([]string, error) {
 			continue
 		}
 		if target != "" && frontierConflictingSuccessor(nodes, n, target) {
-			lines = append(lines, "frontier-review-sequence: "+strings.Join(artifacts, ",")+" source="+name+" reason=conflicting successor identities; native authority-normalization required")
+			lines = append(lines, "frontier-review-sequence: reason=conflicting successor identities; native authority-normalization required source="+name+" artifacts="+strings.Join(artifacts, ","))
 			actionable, blocked = true, true
 			continue
 		}
 		if target != "" && n.hasPosition && maps[n.position+1] != "" && maps[n.position+1] != target {
-			lines = append(lines, "frontier-review-sequence: "+strings.Join(artifacts, ",")+" source="+name+" reason=next Spec conflicts with recorded successor; native authority-normalization required")
+			lines = append(lines, "frontier-review-sequence: reason=next Spec conflicts with recorded successor; native authority-normalization required source="+name+" artifacts="+strings.Join(artifacts, ","))
 			actionable, blocked = true, true
 			continue
 		}
@@ -459,7 +478,7 @@ func FrontierLines(root, slug string) ([]string, error) {
 			lines = append(lines, fmt.Sprintf("frontier-workspace: %s location=missing action=prepare reason=recorded next workspace; native scope and independence review required", target), fmt.Sprintf("frontier-prepare: /rite-spec %s source=%s reason=read recorded sequence authority before preparation; no workspace created", frontierQuote(target), name))
 			actionable = true
 		} else if target == "" && n.hasRemaining && n.remaining > 0 {
-			lines = append(lines, "frontier-review-sequence: "+strings.Join(artifacts, ",")+" source="+name+" reason=remaining work unresolved; native authority-normalization required")
+			lines = append(lines, "frontier-review-sequence: reason=remaining work unresolved; native authority-normalization required source="+name+" artifacts="+strings.Join(artifacts, ","))
 			actionable, blocked = true, true
 		}
 	}
@@ -574,7 +593,7 @@ func frontierQuestionHold(n *frontierWorkspace) (string, error) {
 	return "", nil
 }
 
-func frontierLocal(root, controller string, n *frontierWorkspace, candidates *[]parallel.SlicePaths) (string, string, error) {
+func frontierLocal(root, controller string, n *frontierWorkspace, candidates *[]parallel.SlicePaths, dispatch *dispatchFile) (string, string, error) {
 	n.selectionHeld = true
 	if frontierTerminal(n) {
 		return "complete", "terminal workspace", nil
@@ -585,15 +604,20 @@ func frontierLocal(root, controller string, n *frontierWorkspace, candidates *[]
 	if n.status != "running" && n.status != "ready" {
 		return "blocked", "status lacks an actionable native cursor; normalize state without inventing authority", nil
 	}
-	raw, err := readBoundedRegularFile(filepath.Join(n.dir, "dispatch.json"), workspaceArtifactLimit)
-	if err != nil && !os.IsNotExist(err) {
-		return "", "", err
-	}
-	if err == nil {
-		dispatch, err := decodeDispatch(raw)
-		if err != nil {
+	if dispatch == nil {
+		raw, err := readBoundedRegularFile(filepath.Join(n.dir, "dispatch.json"), workspaceArtifactLimit)
+		if err != nil && !os.IsNotExist(err) {
 			return "", "", err
 		}
+		if err == nil {
+			dispatch, err = decodeDispatch(raw)
+			if err != nil {
+				return "", "", err
+			}
+		}
+	}
+	if dispatch != nil {
+		var err error
 		retained, pending := false, false
 		var built map[string]bool
 		for _, wave := range dispatch.Waves {