devrites 7.3.4 → 7.3.6

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

@@ -0,0 +1,168 @@
+package lib
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/markdowntext"
+)
+
+// frontierCanonicalRoadmap reads current authority from the full related sequence.
+// A nil map without an error leaves headerless historical maps to legacy parsing.
+func frontierCanonicalRoadmap(nodes map[string]*frontierWorkspace, ordered []string) (mapping map[int]string, artifacts []string, err error) {
+	var owner *frontierWorkspace
+	var lines []string
+	for _, slug := range ordered {
+		n := nodes[slug]
+		if n == nil || n.dir == "" {
+			continue
+		}
+		path := filepath.Join(n.dir, "roadmap.md")
+		raw, readErr := readBoundedRegularFile(path, workspaceArtifactLimit)
+		if os.IsNotExist(readErr) {
+			continue
+		}
+		if readErr != nil {
+			return nil, append(artifacts, path), fmt.Errorf("roadmap %s unreadable: %w", path, readErr)
+		}
+		structural, parseErr := markdowntext.Structural(raw)
+		if parseErr != nil {
+			return nil, append(artifacts, path), fmt.Errorf("roadmap %s malformed: %w", path, parseErr)
+		}
+		candidate := strings.Split(string(structural), "\n")
+		explicit := false
+		for _, line := range candidate {
+			line = strings.TrimSpace(line)
+			if strings.HasPrefix(line, "Sequence root:") || strings.HasPrefix(line, "Decision:") {
+				explicit = true
+				break
+			}
+		}
+		if !explicit {
+			continue
+		}
+		artifacts = append(artifacts, path)
+		if owner != nil {
+			return nil, artifacts, fmt.Errorf("multiple canonical roadmap owners: %s and %s", owner.slug, slug)
+		}
+		owner, lines = n, candidate
+	}
+	if owner == nil {
+		return nil, nil, nil
+	}
+	root, decision := "", ""
+	rootCount, decisionCount := 0, 0
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if value, ok := strings.CutPrefix(line, "Sequence root:"); ok {
+			root, rootCount = strings.TrimSpace(value), rootCount+1
+		}
+		if value, ok := strings.CutPrefix(line, "Decision:"); ok {
+			decision, decisionCount = strings.TrimSpace(value), decisionCount+1
+		}
+	}
+	if rootCount != 1 || decisionCount != 1 || !devritespaths.ValidSlug(root) || strings.ContainsAny(root, " \t") || strings.HasPrefix(root, "-") {
+		return nil, artifacts, fmt.Errorf("canonical roadmap requires one valid Sequence root and Decision header")
+	}
+	if len(decision) != 7 || !strings.HasPrefix(decision, "DEC-") || strings.Trim(decision[4:], "0123456789") != "" {
+		return nil, artifacts, fmt.Errorf("canonical roadmap Decision must be DEC-NNN")
+	}
+	decisionPath := filepath.Join(owner.dir, "decisions.md")
+	artifacts = append(artifacts, decisionPath)
+	raw, readErr := readBoundedRegularFile(decisionPath, workspaceArtifactLimit)
+	if readErr != nil {
+		return nil, artifacts, fmt.Errorf("canonical roadmap decision unreadable: %w", readErr)
+	}
+	structural, parseErr := markdowntext.Structural(raw)
+	if parseErr != nil {
+		return nil, artifacts, fmt.Errorf("canonical roadmap decision malformed: %w", parseErr)
+	}
+	headings := 0
+	for _, line := range strings.Split(string(structural), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && fields[0] == "##" && fields[1] == decision {
+			headings++
+		}
+	}
+	if headings != 1 {
+		return nil, artifacts, fmt.Errorf("canonical roadmap Decision %s requires one exact owner-local heading, found %d", decision, headings)
+	}
+	mapping = map[int]string{}
+	positions := map[string]int{}
+	tables := 0
+	for i := 0; i < len(lines); i++ {
+		cells := frontierCells(lines[i])
+		if len(cells) != 0 && (len(cells) != 2 || cells[0] != "Position" || cells[1] != "Workspace") {
+			return nil, artifacts, fmt.Errorf("canonical roadmap contains an unexpected table")
+		}
+		if len(cells) != 2 || cells[0] != "Position" || cells[1] != "Workspace" {
+			continue
+		}
+		tables++
+		if tables != 1 || i+1 >= len(lines) {
+			return nil, artifacts, fmt.Errorf("canonical roadmap requires exactly one Position/Workspace table")
+		}
+		separator := frontierCells(lines[i+1])
+		if len(separator) != 2 {
+			return nil, artifacts, fmt.Errorf("canonical roadmap table separator malformed")
+		}
+		for _, cell := range separator {
+			if len(strings.Trim(cell, ":")) < 3 || strings.Trim(cell, "-:") != "" {
+				return nil, artifacts, fmt.Errorf("canonical roadmap table separator malformed")
+			}
+		}
+		i += 2
+		for ; i < len(lines) && strings.HasPrefix(strings.TrimSpace(lines[i]), "|"); i++ {
+			row := frontierCells(lines[i])
+			if len(row) != 2 {
+				return nil, artifacts, fmt.Errorf("canonical roadmap table row malformed")
+			}
+			position, numberErr := strconv.Atoi(row[0])
+			slug := row[1]
+			if numberErr != nil || position != len(mapping)+1 || strconv.Itoa(position) != row[0] {
+				return nil, artifacts, fmt.Errorf("canonical roadmap positions must be unique and contiguous from 1")
+			}
+			if !devritespaths.ValidSlug(slug) || strings.ContainsAny(slug, " \t") || strings.HasPrefix(slug, "-") || positions[slug] != 0 {
+				return nil, artifacts, fmt.Errorf("canonical roadmap requires unique valid workspace slugs")
+			}
+			mapping[position], positions[slug] = slug, position
+		}
+		i--
+	}
+	if tables != 1 || len(mapping) == 0 || mapping[1] != root {
+		return nil, artifacts, fmt.Errorf("canonical roadmap requires one nonempty table rooted at Sequence root")
+	}
+	for _, slug := range ordered {
+		n := nodes[slug]
+		chain, chainErr := frontierChain(nodes, slug)
+		if chainErr != nil {
+			return nil, artifacts, fmt.Errorf("canonical roadmap recorded chain invalid: %w", chainErr)
+		}
+		if chain[len(chain)-1] != root {
+			return nil, artifacts, fmt.Errorf("canonical roadmap root %s does not match actual chain anchor", root)
+		}
+		position := positions[slug]
+		if position == 0 || n.hasPosition && n.position != position {
+			return nil, artifacts, fmt.Errorf("canonical roadmap conflicts with recorded position for %s", slug)
+		}
+		if n.parent != mapping[position-1] {
+			return nil, artifacts, fmt.Errorf("canonical roadmap conflicts with recorded predecessor for %s", slug)
+		}
+		if target := frontierSpecTarget(n); target != "" && mapping[position+1] != target {
+			return nil, artifacts, fmt.Errorf("canonical roadmap conflicts with next Spec for %s", slug)
+		}
+	}
+	for _, slug := range mapping {
+		if n := nodes[slug]; n != nil {
+			position := positions[slug]
+			if n.problem != nil || n.hasPosition && n.position != position || n.parent != mapping[position-1] {
+				return nil, artifacts, fmt.Errorf("canonical roadmap workspace %s is not bound to its recorded sequence position", slug)
+			}
+		}
+	}
+	return mapping, artifacts, nil
+}

