devrites 7.3.4 → 7.3.6

package/engine/internal/lib/frontier.go

@@ -5,7 +5,6 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"sort"
 	"strconv"
 	"strings"
 
@@ -241,6 +240,10 @@ func frontierQuote(s string) string { return "'" + strings.ReplaceAll(s, "'", "'
 
 // FrontierLines reports structural obligations, never semantic authorization or Ship approval.
 func FrontierLines(root, slug string) ([]string, error) {
+	mode, err := autocompleteMode(root)
+	if err != nil {
+		return nil, err
+	}
 	if slug == "" {
 		var err error
 		slug, err = devritespaths.ActiveSlug(root)
@@ -248,11 +251,13 @@ func FrontierLines(root, slug string) ([]string, error) {
 			return nil, err
 		}
 	}
+	workspaceOverride := ""
 	if slug != "" {
 		if !devritespaths.ValidSlug(slug) {
 			return nil, fmt.Errorf("invalid source slug")
 		}
-		if _, err := devritespaths.WorkspaceOverrideChecked(root, slug); err != nil {
+		workspaceOverride, err = devritespaths.WorkspaceOverrideChecked(root, slug)
+		if err != nil {
 			return nil, err
 		}
 	}
@@ -288,44 +293,21 @@ func FrontierLines(root, slug string) ([]string, error) {
 	}
 	chain, chainErr := frontierChain(nodes, slug)
 	if chainErr != nil {
-		return []string{"frontier: blocked", "frontier-source: " + slug, fmt.Sprintf("frontier-workspace: %s location=%s action=repair reason=%s", slug, source.location, chainErr)}, nil
-	}
-	anchor := chain[len(chain)-1]
-	related := map[string]bool{anchor: true}
-	for range maxSequenceChain {
-		changed := false
-		for name, n := range nodes {
-			if related[n.parent] && !related[name] {
-				related[name] = true
-				changed = true
-			}
-		}
-		if !changed {
-			break
-		}
-	}
+		location := "work"
+		if source.location == "archive" {
+			location = "archive"
+		}
+		artifact := filepath.Join(root, location, slug, "state.md")
+		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: reason=native authority-normalization required: " + chainErr.Error() + " artifacts=" + artifact,
+		}, nil
+	}
+	ordered, related := frontierRelated(nodes, chain)
 	if len(related) == 1 && source.parent == "" && !source.hasPosition && !source.hasRemaining && frontierSpecTarget(source) == "" {
 		return []string{"frontier: none"}, nil
 	}
-	ordered := make([]string, 0, len(related))
-	for name := range related {
-		ordered = append(ordered, name)
-	}
-	depth := make(map[string]int, len(ordered))
-	for _, name := range ordered {
-		chain, _ := frontierChain(nodes, name)
-		depth[name] = len(chain)
-	}
-	sort.Slice(ordered, func(i, j int) bool {
-		a, b := nodes[ordered[i]], nodes[ordered[j]]
-		if depth[a.slug] != depth[b.slug] {
-			return depth[a.slug] < depth[b.slug]
-		}
-		if a.position != b.position {
-			return a.position < b.position
-		}
-		return a.slug < b.slug
-	})
 	controller := ""
 	for _, name := range ordered {
 		if nodes[name].location == "live" {
@@ -350,6 +332,9 @@ func FrontierLines(root, slug string) ([]string, error) {
 	if err != nil {
 		return nil, err
 	}
+	if workspaceOverride != "" {
+		allowFuture = false
+	}
 	if lease != nil && lease.Capacity > 0 && capN > lease.Capacity {
 		capN = lease.Capacity
 	}
@@ -364,12 +349,43 @@ func FrontierLines(root, slug string) ([]string, error) {
 	if source.hasRemaining && source.remaining == 0 {
 		allowFuture = false
 	}
-	maps, artifacts, mapProblem := frontierRoadmap(nodes, ordered)
+	maps, artifacts, mapProblem, invalidCanonical := frontierRoadmap(nodes, ordered)
+	if invalidCanonical {
+		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, ","))
+	}
+	records := frontierRecords{}
+	if mode {
+		records, err = frontierEvidence(root, slug)
+		if err != nil {
+			return nil, err
+		}
+	}
+	sequenceDeferred := mode && records.blocked["sequence"] != ""
 	if mapProblem != "" {
-		lines = append(lines, "frontier-review-sequence: "+strings.Join(artifacts, ",")+" reason=native authority-normalization required: "+mapProblem)
-		blocked = true
+		if sequenceDeferred {
+			lines = append(lines, "frontier-blocked: sequence — "+records.blocked["sequence"]+"; scheduling deferred, not normalized")
+		} else {
+			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"
@@ -382,25 +398,38 @@ 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
+			held = inheritedPreparation || action == "blocked" || err != nil || mode && action == "wait" && deferred[name] != ""
 			switch action {
 			case "inspect", "prepare", "repair":
 				actionable = true
 			case "wait":
 				waiting = true
+			case "no-cursor":
+				blocked = true
+				action = "wait"
 			case "blocked":
 				blocked = true
 				action = "wait"
 			}
 		}
 		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
 		}
@@ -409,18 +438,18 @@ func FrontierLines(root, slug string) ([]string, error) {
 			target = maps[n.position+1]
 		}
 		if mapProblem != "" {
-			if target != "" || n.hasRemaining && n.remaining > 0 {
+			if !sequenceDeferred && (target != "" || n.hasRemaining && n.remaining > 0) {
 				actionable = true
 			}
 			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
 		}
@@ -429,16 +458,47 @@ func FrontierLines(root, slug string) ([]string, error) {
 			actionable, blocked = true, true
 			continue
 		}
+		if mode && target != "" {
+			sourceRecords := records
+			if name != slug {
+				sourceRecords, err = frontierEvidence(root, name)
+				if err != nil {
+					return nil, err
+				}
+			}
+			if reason := sourceRecords.blocked[target]; reason != "" {
+				deferred[target] = reason
+				lines = append(lines, "frontier-blocked: "+target+" source="+name+" — "+reason+"; preparation deferred, not approved")
+				continue
+			}
+		}
 		if target != "" && nodes[target] == nil && !prepared[target] {
 			prepared[target] = true
 			// A table identifies a preparation obligation, not approval to implement it.
 			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
 		}
 	}
+	if mode {
+		filtered := candidates[:0]
+		for _, candidate := range candidates {
+			workspace := candidate.Workspace
+			if workspace == "" {
+				workspace = controller
+			}
+			if workspace != slug {
+				if reason := frontierSerialReason(records, slug, workspace, candidate.ID); reason != "" {
+					lines = append(lines, "frontier-serial: "+workspace+"/"+candidate.ID+" — "+reason+"; ordered handoff retained")
+					continue
+				}
+			}
+			filtered = append(filtered, candidate)
+		}
+		candidates = filtered
+	}
 	if controller != "" && controllerProblem == "" && len(live) > 0 {
 		lines = append(lines, fmt.Sprintf("frontier-select-command: devrites-engine parallel select --root %s --slug %s --from-plan --workspaces %s --cap %d", frontierQuote(filepath.Dir(root)), frontierQuote(controller), frontierQuote(strings.Join(live, ",")), capN))
 		if len(candidates) > 0 {
@@ -533,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
@@ -544,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 {
@@ -638,12 +703,22 @@ func frontierLocal(root, controller string, n *frontierWorkspace, candidates *[]
 		n.selectionHeld = true
 		return "wait", "Ship requires existing native authority; controller invocation is not approval", nil
 	}
+	if n.next == "" {
+		// Missing local work is not a hold on independently recorded preparation.
+		n.selectionHeld = true
+		return "no-cursor", "no actionable native internal cursor; review state without inventing authority", nil
+	}
 	return "blocked", "no actionable native internal cursor; review state without inventing authority", nil
 }
 
-// Only exact position/slug or position/workspace tables are structural authority.
-// Different maps require native normalization, even if prose claims one supersedes another.
-func frontierRoadmap(nodes map[string]*frontierWorkspace, ordered []string) (map[int]string, []string, string) {
+// Current canonical authority supersedes historical tables without rewriting them.
+// Without it, differing exact legacy maps require native normalization.
+func frontierRoadmap(nodes map[string]*frontierWorkspace, ordered []string) (map[int]string, []string, string, bool) {
+	if mapping, artifacts, err := frontierCanonicalRoadmap(nodes, ordered); err != nil {
+		return nil, artifacts, err.Error(), true
+	} else if mapping != nil {
+		return mapping, artifacts, "", false
+	}
 	result := map[int]string{}
 	var artifacts []string
 	problem := ""
@@ -743,7 +818,7 @@ func frontierRoadmap(nodes map[string]*frontierWorkspace, ordered []string) (map
 			artifacts = append(artifacts, filepath.Join(nodes[slug].dir, "state.md"))
 		}
 	}
-	return result, artifacts, problem
+	return result, artifacts, problem, false
 }
 
 func frontierCells(line string) []string {
@@ -782,6 +857,12 @@ func frontierBoundSpec(root, slug, action string) bool {
 	if err != nil {
 		return false
 	}
+	ordered, _ := frontierRelated(nodes, chain)
+	mapping, _, problem, invalidCanonical := frontierRoadmap(nodes, ordered)
+	if invalidCanonical {
+		return false
+	}
+	// Existing checked children remain resumable under ambiguous historical maps.
 	if child := nodes[target]; child != nil {
 		if child.parent != slug {
 			return false
@@ -791,7 +872,6 @@ func frontierBoundSpec(root, slug, action string) bool {
 		}
 		return true
 	}
-	mapping, _, problem := frontierRoadmap(nodes, chain)
 	if problem != "" || n.hasPosition && mapping[n.position+1] != "" && mapping[n.position+1] != target {
 		return false
 	}