devrites 7.3.5 → 7.3.7

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/regression.go

@@ -59,6 +59,18 @@ var (
 	regressH2Re      = regexp.MustCompile(`(?m)^## `)
 )
 
+// ledgerOwner returns the slice digits a checked state.md item owns: only its
+// first slice token (documented `SLICE-003` or `Slice 3`). Later tokens on the
+// same line are context — a blocked dependent, an INV reference, a NOT_RUN
+// note — and do not make those slices built.
+func ledgerOwner(item string) (string, bool) {
+	m := regressSliceIDRe.FindStringSubmatch(item)
+	if m == nil {
+		return "", false
+	}
+	return m[1], true
+}
+
 // progressFingerprint is the structural state one baseline records. Sets are
 // sorted for deterministic output and diffing.
 type progressFingerprint struct {
@@ -180,13 +192,15 @@ func fingerprintWorkspace(root, slug, workspace string) (progressFingerprint, er
 	note("state.md", err)
 	if err == nil {
 		for _, item := range regressBuiltRe.FindAllString(masked, -1) {
-			for _, m := range regressSliceIDRe.FindAllStringSubmatch(item, -1) {
-				// `SLICE-001` and `Slice 1` name the same slice.
-				n, _ := strconv.Atoi(m[1])
-				id := fmt.Sprintf("SLICE-%03d", n)
-				if !slices.Contains(fp.DoneSlices, id) {
-					fp.DoneSlices = append(fp.DoneSlices, id)
-				}
+			digits, ok := ledgerOwner(item)
+			if !ok {
+				continue
+			}
+			// `SLICE-001` and `Slice 1` name the same slice.
+			n, _ := strconv.Atoi(digits)
+			id := fmt.Sprintf("SLICE-%03d", n)
+			if !slices.Contains(fp.DoneSlices, id) {
+				fp.DoneSlices = append(fp.DoneSlices, id)
 			}
 		}
 	}

package/engine/internal/lib/taskgraph.go

@@ -235,8 +235,8 @@ func builtSlicesFrom(read func(string) ([]byte, error)) (map[string]bool, error)
 		if !builtWordRe.MatchString(item) {
 			continue
 		}
-		for _, m := range regressSliceIDRe.FindAllStringSubmatch(item, -1) {
-			built[strings.TrimLeft(m[1], "0")] = true
+		if digits, ok := ledgerOwner(item); ok {
+			built[strings.TrimLeft(digits, "0")] = true
 		}
 	}
 	extra, err := evidenceBuiltFrom(read)

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: