devrites 7.3.5 → 7.3.6

package/engine/internal/lib/frontier_controller.go

@@ -134,19 +134,14 @@ func frontierSerialReason(records frontierRecords, source, workspace, id string)
 	return records.serial[parallel.SliceKey(workspace, "SLICE-"+sliceNumber(id))]
 }
 
-func frontierPendingPreparation(n *frontierWorkspace) (bool, error) {
-	raw, err := readBoundedRegularFile(filepath.Join(n.dir, "dispatch.json"), workspaceArtifactLimit)
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	if err != nil {
-		return false, err
-	}
-	dispatch, err := decodeDispatch(raw)
-	if err != nil {
-		return false, err
+func frontierPendingPreparation(dispatch *dispatchFile) bool {
+	if dispatch == nil {
+		return false
 	}
 	for _, wave := range dispatch.Waves {
+		if wave.SequenceResearch {
+			continue
+		}
 		if wave.State != "open" && wave.State != "sealed" {
 			continue
 		}
@@ -155,23 +150,12 @@ func frontierPendingPreparation(n *frontierWorkspace) (bool, error) {
 				continue
 			}
 			base := roleBase(role)
-			switch strings.ToLower(wave.Phase) {
-			case "spec", "clarify", "temper":
-				if base == "evidence-scout" || base == "strategy-reviewer" {
-					return true, nil
-				}
-			case "define", "plan":
-				if base == "plan-drafter" || base == "evidence-scout" {
-					return true, nil
-				}
-			case "vet":
-				if base == "plan-reviewer" || base == "devex-reviewer" || base == "strategy-reviewer" || base == "code-reviewer" {
-					return true, nil
-				}
+			if preparationRole(strings.ToLower(wave.Phase), base) {
+				return true
 			}
 		}
 	}
-	return false, nil
+	return false
 }
 
 func frontierSuccessor(n *frontierWorkspace, nodes map[string]*frontierWorkspace, mapping map[int]string) (string, error) {
@@ -199,8 +183,8 @@ func frontierSuccessor(n *frontierWorkspace, nodes map[string]*frontierWorkspace
 
 func frontierPreparationAdmission(root, source string, nodes map[string]*frontierWorkspace, mapping map[int]string, problem string, allow bool, records frontierRecords) ([]string, error) {
 	n := nodes[source]
-	if !allow || n.hasRemaining && n.remaining == 0 {
-		return nil, nil
+	if n == nil {
+		return nil, fmt.Errorf("source %s is not an existing sequence workspace", source)
 	}
 	if hold, err := frontierQuestionHold(n); err != nil || hold != "" {
 		return nil, err
@@ -222,15 +206,20 @@ func frontierPreparationAdmission(root, source string, nodes map[string]*frontie
 		if reason == "" {
 			reason = "positive remaining budget has no exact recorded successor"
 		}
-		return nil, fmt.Errorf("source %s native authority-normalization required before writer admission: %s; read sequence artifacts, record current roadmap through its owning decision, or retain frontier-blocked: sequence — <specific constraint>", source, reason)
+		return nil, fmt.Errorf("source %s native authority-normalization required before forward-phase admission: %s; read sequence artifacts, record current roadmap through its owning decision, or retain frontier-blocked: sequence — <specific constraint>", source, reason)
 	}
-	if target == "" {
+	if target == "" || nodes[target] == nil && (!allow || n.hasRemaining && n.remaining == 0) {
 		return nil, nil
 	}
+	var successorDispatch *dispatchFile
 	if child := nodes[target]; child != nil {
 		if _, err := frontierChain(nodes, target); err != nil {
 			return nil, err
 		}
+		successorDispatch, err = frontierPreparationBindings(child, nil)
+		if err != nil {
+			return nil, err
+		}
 	}
 	if reason := records.blocked[target]; reason != "" {
 		return []string{"frontier-blocked: " + target + " — " + reason + "; preparation deferred, not approved"}, nil
@@ -242,8 +231,8 @@ func frontierPreparationAdmission(root, source string, nodes map[string]*frontie
 		if frontierTerminal(child) {
 			return nil, nil
 		}
-		if pending, err := frontierPendingPreparation(child); err != nil || pending {
-			return nil, err
+		if frontierPendingPreparation(successorDispatch) {
+			return nil, nil
 		}
 		ready, notices, err := WorkspaceReady(filepath.Dir(root), source, target)
 		if err != nil {
@@ -264,7 +253,7 @@ func frontierPreparationAdmission(root, source string, nodes map[string]*frontie
 			return nil, nil
 		}
 	}
-	return nil, fmt.Errorf("successor %s preparation has not actually started; invoke /rite-spec %s or its native Plan/Vet cursor and retain launched planning/review handles before /rite-build %s; alternatively retain frontier-blocked: %s — <specific constraint> in evidence.md", target, frontierQuote(target), source, target)
+	return nil, fmt.Errorf("successor %s preparation has not actually started; invoke /rite-spec %s or its native Plan/Vet cursor and retain launched planning/review handles before continuing forward phases of %s; alternatively retain frontier-blocked: %s — <specific constraint> in evidence.md", target, frontierQuote(target), source, target)
 }
 
 func frontierNormalizePaths(paths []string) error {
@@ -321,7 +310,7 @@ func frontierLeaseReserved(lease *parallel.Lease, controller, source string, ids
 	return len(ids) > 0
 }
 
-func frontierWriterRetention(root, source, controller, binding string, lease *parallel.Lease, nodes map[string]*frontierWorkspace, ordered, ids []string, current *dispatchFile) error {
+func frontierWriterRetention(root, source, controller, binding string, lease *parallel.Lease, nodes map[string]*frontierWorkspace, ordered, ids []string, current *dispatchFile, checkPreparation bool) error {
 	var claims map[string]*claimRecord
 	for _, slug := range ordered {
 		if _, err := frontierChain(nodes, slug); err != nil {
@@ -340,6 +329,11 @@ func frontierWriterRetention(root, source, controller, binding string, lease *pa
 			if err != nil {
 				return err
 			}
+			if checkPreparation {
+				if _, err := frontierPreparationBindings(nodes[slug], dispatch); err != nil {
+					return err
+				}
+			}
 		}
 		for name, wave := range dispatch.Waves {
 			if wave.State == "complete" || wave.TerminalAt != "" {
@@ -475,6 +469,12 @@ func autocompleteWriterAdmission(root, source string, wave *dispatchWave, curren
 	if err != nil {
 		return "", nil, err
 	}
+	checkPreparation := capN > 1 && (lease == nil || lease.Capacity != 1)
+	if checkPreparation {
+		if _, err := frontierPreparationBindings(nodes[source], current); err != nil {
+			return "", nil, err
+		}
+	}
 	chain, err := frontierChain(nodes, source)
 	if err != nil {
 		return "", nil, err
@@ -498,9 +498,12 @@ func autocompleteWriterAdmission(root, source string, wave *dispatchWave, curren
 	if err != nil {
 		return "", nil, err
 	}
-	notices, err := frontierPreparationAdmission(root, source, nodes, mapping, problem, allow && capN > 1, records)
-	if err != nil {
-		return "", nil, err
+	var notices []string
+	if checkPreparation {
+		notices, err = frontierPreparationAdmission(root, source, nodes, mapping, problem, allow, records)
+		if err != nil {
+			return "", nil, err
+		}
 	}
 	local, withheld, err := WorkspaceReady(filepath.Dir(root), controller, source)
 	if err != nil {
@@ -531,7 +534,7 @@ func autocompleteWriterAdmission(root, source string, wave *dispatchWave, curren
 	if reserved {
 		binding = controller + "/" + lease.BatchID + "@" + lease.CreatedAt
 	}
-	if err := frontierWriterRetention(root, source, controller, binding, lease, nodes, ordered, ids, current); err != nil {
+	if err := frontierWriterRetention(root, source, controller, binding, lease, nodes, ordered, ids, current, checkPreparation); err != nil {
 		return "", nil, err
 	}
 	var candidates []parallel.SlicePaths
@@ -549,7 +552,7 @@ func autocompleteWriterAdmission(root, source string, wave *dispatchWave, curren
 		} else if hold != "" {
 			continue
 		}
-		if _, _, err := frontierLocal(root, controller, n, &candidates); err != nil {
+		if _, _, err := frontierLocal(root, controller, n, &candidates, nil); err != nil {
 			return "", nil, err
 		}
 	}
@@ -613,6 +616,18 @@ func autocompleteWriterAdmission(root, source string, wave *dispatchWave, curren
 	return binding, notices, nil
 }
 
+const frontierInheritedPreparationWait = "preparatory descendant; continue immediate-parent preparation before this native cursor"
+
+func frontierSourcePreparationWait(source string, lines []string) bool {
+	wait := "frontier-workspace: " + source + " location=live action=wait reason=" + frontierInheritedPreparationWait
+	for _, line := range lines {
+		if line == wait {
+			return true
+		}
+	}
+	return false
+}
+
 func frontierGlobalPriority(source string, lines []string) bool {
 	controller := source
 	for _, line := range lines {

package/engine/internal/lib/frontier_preparation.go

@@ -0,0 +1,210 @@
+package lib
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/parallel"
+)
+
+type preparationPurpose struct {
+	parent   string
+	research bool
+}
+
+func preparationPhase(phase string) bool {
+	switch phase {
+	case "spec", "clarify", "temper", "define", "plan", "vet":
+		return true
+	}
+	return false
+}
+
+func preparationRole(phase, role string) bool {
+	switch phase {
+	case "spec", "clarify", "temper":
+		return role == "evidence-scout" || role == "strategy-reviewer"
+	case "define", "plan":
+		return role == "plan-drafter" || role == "evidence-scout"
+	case "vet":
+		return role == "plan-reviewer" || role == "devex-reviewer" || role == "strategy-reviewer" || role == "code-reviewer"
+	}
+	return false
+}
+
+func (p preparationPurpose) validate(phase string, roles []string, context bool) error {
+	phase = strings.ToLower(phase)
+	if p.parent == "" && !p.research {
+		return nil
+	}
+	if p.parent != "" && p.research {
+		return fmt.Errorf("--prepare-for and --sequence-research are mutually exclusive")
+	}
+	if !preparationPhase(phase) {
+		return fmt.Errorf("preparation purpose requires a native preparation phase")
+	}
+	if len(roles) == 0 && (!context || p.research) {
+		return fmt.Errorf("preparation dispatch/research requires an allowed named role")
+	}
+	for _, role := range roles {
+		if p.research && role != "evidence-scout" || !p.research && !preparationRole(phase, roleBase(role)) {
+			return fmt.Errorf("role %q is not permitted for this preparation purpose", role)
+		}
+	}
+	return nil
+}
+
+func earlyPreparationPhase(phase string) bool {
+	phase = strings.ToLower(phase)
+	return phase == "temper" || phase == "define" || phase == "plan" || phase == "vet"
+}
+
+// Context and dispatch share admission; neither a bundle nor a purpose flag proves a native launch.
+func preparationAdmission(root, source, phase string, purpose preparationPurpose, current *dispatchFile) ([]string, error) {
+	phase = strings.ToLower(phase)
+	if purpose.research {
+		if current != nil {
+			return nil, nil
+		}
+		dir, err := devritespaths.ExistingFeatureDirChecked(root, source)
+		if err != nil {
+			return nil, err
+		}
+		raw, err := readBoundedRegularFile(filepath.Join(dir, "dispatch.json"), workspaceArtifactLimit)
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+		_, err = decodeDispatch(raw)
+		return nil, err
+	}
+	if purpose.parent == "" && !earlyPreparationPhase(phase) {
+		return nil, nil
+	}
+	mode, err := autocompleteMode(root)
+	if err != nil {
+		return nil, err
+	}
+	if purpose.parent == "" && !mode {
+		return nil, nil
+	}
+	allow, capacity, err := frontierPolicy(root)
+	if err != nil {
+		return nil, err
+	}
+	if mode {
+		_, lease, leaseErr := parallel.ControllerLease(filepath.Dir(root))
+		if leaseErr != nil {
+			return nil, leaseErr
+		}
+		if lease != nil && lease.Capacity > 0 && lease.Capacity < capacity {
+			capacity = lease.Capacity
+		}
+	}
+	if purpose.parent == "" && capacity <= 1 {
+		return nil, nil
+	}
+	nodes, err := frontierScan(root)
+	if err != nil {
+		return nil, err
+	}
+	chain, err := frontierChain(nodes, source)
+	if err != nil {
+		return nil, err
+	}
+	if mode && capacity > 1 {
+		if _, err := frontierPreparationBindings(nodes[source], current); err != nil {
+			return nil, err
+		}
+	}
+	ordered, _ := frontierRelated(nodes, chain)
+	mapping, _, problem, invalid := frontierRoadmap(nodes, ordered)
+	if invalid {
+		return nil, fmt.Errorf("invalid canonical roadmap: %s", problem)
+	}
+	if purpose.parent != "" {
+		parent, child := nodes[purpose.parent], nodes[source]
+		if parent == nil || child == nil || parent == child || child.parent != parent.slug || !parent.hasPosition || !child.hasPosition || child.position != parent.position+1 {
+			return nil, fmt.Errorf("--prepare-for requires an existing bound immediate parent with adjacent sequence positions")
+		}
+		if _, err := frontierChain(nodes, parent.slug); err != nil {
+			return nil, err
+		}
+		target, err := frontierSuccessor(parent, nodes, mapping)
+		if problem != "" || err != nil || target != source {
+			return nil, fmt.Errorf("--prepare-for parent/successor authority does not agree: %s %v", problem, err)
+		}
+		return nil, nil
+	}
+	records, err := frontierEvidence(root, source)
+	if err != nil {
+		return nil, err
+	}
+	return frontierPreparationAdmission(root, source, nodes, mapping, problem, allow && capacity > 1, records)
+}
+
+// Validate the whole retained ledger before any current-scope classification or credit.
+// A decoded account may be supplied by dispatch admission; recovery uses decode alone.
+func frontierPreparationBindings(n *frontierWorkspace, account *dispatchFile) (*dispatchFile, error) {
+	if n == nil {
+		return nil, fmt.Errorf("preparation binding source is not an existing sequence workspace")
+	}
+	if account == nil {
+		raw, err := readBoundedRegularFile(filepath.Join(n.dir, "dispatch.json"), workspaceArtifactLimit)
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+		account, err = decodeDispatch(raw)
+		if err != nil {
+			return nil, err
+		}
+	}
+	for _, wave := range account.Waves {
+		if wave.PreparationFor != "" && wave.PreparationFor != n.parent && wave.State != "complete" && (wave.State != "abandoned" || wave.TerminalAt == "") {
+			return nil, fmt.Errorf("workspace %s preparation account does not match its immediate parent", n.slug)
+		}
+	}
+	return account, nil
+}
+
+func frontierPreparatoryOnly(root string, n *frontierWorkspace, nodes map[string]*frontierWorkspace, mapping map[int]string, problem string) (bool, *dispatchFile, error) {
+	account, err := frontierPreparationBindings(n, nil)
+	if err != nil {
+		return false, nil, err
+	}
+	parent := nodes[n.parent]
+	if parent == nil || frontierTerminal(parent) || frontierTerminal(n) || problem != "" || !parent.hasPosition || !n.hasPosition || n.position != parent.position+1 {
+		return false, account, nil
+	}
+	if _, err := frontierChain(nodes, n.slug); err != nil {
+		return false, account, nil
+	}
+	target, err := frontierSuccessor(parent, nodes, mapping)
+	if err != nil || target != n.slug {
+		return false, account, nil
+	}
+	active, err := readBoundedRegularFile(filepath.Join(root, "ACTIVE"), workspaceArtifactLimit)
+	if err != nil && !os.IsNotExist(err) {
+		return false, account, err
+	}
+	if strings.TrimSpace(string(active)) == n.slug {
+		return false, account, nil
+	}
+	if account == nil {
+		return true, nil, nil
+	}
+	for _, wave := range account.Waves {
+		if wave.PreparationFor == "" && !wave.SequenceResearch && (earlyPreparationPhase(wave.Phase) || isBuildWrightWave(wave)) {
+			return false, account, nil
+		}
+	}
+	return true, account, nil
+}

package/engine/internal/lib/next.go

@@ -91,6 +91,9 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 			fmt.Fprintln(stdout, "next-command: /rite-autocomplete")
 			return exit
 		}
+		if mode && frontierSourcePreparationWait(slug, lines) {
+			return exit
+		}
 	}
 	if report.Phase == state.PhaseBuild {
 		printPlanBatch(stdout, root, slug)
@@ -118,11 +121,11 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 			}
 			missing = report.MissingFiles
 		} else {
-			if policy.Target == state.PhaseClarify && openQuestions == 0 {
+			missing = missingArtifacts(featureDir, policy.RequiredArtifacts)
+			if policy.Target == state.PhaseClarify && openQuestions == 0 && len(missing) == 0 {
 				skips = append(skips, "clarify (0 open questions)")
 				continue
 			}
-			missing = missingArtifacts(featureDir, policy.RequiredArtifacts)
 			// A phase that adds no required artifact over the previous one
 			// (build after vet, polish after prove) cannot be proven done by
 			// artifact presence, so it is never skipped. Converge is the

package/engine/internal/lib/triggers.go

@@ -176,5 +176,14 @@ func triggerApplyCommand(opts contextOpts, suggested []string) string {
 		}
 	}
 	parts = append(parts, "--trigger", strings.Join(suggested, ","))
+	if opts.purpose.parent != "" {
+		parts = append(parts, "--prepare-for", frontierQuote(opts.purpose.parent))
+	}
+	if opts.purpose.research {
+		parts = append(parts, "--sequence-research")
+	}
+	if opts.skillsRoot != "" {
+		parts = append(parts, "--skills-root", frontierQuote(opts.skillsRoot))
+	}
 	return strings.Join(parts, " ")
 }

package/pack/.claude/skills/devrites-lib/SKILL.md

@@ -39,6 +39,8 @@ lifecycle state from chat or optional `README.md`.
   completion states. The host renders the response normally.
 - [`reference/parallel-workspaces.md`](reference/parallel-workspaces.md): explicit
   phase targets, one isolated global controller, and source-owned proof.
+- [Autocomplete loop](../rite-autocomplete/reference/loop.md#early-preparation-admission):
+  controller-only early preparation, bounded successor routing and normalization research.
 - [`reference/visual-playbooks/index.md`](reference/visual-playbooks/index.md): progressive
   visual HTML playbook router (load matching ids only; dual-read outline).
 

package/pack/.claude/skills/devrites-lib/reference/parallel-workspaces.md

@@ -101,16 +101,18 @@ return cursors and native handles: one controller, not another phase or queue.
    Normalize unresolved legacy sequence authority through its owning decision/
    phase. Positive budget, ambiguous prose or path disjointness grants nothing.
    A current invalid canonical map is an error, never a fallback to history.
-   For controller mode at cap>1, before a new Build-wright wave writes claims,
-   rounds or history, start preparation of that source's immediate recorded
-   successor. Missing targets need native Spec → Clarify → Temper → Define/Plan →
-   affected Vet; existing targets need completed native state, actual pending
-   planning/review handles, current Build-ready binding, or a human/dependency hold.
-   Completed live/archived successors need no reopening; retained actors still bind.
-   A placeholder, prose claim, unopened wave or unrelated reviewer is insufficient.
-   Pipeline one successor per admitted source; preparing the whole roadmap first
-   is unnecessary. Opt-out, zero opening budget or source human/question holds
-   prevent new openings, not already-created child planning or independent work.
+   At controller cap>1, resolve sequence authority and start actual immediate-
+   successor preparation before ordinary local Temper/Define/Plan/Vet context or
+   dispatch open, and retain the full Build gate before claims/rounds/history.
+   Follow [early preparation](../../rite-autocomplete/reference/loop.md#early-preparation-admission)
+   for native launch/start, internal markers and bounded preparatory-only routing.
+   Missing targets need native Spec → Clarify → Temper → Define/Plan → affected
+   Vet; existing targets need current completed/readiness state, registered pending
+   native preparation, or an existing human/dependency hold. Completed live/
+   archived successors need no reopening; valid finite tails discharge the
+   obligation. Placeholders, reports and unopened waves prove nothing.
+   Opt-out, zero opening budget or source human/question holds prevent new
+   openings, not existing child preparation or independent work.
    If preparation cannot start, retain `frontier-blocked: <successor> — <constraint>`
    in source `evidence.md`. `frontier-blocked: sequence — <constraint>` may defer
    unresolved historical normalization for valid independent local work. Each row

package/pack/.claude/skills/rite-autocomplete/SKILL.md

@@ -115,11 +115,13 @@ next sequence continuation through Vet in a second session, then stop.
    Temper → Define → Vet → Build → Prove → Polish → Review → Seal. Durable files
    carry state. Apply the mutable post-vet budget before Build. Consume fresh scheduling
    emitted by recorded `dispatch return`; rerun frontier after further changes
-   and before waits. Start actual immediate-successor preparation before local
-   writer admission, or disclose the narrow deferral in the shared global pass.
-   A placeholder or report is not preparation; the entire sequence need not be
-   prepared at once. Preserve local cursors and protected validation windows;
-   pass Build the resolved global cap and retain every admission/isolation gate.
+   and before waits. Before ordinary local Temper/Define/Plan/Vet context/dispatch,
+   resolve sequence authority and start actual immediate-successor preparation
+   under [early admission](reference/loop.md#early-preparation-admission),
+   or retain the global pass's concrete deferral; keep the full Build gate.
+   Derive initial preparatory-only routing before any marked wave; do not recurse
+   through the roadmap. Preserve local cursors, protected validation windows and
+   every admission/isolation gate; pass Build the resolved global cap.
    **Completion:** Seal GO or a durable valid stop precedes later phases.
 5. **Apply stops.** At every gate use
    [stop-conditions.md](reference/stop-conditions.md). A `blocked` label alone is not a stop condition:

package/pack/.claude/skills/rite-autocomplete/reference/loop.md

@@ -39,18 +39,41 @@ remaining. AFK configuration itself stays unchanged.
 
 ### Admit each unattended cycle
 
-Before each phase, fan-out, recovery or writer: run cheap readiness and reject
-overlap. Before Build admission, execute the shared immediate-successor
-preparation/deferral and global cohort rules; local readiness alone is insufficient.
-Count every leaf result. Explicit activations reset activation-local counters,
-not durable slice/recovery state. Pass resolved `--parallel N` to
-[Build](../../rite-build/reference/output.md#caller-owned-continuation).
-Ignored legacy budgets and local serial constraints are not whole-run stops.
-Invented ceilings on dispatches, waits, tool calls or turns cannot stop execution;
-human instructions to pause or limit scope still bind.
-Resolve ranked validating/blocking picks via `devrites-engine state resolve`;
-never hand `/rite-resolve` to the user. Escalating, irreversible-risk, access, blocking
-without recommendations, and Seal judgment (`slice: seal`) still pause.
+Before each phase/fan-out/recovery/writer, check readiness/overlap and apply early
+admission and the global pass below; local readiness is insufficient. Count every leaf.
+Explicit activation resets only activation-local counters, not durable recovery.
+Pass resolved `--parallel N` to [Build](../../rite-build/reference/output.md#caller-owned-continuation).
+Legacy or invented execution ceilings never stop this controller; human limits bind.
+Resolve ranked validating/blocking picks via `devrites-engine state resolve`, not
+a user handoff. Escalating, irreversible-risk, access, unrecommended blocking picks
+and Seal judgment (`slice: seal`) still pause.
+
+## Early preparation admission
+
+Internal exclusive `context`/`dispatch open` flags:
+- `--prepare-for <parent-source>`: permitted native non-Build preparation roles
+  (only controlling-root context may be roleless), exact existing immediate
+  successor/parent agreeing on canonical identity, binding, adjacency and chain.
+  Exempts the child's successor gate, never product writes.
+- `--sequence-research`: only canonical `evidence-scout`, Spec/Clarify/Temper/Define/
+  Plan/Vet, exact existing source and normal path/role/ledger constraints. Exempts
+  authority/successor admission solely to investigate broken authority read-only:
+  no acceptance, scope/approval/phase advance, successor creation, writers,
+  readiness or preparation credit.
+
+Context (`--skill rite-<phase>` too) checks before writes; no account required.
+Use context → packet → open → native launch → `dispatch start` actual handles
+before parent admission; openings alone do not count.
+
+Derive preparatory-only B before any marked wave from nonterminal parent A:
+until ordinary unmarked B Temper/Define/Plan/Vet or Build-wright admission
+(checking C first), A becoming terminal or ordered handoff to B, C waits—even
+explicit C `next`/`check continuation`. No C creation/rerouting before A's eligible
+phase. Completed B history retains this bound; Spec/Clarify/research/read-only
+Build do not release it. Independent work stays visible; all global-pass gates bind.
+
+Shared registry edits alone do not serialize disjoint modules. Isolate their
+writer; refusal-only tests never replace positive requirements or defer their band.
 
 ## Phase arc
 
@@ -70,12 +93,10 @@ Workspace files, not chat, carry state. Read/execute each phase skill:
 | 10 | `/rite-seal` | GO/NO-GO; no Git |
 | 11 | `/rite-ship` | only after GO; `--ship` never authorizes Git; stop at literal-GO/native approval |
 
-At phase entry, before local recovery or waits, execute the
+At phase entry, before recovery/waits, execute the
 [global pass](../../devrites-lib/reference/parallel-workspaces.md#continuous-global-frontier).
-Consume the fresh frontier emitted after a recorded `dispatch return`; after
-landing, planning/artifact changes or capacity updates, rerun frontier. Execute
-authorized preparation/selection, preserving pending handles, local cursors and
-protected validation windows. Reporting or creating a placeholder is not progress.
+Consume persisted return frontiers; rerun after landing/artifact/capacity changes.
+Execute authorized routes, retaining handles, cursors and protected proof windows.
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
 pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or
@@ -88,14 +109,12 @@ floor; `--update` never excuses an unreconciled regression.
 
 ## Sequence continuation
 
-With a recorded successor, opening budget and no opt-out, Seal GO stays internal:
-leave the owner sealed/unshipped with `/rite-ship`, then resume the prepared child
-or invoke its authorized native Spec. Sequence authority follows the
-[shared grammar](../../devrites-lib/reference/workspace-artifact-schema.md#what-each-file-owns),
-not invented slugs. Charge an opening once; preparation may pipeline before Seal,
-one immediate successor per admitted source, not the whole roadmap at once.
-Reuse the child's durable cursor and controller. ACTIVE changes only at normal
-ordered handoff; early planning or isolated independent Build does not advance it.
+With a recorded successor, budget and no opt-out, Seal GO stays internal:
+leave the owner sealed/unshipped with `/rite-ship`; resume the child's cursor/
+controller or authorized native Spec. Use the
+[shared grammar](../../devrites-lib/reference/workspace-artifact-schema.md#what-each-file-owns).
+Charge once; pipeline only immediate successors. ACTIVE changes at ordered handoff,
+not early planning or isolated independent Build.
 
 Before invoking a continuation, require durable `state.md`
 `sequence_workspaces_remaining > 0`; if absent, first write
@@ -149,20 +168,14 @@ and park it after three escalations while independent work continues.
 
 ## Continuous caller obligation
 
-After a green slice or phase, execute its recorded `next_action` internally;
-reply only at completion or a genuine stop.
-
-Before replying, run `devrites-engine check continuation`: `required` means
-consume `invoke:` now; only `clear` permits a final reply. Under controller mode,
-actionable normalization, successor preparation or foreign work precedes local
-Build. Local-only reconciliation, repair, picks or discharged scheduling deferrals
-retain the owning phase edge, not recursive `/rite-autocomplete`.
-Agent-owned NEEDS_REPLAN, budgeted Critical/Important recovery, independent work
-or a recommended blocking answer stays internal. Invoke repair or `state resolve`
-unless the [resolver-failure stop](stop-conditions.md#other-stop-classes) applies.
-A distinct invariant is progress, not exhaustion; repeated failed resolver calls
-without correction are not progress.
-
-The number of completed repair/Vet cycles, context pressure, compaction, session
-duration, and nested completion never turn checkpoints into handoffs. Persist and
-resume to the requested rest point or shared human/safety/access/parked-recovery stop.
+Execute each green slice/phase's `next_action` internally. Before replying, run
+`devrites-engine check continuation`: consume `required`'s `invoke:`; only `clear`
+permits reply. Controller normalization/preparation/foreign work precedes local
+Build; local repair/picks/reconciliation/discharged deferrals keep their phase,
+not recursive Autocomplete. Route agent-owned NEEDS_REPLAN, budgeted Critical/Important recovery,
+independent work and recommended blocking answers internally; invoke repair or
+`state resolve` unless the [resolver-failure stop](stop-conditions.md#other-stop-classes)
+applies. Distinct invariants are progress; unchanged resolver retries are not.
+Cycles, context pressure, compaction, duration and nested completion never create
+handoffs. Persist/resume until requested completion or a shared human/safety/
+access/parked-recovery stop.

package/pack/generated/claude/skills/devrites-lib/SKILL.md

@@ -39,6 +39,8 @@ lifecycle state from chat or optional `README.md`.
   completion states. The host renders the response normally.
 - [`reference/parallel-workspaces.md`](reference/parallel-workspaces.md): explicit
   phase targets, one isolated global controller, and source-owned proof.
+- [Autocomplete loop](../rite-autocomplete/reference/loop.md#early-preparation-admission):
+  controller-only early preparation, bounded successor routing and normalization research.
 - [`reference/visual-playbooks/index.md`](reference/visual-playbooks/index.md): progressive
   visual HTML playbook router (load matching ids only; dual-read outline).