package/engine/internal/lib/next.go

@@ -82,6 +82,18 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 		for _, line := range lines {
 			fmt.Fprintln(stdout, line)
 		}
+		mode, err := autocompleteMode(root)
+		if err != nil {
+			fmt.Fprintf(stderr, "next: %v\n", err)
+			return 2
+		}
+		if mode && frontierGlobalPriority(slug, lines) {
+			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)
@@ -109,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/engine/internal/parallel/repository.go

@@ -169,6 +169,8 @@ func controllerLease(root, controller string) (*repositoryLease, error) {
 
 // ControllerLease returns the retained repository controller without changing its lease.
 // A lease in another checkout requires recovery at that explicit control root.
+// Recorded checkout/ref identity must still match; legacy leases lack that evidence.
+// Active reservations must remain path-disjoint; integrated history holds no slot.
 func ControllerLease(repoRoot string) (string, *Lease, error) {
 	found, err := controllerLease(repoRoot, "")
 	if err != nil || found == nil {
@@ -177,6 +179,14 @@ func ControllerLease(repoRoot string) (string, *Lease, error) {
 	if found.root != resolvedPath(repoRoot) {
 		return "", nil, fmt.Errorf("repository controller lease retained by %s at %s; recover at its explicit root", found.controller, found.root)
 	}
+	if err := ensureControllerIdentity(repoRoot, found.lease); err != nil {
+		return "", nil, err
+	}
+	if active := activeSlices(found.lease); len(active) >= 2 {
+		if _, err := CheckPathDisjoint(active, repoRoot); err != nil {
+			return "", nil, err
+		}
+	}
 	return found.controller, found.lease, nil
 }
 

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).