devrites 4.1.0 → 4.3.0

package/engine/internal/parallel/parallel_test.go

@@ -0,0 +1,242 @@
+package parallel
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func gitOk(t *testing.T, dir string, args ...string) string {
+	t.Helper()
+	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
+	cmd.Env = append(os.Environ(),
+		"GIT_CONFIG_NOSYSTEM=1",
+		"GIT_TERMINAL_PROMPT=0",
+		"GIT_AUTHOR_NAME=DevRites Test",
+		"GIT_AUTHOR_EMAIL=devrites@example.invalid",
+		"GIT_COMMITTER_NAME=DevRites Test",
+		"GIT_COMMITTER_EMAIL=devrites@example.invalid",
+	)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("git %v: %v\n%s", args, err, out)
+	}
+	return strings.TrimSpace(string(out))
+}
+
+func setupRepo(t *testing.T) (repo, base string) {
+	t.Helper()
+	repo = t.TempDir()
+	gitOk(t, repo, "init")
+	gitOk(t, repo, "checkout", "-b", "main")
+	if err := os.MkdirAll(filepath.Join(repo, "src"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(repo, "src", "a.go"), []byte("package main\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(repo, "src", "b.go"), []byte("package main\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(repo, "README.md"), []byte("base\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, repo, "add", ".")
+	gitOk(t, repo, "commit", "-m", "base")
+	base = gitOk(t, repo, "rev-parse", "HEAD")
+	return repo, base
+}
+
+func TestLeaseRoundTrip(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "parallel-lease.md")
+	lease := &Lease{
+		BatchID:             "batch1",
+		CreatedAt:           "2026-08-23T00:00:00Z",
+		BaseSHA:             "abcdef1",
+		N:                   2,
+		Status:              StatusRunning,
+		ControlPIDOrSession: "test",
+		Slices: []LeaseSlice{
+			{ID: "slice-a", Paths: []string{"src/a.go"}, WorktreePath: "/tmp/a", Branch: "devrites/parallel/x/batch1/slice-a", WrightStatus: WrightPending},
+			{ID: "slice-b", Paths: []string{"src/b.go"}, WorktreePath: "/tmp/b", Branch: "devrites/parallel/x/batch1/slice-b", WrightStatus: WrightPending},
+		},
+	}
+	if err := WriteLease(path, lease); err != nil {
+		t.Fatal(err)
+	}
+	got, err := ReadLease(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.BatchID != "batch1" || got.Status != StatusRunning || len(got.Slices) != 2 {
+		t.Fatalf("unexpected lease: %#v", got)
+	}
+}
+
+func TestCreateAbortCleanup(t *testing.T) {
+	repo, base := setupRepo(t)
+	slug := "demo-feature"
+	batch := "batch1"
+	lease, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    slug,
+		BatchID: batch,
+		BaseSHA: base,
+		Slices: []SlicePaths{
+			{ID: "slice-a", Paths: []string{"src/a.go"}},
+			{ID: "slice-b", Paths: []string{"src/b.go"}},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease.Status != StatusRunning || lease.N != 2 {
+		t.Fatalf("lease=%#v", lease)
+	}
+	wtA := lease.Slices[0].WorktreePath
+	wtB := lease.Slices[1].WorktreePath
+	for _, wt := range []string{wtA, wtB} {
+		if _, err := os.Stat(wt); err != nil {
+			t.Fatalf("missing worktree %s: %v", wt, err)
+		}
+		if head := gitOk(t, wt, "rev-parse", "HEAD"); head != base {
+			t.Fatalf("worktree head %s want %s", head, base)
+		}
+	}
+	if head := gitOk(t, repo, "rev-parse", "HEAD"); head != base {
+		t.Fatalf("control moved after create: %s", head)
+	}
+
+	// Drift control tip, then abort should restore base.
+	if err := os.WriteFile(filepath.Join(repo, "README.md"), []byte("drift\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, repo, "add", "README.md")
+	gitOk(t, repo, "commit", "-m", "drift")
+	if _, err := Abort(repo, slug, true); err != nil {
+		t.Fatal(err)
+	}
+	if head := gitOk(t, repo, "rev-parse", "HEAD"); head != base {
+		t.Fatalf("abort left control at %s want %s", head, base)
+	}
+	leasePath, _ := LeasePath(repo, slug)
+	lease, err = ReadLease(leasePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease.Status != StatusAborted {
+		t.Fatalf("status=%s", lease.Status)
+	}
+	if _, err := os.Stat(wtA); err != nil {
+		t.Fatalf("abort should preserve worktree: %v", err)
+	}
+
+	if err := Cleanup(repo, slug, true); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(wtA); !os.IsNotExist(err) {
+		t.Fatalf("cleanup should remove worktree A")
+	}
+	if _, err := os.Stat(leasePath); !os.IsNotExist(err) {
+		t.Fatalf("cleanup should clear lease")
+	}
+}
+
+func TestCreateRefusesOverlap(t *testing.T) {
+	repo, base := setupRepo(t)
+	_, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    "demo",
+		BatchID: "batch1",
+		BaseSHA: base,
+		Slices: []SlicePaths{
+			{ID: "slice-a", Paths: []string{"src/a.go"}},
+			{ID: "slice-b", Paths: []string{"src/a.go"}},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "overlap") {
+		t.Fatalf("expected overlap refusal, got %v", err)
+	}
+}
+
+func TestIntegrateDivergentSiblings(t *testing.T) {
+	repo, base := setupRepo(t)
+	slug := "demo-feature"
+	batch := "batch1"
+	lease, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    slug,
+		BatchID: batch,
+		BaseSHA: base,
+		Slices: []SlicePaths{
+			{ID: "slice-a", Paths: []string{"src/a.go"}},
+			{ID: "slice-b", Paths: []string{"src/b.go"}},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	wtA := lease.Slices[0].WorktreePath
+	wtB := lease.Slices[1].WorktreePath
+
+	if err := os.WriteFile(filepath.Join(wtA, "src", "a.go"), []byte("package main\n\nfunc A() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, wtA, "add", "src/a.go")
+	gitOk(t, wtA, "commit", "-m", "slice-a green")
+	tcA := gitOk(t, wtA, "rev-parse", "HEAD")
+
+	if err := os.WriteFile(filepath.Join(wtB, "src", "b.go"), []byte("package main\n\nfunc B() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, wtB, "add", "src/b.go")
+	gitOk(t, wtB, "commit", "-m", "slice-b green")
+	tcB := gitOk(t, wtB, "rev-parse", "HEAD")
+
+	if _, err := RecordGreen(repo, slug, "slice-a", tcA); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := RecordGreen(repo, slug, "slice-b", tcB); err != nil {
+		t.Fatal(err)
+	}
+
+	tip, lease, err := Integrate(IntegrateOpts{Root: repo, Slug: slug, ApplyToControl: true})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease.Status != StatusComplete {
+		t.Fatalf("status=%s", lease.Status)
+	}
+	if tip == "" || tip == base {
+		t.Fatalf("expected advanced tip, got %s", tip)
+	}
+	head := gitOk(t, repo, "rev-parse", "HEAD")
+	if head != tip {
+		t.Fatalf("control head %s want tip %s", head, tip)
+	}
+	a := mustRead(t, filepath.Join(repo, "src", "a.go"))
+	b := mustRead(t, filepath.Join(repo, "src", "b.go"))
+	if !strings.Contains(a, "func A") || !strings.Contains(b, "func B") {
+		t.Fatalf("integrated contents missing: a=%q b=%q", a, b)
+	}
+
+	if err := Cleanup(repo, slug, false); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(wtA); !os.IsNotExist(err) {
+		t.Fatalf("cleanup should remove workers")
+	}
+}
+
+func mustRead(t *testing.T, path string) string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(b)
+}

package/engine/internal/parallel/pathdisjoint.go

@@ -0,0 +1,129 @@
+// Package parallel implements deterministic parallel-worktree control ops:
+// path-disjoint checks, advisory leases, and git worktree create/integrate/cleanup.
+package parallel
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+var winAbsRE = regexp.MustCompile(`(?i)^[A-Za-z]:[/\\]`)
+
+// SlicePaths is one path-disjoint eligibility unit.
+type SlicePaths struct {
+	ID    string   `json:"id"`
+	Paths []string `json:"paths"`
+}
+
+// NormalizePath mirrors scripts/check-path-disjoint.py: slash-normalize, reject
+// empty/absolute/.. paths, and drop empty/"." segments.
+func NormalizePath(raw string) (string, error) {
+	path := strings.TrimSpace(strings.ReplaceAll(raw, `\`, "/"))
+	if path == "" {
+		return "", fmt.Errorf("empty path is not allowed")
+	}
+	if strings.HasPrefix(path, "/") || winAbsRE.MatchString(path) {
+		return "", fmt.Errorf("path must be project-relative, not absolute: %q", raw)
+	}
+	parts := make([]string, 0, strings.Count(path, "/")+1)
+	for part := range strings.SplitSeq(path, "/") {
+		if part == "" || part == "." {
+			continue
+		}
+		if part == ".." {
+			return "", fmt.Errorf("path must not contain '..': %q", raw)
+		}
+		parts = append(parts, part)
+	}
+	if len(parts) == 0 {
+		return "", fmt.Errorf("empty path is not allowed")
+	}
+	return strings.Join(parts, "/"), nil
+}
+
+func validateSlicePaths(paths []string, label, root string) ([]string, error) {
+	if paths == nil {
+		return nil, fmt.Errorf("%s: paths must be a list", label)
+	}
+	normalized := make([]string, 0, len(paths))
+	seen := make(map[string]struct{}, len(paths))
+	for _, raw := range paths {
+		path, err := NormalizePath(raw)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", label, err)
+		}
+		// Parallel eligibility must reject workspace control metadata so slices
+		// cannot claim control-tree / SSOT files (docs: ".devrites/**").
+		if path == ".devrites" || strings.HasPrefix(path, ".devrites/") {
+			return nil, fmt.Errorf("%s: path must not include .devrites: %q", label, path)
+		}
+		if _, ok := seen[path]; ok {
+			return nil, fmt.Errorf("%s: duplicate path %q", label, path)
+		}
+		seen[path] = struct{}{}
+		normalized = append(normalized, path)
+		if root != "" {
+			full := filepath.Join(root, filepath.FromSlash(path))
+			if info, err := os.Lstat(full); err == nil && info.Mode()&os.ModeSymlink != 0 {
+				return nil, fmt.Errorf("%s: symlink path is not allowed: %q", label, path)
+			}
+		}
+	}
+	return normalized, nil
+}
+
+// CheckPathDisjoint returns slice ids when every pair of path sets is disjoint.
+func CheckPathDisjoint(slices []SlicePaths, root string) ([]string, error) {
+	if len(slices) < 2 {
+		return nil, fmt.Errorf("need at least two slices to check path-disjoint eligibility")
+	}
+	owners := make(map[string][]string)
+	ids := make([]string, 0, len(slices))
+	for index, item := range slices {
+		label := fmt.Sprintf("slice %d", index)
+		if item.ID != "" {
+			label = fmt.Sprintf("slice %q", item.ID)
+			ids = append(ids, item.ID)
+		} else {
+			ids = append(ids, fmt.Sprintf("%d", index))
+		}
+		paths, err := validateSlicePaths(item.Paths, label, root)
+		if err != nil {
+			return nil, err
+		}
+		for _, path := range paths {
+			owners[path] = append(owners[path], label)
+		}
+	}
+	var overlaps []string
+	for path, labels := range owners {
+		if len(labels) > 1 {
+			overlaps = append(overlaps, fmt.Sprintf("%q shared by %s", path, strings.Join(labels, ", ")))
+		}
+	}
+	if len(overlaps) > 0 {
+		sort.Strings(overlaps)
+		return nil, fmt.Errorf("path sets overlap: %s", strings.Join(overlaps, "; "))
+	}
+	return ids, nil
+}
+
+// ParseSlicesJSON accepts {"slices":[...]} or a top-level slices array.
+func ParseSlicesJSON(data []byte) ([]SlicePaths, error) {
+	var asObject struct {
+		Slices []SlicePaths `json:"slices"`
+	}
+	if err := json.Unmarshal(data, &asObject); err == nil && asObject.Slices != nil {
+		return asObject.Slices, nil
+	}
+	var asList []SlicePaths
+	if err := json.Unmarshal(data, &asList); err == nil {
+		return asList, nil
+	}
+	return nil, fmt.Errorf(`input must be {"slices": [...]} or a top-level slices array`)
+}

package/engine/internal/parallel/pathdisjoint_test.go

@@ -0,0 +1,97 @@
+package parallel
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestNormalizePathRejectsDirty(t *testing.T) {
+	t.Parallel()
+	cases := []string{"", " ", "/", "/abs", `C:\windows`, `..`, "a/../b", "../x"}
+	for _, raw := range cases {
+		if _, err := NormalizePath(raw); err == nil {
+			t.Fatalf("NormalizePath(%q) should fail", raw)
+		}
+	}
+}
+
+func TestNormalizePathAcceptsRelative(t *testing.T) {
+	t.Parallel()
+	got, err := NormalizePath(`src\foo.go`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "src/foo.go" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestCheckPathDisjointOverlap(t *testing.T) {
+	t.Parallel()
+	_, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{"src/a.go"}},
+		{ID: "b", Paths: []string{"src/a.go"}},
+	}, "")
+	if err == nil || !strings.Contains(err.Error(), "overlap") {
+		t.Fatalf("expected overlap error, got %v", err)
+	}
+}
+
+func TestCheckPathDisjointOK(t *testing.T) {
+	t.Parallel()
+	ids, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{"src/a.go"}},
+		{ID: "b", Paths: []string{"src/b.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ids) != 2 {
+		t.Fatalf("ids=%v", ids)
+	}
+}
+
+func TestCheckPathDisjointRejectsDevritesPaths(t *testing.T) {
+	t.Parallel()
+	_, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{".devrites/work/state.md"}},
+		{ID: "b", Paths: []string{"src/b.go"}},
+	}, "")
+	if err == nil || !strings.Contains(err.Error(), ".devrites") {
+		t.Fatalf("expected .devrites rejection error, got %v", err)
+	}
+}
+
+func TestCheckPathDisjointSymlinkRoot(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	target := filepath.Join(dir, "real.go")
+	if err := os.WriteFile(target, []byte("x"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(dir, "link.go")
+	if err := os.Symlink(target, link); err != nil {
+		t.Skip("symlinks unavailable")
+	}
+	_, err := CheckPathDisjoint([]SlicePaths{
+		{ID: "a", Paths: []string{"link.go"}},
+		{ID: "b", Paths: []string{"other.go"}},
+	}, dir)
+	if err == nil || !strings.Contains(err.Error(), "symlink") {
+		t.Fatalf("expected symlink error, got %v", err)
+	}
+}
+
+func TestParseSlicesJSONShapes(t *testing.T) {
+	t.Parallel()
+	a, err := ParseSlicesJSON([]byte(`{"slices":[{"id":"a","paths":["x.go"]},{"id":"b","paths":["y.go"]}]}`))
+	if err != nil || len(a) != 2 {
+		t.Fatalf("object shape: %v %#v", err, a)
+	}
+	b, err := ParseSlicesJSON([]byte(`[{"id":"a","paths":["x.go"]},{"id":"b","paths":["y.go"]}]`))
+	if err != nil || len(b) != 2 {
+		t.Fatalf("array shape: %v %#v", err, b)
+	}
+}

package/engine/internal/state/cmd/workflowmanifest/main.go

@@ -1,5 +1,5 @@
 // Command workflowmanifest writes the deterministic cross-language derivative
-// of state.WorkflowPhases. The typed Go registry remains the authority.
+// of state.PhasePolicies. The typed Go registry remains the authority.
 package main
 
 import (
@@ -12,6 +12,35 @@ import (
 	"github.com/devrites/devrites/internal/state"
 )
 
+type workflowPhase struct {
+	ID                  state.Phase          `json:"id"`
+	ResumeVerb          string               `json:"resumeVerb,omitempty"`
+	TransitionRight     string               `json:"transitionRight"`
+	RequiredSections    []state.Section      `json:"requiredSections,omitempty"`
+	WorkspaceRequired   []state.ArtifactPath `json:"workspaceRequired"`
+	ProofRequired       bool                 `json:"proofRequired,omitempty"`
+	BlocksOpenQuestions bool                 `json:"blocksOpenQuestions,omitempty"`
+	Shippable           bool                 `json:"shippable,omitempty"`
+}
+
+func workflowPhases() []workflowPhase {
+	policies := state.PhasePolicies()
+	phases := make([]workflowPhase, len(policies))
+	for i, policy := range policies {
+		phases[i] = workflowPhase{
+			ID:                  policy.Target,
+			ResumeVerb:          policy.ResumeVerb,
+			TransitionRight:     policy.TransitionRight,
+			RequiredSections:    policy.RequiredSections,
+			WorkspaceRequired:   policy.RequiredArtifacts,
+			ProofRequired:       policy.ProofRequired,
+			BlocksOpenQuestions: policy.BlocksOpenQuestions,
+			Shippable:           policy.Shippable,
+		}
+	}
+	return phases
+}
+
 func main() {
 	outPath := flag.String("out", "workflow_manifest.json", "output path")
 	check := flag.Bool("check", false, "fail when the output is stale")
@@ -21,13 +50,13 @@ func main() {
 		GeneratedBy      string                 `json:"generatedBy"`
 		SchemaVersion    int                    `json:"schemaVersion"`
 		AuthorityPolicy  state.AuthorityPolicy  `json:"authorityPolicy"`
-		Phases           []state.WorkflowPhase  `json:"phases"`
+		Phases           []workflowPhase        `json:"phases"`
 		CursorKeyAliases []state.CursorKeyAlias `json:"cursorKeyAliases"`
 	}{
 		GeneratedBy:      "go generate ./internal/state; DO NOT EDIT",
 		SchemaVersion:    state.SchemaVersion,
 		AuthorityPolicy:  state.WorkflowAuthorityPolicy(),
-		Phases:           state.WorkflowPhases(),
+		Phases:           workflowPhases(),
 		CursorKeyAliases: state.CursorKeyAliases(),
 	}
 	data, err := json.MarshalIndent(document, "", "  ")

package/engine/internal/state/feature.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"github.com/devrites/devrites/internal/devritespaths"
-	"github.com/devrites/devrites/internal/markdowntext"
 	"github.com/devrites/devrites/internal/rootfacts"
 )
 
@@ -24,15 +23,6 @@ func ResolveRoot(override string) (string, error) {
 	return facts.PhysicalRoot, nil
 }
 
-// Feature is a loaded per-feature workspace: its declared phase plus which
-// completeness sections currently have real content.
-type Feature struct {
-	Slug         string
-	Phase        Phase
-	Present      map[Section]bool
-	PresentFiles map[string]bool
-}
-
 // featureDir is the canonical per-feature state directory under root.
 func featureDir(root, slug string) string {
 	return devritespaths.FeatureDir(root, slug)
@@ -71,74 +61,6 @@ func regularFileExists(path string) bool {
 	return err == nil && info.Mode().IsRegular()
 }
 
-// LoadFeature reads a canonical feature workspace. state.md is the sole
-// lifecycle authority; optional README.md metadata is not runtime state.
-func LoadFeature(root, slug string) (*Feature, error) {
-	dir := featureDir(root, slug)
-	if !regularFileExists(filepath.Join(dir, LedgerFile)) {
-		return nil, fmt.Errorf("feature %q not found", slug)
-	}
-
-	phase, ledgerDeclared, err := declaredPhaseFromLedger(filepath.Join(dir, LedgerFile))
-	if err != nil {
-		return nil, fmt.Errorf("feature %q: %w", slug, err)
-	}
-	if !ledgerDeclared {
-		return nil, fmt.Errorf("feature %q: no phase in %s ledger", slug, LedgerFile)
-	}
-	if !KnownPhase(phase) {
-		return nil, fmt.Errorf("feature %q: unknown phase %q", slug, phase)
-	}
-
-	present := make(map[Section]bool, len(Sections))
-	for _, section := range Sections {
-		present[section] = sectionPresentAny(dir, section)
-	}
-	presentFiles := make(map[string]bool)
-	for _, name := range WorkspaceFiles() {
-		presentFiles[name] = sectionPresent(filepath.Join(dir, name))
-	}
-	return &Feature{
-		Slug:         slug,
-		Phase:        phase,
-		Present:      present,
-		PresentFiles: presentFiles,
-	}, nil
-}
-
-func sectionPresentAny(dir string, s Section) bool {
-	for _, name := range sectionFiles[s] {
-		if sectionPresent(filepath.Join(dir, name)) {
-			return true
-		}
-	}
-	return false
-}
-
-func declaredPhaseFromLedger(path string) (Phase, bool, error) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return "", false, nil
-		}
-		return "", false, fmt.Errorf("read %s: %w", LedgerFile, err)
-	}
-	structural, err := markdowntext.Structural(raw)
-	if err != nil {
-		return "", false, fmt.Errorf("read %s: %w", LedgerFile, err)
-	}
-	lines := strings.Split(string(structural), "\n")
-	value, ok := CursorField(lines, CursorPhase)
-	if !ok {
-		return "", false, nil
-	}
-	word := firstPhaseWord(value)
-	if phase, known := PhaseForName(word); known {
-		return phase, true, nil
-	}
-	return Phase(word), true, nil
-}
-
 func firstPhaseWord(value string) string {
 	word := strings.ToLower(strings.TrimSpace(value))
 	if i := strings.IndexAny(word, " 	"); i > 0 {
@@ -153,27 +75,6 @@ func blankOrHash(trimmed string) bool {
 	return trimmed == "" || strings.HasPrefix(trimmed, "#")
 }
 
-// sectionPresent reports whether a section file has real content: it exists
-// and, after removing a leading YAML frontmatter block, ATX (`#`) headings, and
-// whitespace, some content remains. A stub that is only a heading counts as
-// empty, so scaffolding a file never fakes completeness.
-func sectionPresent(path string) bool {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return false
-	}
-	if _, err := markdowntext.Structural(raw); err != nil {
-		return false
-	}
-	body := stripFrontmatter(raw)
-	for _, line := range strings.Split(string(body), "\n") {
-		if !blankOrHash(strings.TrimSpace(line)) {
-			return true
-		}
-	}
-	return false
-}
-
 // stripFrontmatter removes a well-formed leading frontmatter block when
 // determining whether an artifact contains substantive body content. The
 // closing fence must be a line that is exactly `---`.
@@ -191,7 +92,7 @@ func stripFrontmatter(raw []byte) []byte {
 		}
 	}
 	if end < 0 {
-		return raw // no closing fence: treat as if there were no frontmatter
+		return raw
 	}
 	return []byte(strings.Join(lines[end+1:], "\n"))
 }