devrites 5.14.3 → 6.0.0

package/engine/internal/lib/detect.go

@@ -293,7 +293,7 @@ func manifestFallback(root string, slot string) (detectedCommand, bool) {
 		}
 		cmd, ok := m.cmds[slot]
 		if !ok {
-			return detectedCommand{}, false
+			continue
 		}
 		out := detectedCommand{Name: slot, Command: cmd, Source: m.source}
 		binary := strings.Fields(cmd)[0]

package/engine/internal/lib/detect_test.go

@@ -68,6 +68,19 @@ func TestDetectManifestFallbackAndJSON(t *testing.T) {
 	}
 }
 
+func TestDetectManifestFallbackSkipsManifestWithoutSlot(t *testing.T) {
+	root := t.TempDir()
+	writeFile(t, root+"/setup.py", "from setuptools import setup\nsetup()\n")
+	writeFile(t, root+"/build.gradle", "plugins { id 'java' }\n")
+	code, out := runDetect(t, root)
+	if code != 0 {
+		t.Fatalf("code=%d out=%s", code, out)
+	}
+	if !strings.Contains(out, "gradle build") || !strings.Contains(out, "build.gradle") {
+		t.Fatalf("build slot should resolve from build.gradle:\n%s", out)
+	}
+}
+
 func TestDetectEmptyRepoReportsUnresolved(t *testing.T) {
 	root := t.TempDir()
 	code, out := runDetect(t, root)

package/engine/internal/lib/diffscope.go

@@ -153,25 +153,35 @@ func (o diffScopeOpts) changedPaths() ([]string, error) {
 }
 
 // gitStatusPaths lists every path the writer touched: tracked modifications,
-// staged entries, renames (new name), and untracked files.
+// staged entries, renames (new name, then the old name it replaced), and
+// untracked files.
 func gitStatusPaths(dir string) ([]string, error) {
-	out, err := runGitCommand(dir, nil, "status", "--porcelain", "-uall")
+	out, err := runGitCommand(dir, nil, "status", "--porcelain", "-uall", "-z")
 	if err != nil {
 		return nil, err
 	}
 	var paths []string
-	for _, line := range splitLinesNoTrailing(out) {
-		if len(line) < 4 {
+	// -z emits one NUL-terminated record per entry with paths unquoted; a
+	// rename or copy carries a second record, new name first, then the old.
+	records := strings.Split(string(out), "\x00")
+	for i := 0; i < len(records); i++ {
+		record := records[i]
+		if len(record) < 4 {
 			continue
 		}
-		path := strings.TrimSpace(line[3:])
-		if idx := strings.LastIndex(path, " -> "); idx >= 0 {
-			path = path[idx+4:]
+		path := record[3:]
+		if path == "" {
+			continue
 		}
-		path = strings.Trim(path, `"`)
-		if path != "" {
+		if strings.ContainsAny(record[:2], "RC") {
 			paths = append(paths, path)
+			if i+1 < len(records) && records[i+1] != "" {
+				i++
+				paths = append(paths, records[i])
+			}
+			continue
 		}
+		paths = append(paths, path)
 	}
 	return paths, nil
 }

package/engine/internal/lib/dispatch.go

@@ -262,13 +262,20 @@ func dispatchLocked(root, slug, sub, phase, wave, role, handle, reason string, r
 
 	case "status":
 		if wave == "" {
+			var incomplete []string
 			for _, name := range sortedKeys(f.Waves) {
 				w := f.Waves[name]
 				fmt.Fprintf(stdout, "dispatch: wave %s state=%s roles=%d\n", name, w.State, len(w.Roles))
+				if w.State != "complete" {
+					incomplete = append(incomplete, name)
+				}
 			}
 			if len(f.Waves) == 0 {
 				fmt.Fprintln(stdout, "dispatch: no waves")
 			}
+			if len(incomplete) > 0 {
+				return fail("waves not complete: %s", strings.Join(incomplete, ","))
+			}
 			return 0
 		}
 		w := getWave()

package/engine/internal/lib/dup.go

@@ -59,7 +59,6 @@ const (
 	dupMaxPostings     = 32
 	dupMaxPairAnchors  = 8192
 	dupMergeGap        = 4
-	dupMaxClusters     = 200
 	dupHashLength      = 12
 	dupCrossDirMaxHops = 8
 	dupCrossDirBoost   = 0.15
@@ -440,6 +439,18 @@ func dupDistanceBoost(pathA, pathB string, seg dupSegment) float64 {
 // dupClusterUnits merges per-file ranges into units, unions segments into
 // transitive clusters, and orders clusters by their strongest boosted pair.
 func dupClusterUnits(segs []dupSegment, files []dupFile) ([]dupCluster, []dupUnit, []dupEdge) {
+	return dupClusterUnitsCounted(segs, files, nil)
+}
+
+// dupClusterUnitsCounted is dupClusterUnits with an optional counter of the
+// units and edges it examines, so tests can assert on work done instead of
+// wall time.
+func dupClusterUnitsCounted(segs []dupSegment, files []dupFile, steps *int) ([]dupCluster, []dupUnit, []dupEdge) {
+	step := func() {
+		if steps != nil {
+			*steps++
+		}
+	}
 	// Merge each file's overlapping/adjacent ranges into units.
 	perFile := map[int][]dupUnit{}
 	for _, s := range segs {
@@ -465,15 +476,22 @@ func dupClusterUnits(segs []dupSegment, files []dupFile) ([]dupCluster, []dupUni
 		}
 	}
 	// Locate the unit covering a segment endpoint: same file, maximal overlap.
+	// Each file's units are already sorted by start, so only the units that
+	// reach the range are visited.
+	byFile := map[int][]int{}
+	for i, u := range units {
+		byFile[u.file] = append(byFile[u.file], i)
+	}
 	unitIndex := func(file, start, end int) int {
+		idxs := byFile[file]
 		best, bestOverlap := -1, 0
-		for i, u := range units {
-			if u.file != file {
-				continue
-			}
+		k := sort.Search(len(idxs), func(k int) bool { return units[idxs[k]].end >= start })
+		for ; k < len(idxs) && units[idxs[k]].start <= end; k++ {
+			step()
+			u := units[idxs[k]]
 			ov := min(u.end, end) - max(u.start, start) + 1
 			if ov > bestOverlap {
-				best, bestOverlap = i, ov
+				best, bestOverlap = idxs[k], ov
 			}
 		}
 		return best
@@ -503,19 +521,25 @@ func dupClusterUnits(segs []dupSegment, files []dupFile) ([]dupCluster, []dupUni
 		}
 	}
 	groups := map[int][]int{}
+	seen := map[int]bool{}
+	best := map[int]float64{}
 	for _, e := range edges {
+		step()
 		r := find(e.a)
-		if !containsInt(groups[r], e.a) {
-			groups[r] = append(groups[r], e.a)
+		for _, u := range [2]int{e.a, e.b} {
+			if !seen[u] {
+				seen[u] = true
+				groups[r] = append(groups[r], u)
+			}
 		}
-		if !containsInt(groups[r], e.b) {
-			groups[r] = append(groups[r], e.b)
+		if e.boosted > best[r] {
+			best[r] = e.boosted
 		}
 	}
 	var clusters []dupCluster
-	for _, members := range groups {
+	for r, members := range groups {
 		sort.Ints(members)
-		c := dupCluster{units: members}
+		c := dupCluster{units: members, score: best[r]}
 		var sb strings.Builder
 		var hashes []string
 		for _, u := range members {
@@ -530,19 +554,6 @@ func dupClusterUnits(segs []dupSegment, files []dupFile) ([]dupCluster, []dupUni
 		c.hash = hex.EncodeToString(sum[:])[:dupHashLength]
 		clusters = append(clusters, c)
 	}
-	for i := range clusters {
-		best := 0.0
-		member := map[int]bool{}
-		for _, u := range clusters[i].units {
-			member[u] = true
-		}
-		for _, e := range edges {
-			if member[e.a] && member[e.b] && e.boosted > best {
-				best = e.boosted
-			}
-		}
-		clusters[i].score = best
-	}
 	sort.Slice(clusters, func(i, j int) bool {
 		if clusters[i].score != clusters[j].score {
 			return clusters[i].score > clusters[j].score
@@ -583,15 +594,6 @@ func dupHeaderLine(tokens string) bool {
 	return false
 }
 
-func containsInt(xs []int, v int) bool {
-	for _, x := range xs {
-		if x == v {
-			return true
-		}
-	}
-	return false
-}
-
 // dupChangedRanges parses `git diff -U0` output into per-file added-line
 // ranges on the new side. Deleted files contribute nothing.
 func dupChangedRanges(diff string) map[string][][2]int {
@@ -961,11 +963,12 @@ func RunCheckDup(root string, args []string, stdout, stderr io.Writer) int {
 			fmt.Fprintln(stdout, "dup: ok (no similar regions)")
 		}
 		if opts.slug != "" {
-			recordMetric(root, opts.slug, opts.phase, "dup", "", int64(len(clusters)))
+			recordMetric(root, opts.slug, opts.phase, "dup", "", 0)
 		}
 		return 0
 	}
-	fmt.Fprintf(stdout, "dup: %d cluster(s)", len(shown))
+	shownCount := len(shown)
+	fmt.Fprintf(stdout, "dup: %d cluster(s)", shownCount)
 	if ignoredCount > 0 {
 		fmt.Fprintf(stdout, " (%d ignored)", ignoredCount)
 	}
@@ -1000,7 +1003,7 @@ func RunCheckDup(root string, args []string, stdout, stderr io.Writer) int {
 		return 2
 	}
 	if opts.slug != "" {
-		recordMetric(root, opts.slug, opts.phase, "dup", "", int64(len(shown)))
+		recordMetric(root, opts.slug, opts.phase, "dup", "", int64(shownCount))
 	}
 	return 0
 }

package/engine/internal/lib/dup_test.go

@@ -2,9 +2,11 @@ package lib
 
 import (
 	"bytes"
+	"encoding/json"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"testing"
 
@@ -486,3 +488,179 @@ func TestDupStagedQuotedPathAndDiffConfig(t *testing.T) {
 		t.Fatalf("code=%d out=%s err=%s", code, &out, &errOut)
 	}
 }
+
+const dupBlockC = `func loadSettings(path string) (map[string]string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read: %w", err)
+	}
+	out := map[string]string{}
+	for _, line := range strings.Split(string(data), "\n") {
+		k, v, ok := strings.Cut(line, "=")
+		if !ok {
+			continue
+		}
+		out[strings.TrimSpace(k)] = strings.TrimSpace(v)
+	}
+	return out, nil
+}
+`
+
+const dupBlockD = `func readProfile(file string) (map[string]string, error) {
+	raw, err := os.ReadFile(file)
+	if err != nil {
+		return nil, fmt.Errorf("open: %w", err)
+	}
+	res := map[string]string{}
+	for _, row := range strings.Split(string(raw), "\n") {
+		name, val, found := strings.Cut(row, "=")
+		if !found {
+			continue
+		}
+		res[strings.TrimSpace(name)] = strings.TrimSpace(val)
+	}
+	return res, nil
+}
+`
+
+func dupMetricBytes(t *testing.T, root, slug string) []int64 {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(root, "work", slug, MetricsFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got []int64
+	for _, line := range strings.Split(strings.TrimSpace(string(data)), "\n") {
+		var ev metricEvent
+		if err := json.Unmarshal([]byte(line), &ev); err != nil {
+			t.Fatal(err)
+		}
+		got = append(got, ev.Bytes)
+	}
+	return got
+}
+
+func TestRunCheckDupMetricIgnoresLimitAndCountsOnlyShown(t *testing.T) {
+	project := t.TempDir()
+	initDupRepo(t, project)
+	testutil.WriteFile(t, filepath.Join(project, "a/one.go"), "package a\n\n"+dupBlockA)
+	testutil.WriteFile(t, filepath.Join(project, "c/three.go"), "package c\n\n"+dupBlockC)
+	testutil.WriteFile(t, filepath.Join(project, "b/two.go"), "package b\n\n"+dupBlockB)
+	testutil.WriteFile(t, filepath.Join(project, "d/four.go"), "package d\n\n"+dupBlockD)
+	runDupGit(t, project, "add", ".")
+	runDupGit(t, project, "commit", "-qm", "base")
+	root := filepath.Join(project, ".devrites")
+	if err := os.MkdirAll(filepath.Join(root, "work", "demo"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	var hashes []string
+	for _, limit := range []string{"1", "50"} {
+		var stdout, stderr bytes.Buffer
+		args := []string{"demo", "--all", "--min-lines", "5", "--limit", limit}
+		if code := RunCheckDup(root, args, &stdout, &stderr); code != 0 {
+			t.Fatalf("limit=%s code=%d stderr=%s", limit, code, stderr.String())
+		}
+		if limit == "50" {
+			for _, m := range regexp.MustCompile(`cluster \d+ \(([0-9a-f]+)\)`).FindAllStringSubmatch(stdout.String(), -1) {
+				hashes = append(hashes, m[1])
+			}
+		}
+	}
+	if len(hashes) != 2 {
+		t.Fatalf("want 2 clusters, got %v", hashes)
+	}
+	got := dupMetricBytes(t, root, "demo")
+	if len(got) != 2 || got[0] != got[1] {
+		t.Fatalf("metric depends on --limit: %v", got)
+	}
+
+	testutil.WriteFile(t, filepath.Join(root, "dup-ignore"), hashes[0]+"\n")
+	var stdout, stderr bytes.Buffer
+	if code := RunCheckDup(root, []string{"demo", "--all", "--min-lines", "5"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	oneIgnored := dupMetricBytes(t, root, "demo")[2]
+
+	testutil.WriteFile(t, filepath.Join(root, "dup-ignore"), hashes[0]+"\n"+hashes[1]+"\n")
+	stdout.Reset()
+	if code := RunCheckDup(root, []string{"demo", "--all", "--min-lines", "5"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	if allIgnored := dupMetricBytes(t, root, "demo")[3]; allIgnored > oneIgnored {
+		t.Fatalf("metric rose when findings were dismissed: %d -> %d", oneIgnored, allIgnored)
+	}
+}
+
+// dupGroupedInput builds nFiles files of 10 units each (lines 10u..10u+4)
+// where every unit position is linked across consecutive files of each group.
+func dupGroupedInput(nFiles, group int) ([]dupSegment, []dupFile) {
+	files := make([]dupFile, nFiles)
+	for i := range files {
+		files[i] = dupFile{path: "pkg" + string(rune('a'+i%26)) + "/f" + string(rune('a'+i/26%26)) + string(rune('a'+i/676)) + ".go", lines: make([]dupLine, 100)}
+	}
+	var segs []dupSegment
+	for base := 0; base+group <= nFiles; base += group {
+		for u := 0; u < 10; u++ {
+			for k := 0; k+1 < group; k++ {
+				segs = append(segs, dupSegment{
+					aFile: base + k, bFile: base + k + 1,
+					aStart: u * 10, aEnd: u*10 + 4, bStart: u * 10, bEnd: u*10 + 4,
+					boosted: float64((base+k+u)%7+1) / 10,
+				})
+			}
+		}
+	}
+	return segs, files
+}
+
+func TestDupClusterUnitsSmallCase(t *testing.T) {
+	files := []dupFile{
+		{path: "a/x.go", lines: make([]dupLine, 40)},
+		{path: "b/y.go", lines: make([]dupLine, 40)},
+		{path: "c/z.go", lines: make([]dupLine, 40)},
+	}
+	segs := []dupSegment{
+		{aFile: 0, bFile: 1, aStart: 0, aEnd: 4, bStart: 0, bEnd: 4, boosted: 0.5},
+		{aFile: 1, bFile: 2, aStart: 0, aEnd: 4, bStart: 0, bEnd: 4, boosted: 0.9},
+		{aFile: 0, bFile: 1, aStart: 20, aEnd: 24, bStart: 20, bEnd: 24, boosted: 0.3},
+	}
+	clusters, units, edges := dupClusterUnits(segs, files)
+	if len(units) != 5 || len(edges) != 3 || len(clusters) != 2 {
+		t.Fatalf("units=%d edges=%d clusters=%d", len(units), len(edges), len(clusters))
+	}
+	if len(clusters[0].units) != 3 || clusters[0].score != 0.9 {
+		t.Fatalf("first cluster = %d units score %v", len(clusters[0].units), clusters[0].score)
+	}
+	if len(clusters[1].units) != 2 || clusters[1].score != 0.3 {
+		t.Fatalf("second cluster = %d units score %v", len(clusters[1].units), clusters[1].score)
+	}
+	if clusters[0].hash == clusters[1].hash || len(clusters[0].hash) != dupHashLength {
+		t.Fatalf("hashes %q %q", clusters[0].hash, clusters[1].hash)
+	}
+}
+
+func TestDupClusterUnitsWorkIsLinear(t *testing.T) {
+	segs, files := dupGroupedInput(1600, 20)
+	var steps int
+	clusters, units, _ := dupClusterUnitsCounted(segs, files, &steps)
+	if len(clusters) != 80*10 {
+		t.Fatalf("clusters=%d, want 800", len(clusters))
+	}
+	for _, c := range clusters {
+		if len(c.units) != 20 {
+			t.Fatalf("cluster has %d units, want 20", len(c.units))
+		}
+	}
+	// Every unit sits alone in a 10-line slot, so each of the two endpoints of
+	// a segment overlaps exactly one unit, and the scoring pass visits each
+	// edge once. A path that scans all units or all edges per cluster does
+	// more work, and one that skips the counter does none.
+	groups, perGroup, unitsPerFile := 1600/20, 20, 10
+	if want := groups * unitsPerFile * (perGroup - 1); len(segs) != want {
+		t.Fatalf("fixture has %d segments, want %d", len(segs), want)
+	}
+	if want := 3 * len(segs); steps != want {
+		t.Fatalf("examined %d units/edges for %d segments and %d units, want exactly %d", steps, len(segs), len(units), want)
+	}
+}

package/engine/internal/lib/manifest_union.go

@@ -171,7 +171,7 @@ func walkSequenceChain(root, slug, workspace string) ([]string, [][]candidateRow
 	chain := []string{}
 	manifests := [][]candidateRow{}
 	dir := workspace
-	for len(chain) < maxSequenceChain {
+	for {
 		raw, err := readBoundedRegularFile(filepath.Join(dir, "state.md"), maxCandidateManifestBytes)
 		if err != nil {
 			return nil, nil, fmt.Errorf("%s state.md: %w", filepath.Base(dir), err)
@@ -180,6 +180,9 @@ func walkSequenceChain(root, slug, workspace string) ([]string, [][]candidateRow
 		if parent == "" {
 			break
 		}
+		if len(chain) == maxSequenceChain {
+			return nil, nil, fmt.Errorf("sequence chain longer than %d; pass an explicit ordered predecessor list", maxSequenceChain)
+		}
 		if _, dup := visited[parent]; dup {
 			return nil, nil, fmt.Errorf("sequence_parent cycle at %q", parent)
 		}

package/engine/internal/lib/manifest_union_test.go

@@ -2,6 +2,7 @@ package lib
 
 import (
 	"bytes"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -212,3 +213,39 @@ func TestMergeManifestRejectsParentMismatchAndMissingPredecessor(t *testing.T) {
 		t.Fatalf("missing args: code=%d", code)
 	}
 }
+
+func TestSequenceChainBeyondBoundRefusesInsteadOfTruncating(t *testing.T) {
+	root := unionRoot(t)
+	n := maxSequenceChain + 6
+	for i := 0; i < n; i++ {
+		slug := fmt.Sprintf("feat-%03d", i)
+		unionWorkspace(t, root, slug, manifestBody(fmt.Sprintf("| present | `src/f%03d.ts` | SLICE-001 | Added. |", i)), false)
+	}
+	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
+	link := func(slug, parent string) {
+		statePath := filepath.Join(root, "work", slug, "state.md")
+		raw, _ := os.ReadFile(statePath)
+		raw = append(raw, []byte("| sequence_parent | "+parent+" |\n")...)
+		if err := os.WriteFile(statePath, raw, 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for i := 1; i < n; i++ {
+		link(fmt.Sprintf("feat-%03d", i), fmt.Sprintf("feat-%03d", i-1))
+	}
+	link("release", fmt.Sprintf("feat-%03d", n-1))
+	statePath := filepath.Join(root, "work", "release", "state.md")
+	raw, _ := os.ReadFile(statePath)
+	raw = append(raw, []byte("| sequence_role | release |\n")...)
+	if err := os.WriteFile(statePath, raw, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	var stdout, stderr bytes.Buffer
+	if code := RunMergeManifest(root, []string{"release"}, &stdout, &stderr); code == 0 {
+		t.Fatalf("merge over an over-long chain succeeded: stdout=%s", stdout.String())
+	}
+	if err := VerifyReleaseUnion(root, "release"); err == nil {
+		t.Fatal("release union passed over an over-long chain")
+	}
+}

package/engine/internal/lib/metrics.go

@@ -216,6 +216,10 @@ func metricsSummary(root string, args []string, stdout, stderr io.Writer) int {
 		totalEvents++
 		totalBytes += ev.Bytes
 	}
+	if err := scanner.Err(); err != nil {
+		fmt.Fprintf(stderr, "metrics: ledger unreadable after %d events: %v\n", totalEvents, err)
+		return 2
+	}
 	if len(phases) == 0 && bad == 0 {
 		fmt.Fprintf(stdout, "metrics: no events recorded for %s\n", slug)
 		return 0

package/engine/internal/lib/metrics_test.go

@@ -0,0 +1,28 @@
+package lib
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestMetricsSummaryFailsOnOversizedLine(t *testing.T) {
+	root, featureDir := newWorkspace(t, "build")
+	ev := func(e string) string {
+		return `{"ts":"2026-01-01T00:00:00Z","phase":"build","event":"` + e + `"}` + "\n"
+	}
+	ledger := ev("a") + strings.Repeat("x", 1<<20) + "\n" + ev("b") + ev("c")
+	if err := os.WriteFile(filepath.Join(featureDir, MetricsFile), []byte(ledger), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	code := RunMetrics(root, []string{"summary", "feat"}, stdout, stderr)
+	if code == 0 {
+		t.Fatalf("truncated ledger reported as complete:\n%s", stdout)
+	}
+	if !strings.Contains(stderr.String(), "ledger unreadable after 1 events") {
+		t.Fatalf("stderr missing truncation report: %q", stderr)
+	}
+}

package/engine/internal/lib/migrate_test.go

@@ -152,3 +152,62 @@ func TestMigrateCurrentAndNewerSchemaAreRefused(t *testing.T) {
 		t.Fatalf("newer schema: code=%d stderr=%q", code, stderr.String())
 	}
 }
+
+// End to end through the `migrate` command path. migrate.go
+// calls state.ConvertCursorToTable (apply, unconditional) and state.CursorForm
+// (plan), so a fenced example in state.md — the phase-authority ledger — must
+// survive a migration byte for byte, and a migration plan must not advertise a
+// conversion that only fenced content would have performed.
+
+func seedLedger(t *testing.T, body string) (root, workspace string) {
+	t.Helper()
+	root = t.TempDir()
+	workspace = filepath.Join(root, "work", "feature")
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return root, workspace
+}
+
+const ledgerBody = "# State\n\n## Recovery note\n\nThe pre-v5 ledger looked like this:\n\n~~~md\n- Phase: build\n- Status: running\n~~~\n\n## Cursor\n\n- Phase: build\n- Status: running\n"
+
+func TestMigrateLeavesFencedCursorExamplesByteIdentical(t *testing.T) {
+	root, workspace := seedLedger(t, ledgerBody)
+	var stdout, stderr strings.Builder
+	if code := Migrate(root, []string{"feature"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
+	}
+	body, err := os.ReadFile(filepath.Join(workspace, "state.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(body)
+	if got := strings.Count(text, "- Phase: build"); got != 1 {
+		t.Fatalf("fenced example rewritten: %d surviving \"- Phase: build\" lines in\n%s", got, text)
+	}
+	if !strings.Contains(text, "| phase | build |") {
+		t.Fatalf("live cursor bullet not converted to the canonical table row:\n%s", text)
+	}
+	fenced := "~~~md\n- Phase: build\n- Status: running\n~~~"
+	if !strings.Contains(text, fenced) {
+		t.Fatalf("fenced block not preserved byte for byte:\n%s", text)
+	}
+}
+
+func TestMigratePlanDoesNotOfferConversionForFencedCursorsOnly(t *testing.T) {
+	body := "# State\n\n## Recovery note\n\n~~~md\n- Phase: build\n- Status: running\n~~~\n"
+	root, _ := seedLedger(t, body)
+	var stdout, stderr strings.Builder
+	if code := Migrate(root, []string{"feature", "--dry-run", "--answer", "phase=build"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
+	}
+	if strings.Contains(stdout.String(), "[cursor]") {
+		t.Fatalf("plan offers a cursor conversion for a ledger whose only legacy bullets are fenced:\n%s", stdout.String())
+	}
+	if !strings.Contains(stdout.String(), "[schema] record schema") {
+		t.Fatalf("plan incomplete:\n%s", stdout.String())
+	}
+}

package/engine/internal/lib/observe_budgets.go

@@ -28,33 +28,48 @@ type BulkFile struct {
 }
 
 // observeArtifactBudgets lists canonical artifacts present in the workspace root with
-// their budget status, plus non-canonical files large enough to hurt a reader.
-func observeArtifactBudgets(workspace string) ([]ArtifactBudget, []BulkFile, error) {
+// their budget status, plus non-canonical files large enough to hurt a reader. The
+// third return names every entry it could not read: one unreadable artifact must not
+// hide the budgets of every other artifact.
+func observeArtifactBudgets(workspace string) ([]ArtifactBudget, []BulkFile, []string, error) {
 	entries, err := os.ReadDir(workspace)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	var budgets []ArtifactBudget
 	var bulk []BulkFile
+	var unreadable []string
 	for _, entry := range entries {
 		if !entry.Type().IsRegular() {
 			continue
 		}
+		name := entry.Name()
 		info, err := entry.Info()
 		if err != nil {
-			return nil, nil, err
+			unreadable = append(unreadable, name)
+			continue
 		}
-		name := entry.Name()
 		if _, canonical := state.ArtifactLineBudget(name); !canonical {
 			if info.Size() > bulkFileThreshold {
 				bulk = append(bulk, BulkFile{File: name, Bytes: info.Size()})
 			}
 			continue
 		}
-		// #nosec G304 -- canonical workspace artifact name from a fixed table
-		raw, err := os.ReadFile(filepath.Join(workspace, name))
+		if info.Size() > maxCandidateArtifactBytes {
+			measured, _ := state.ArtifactBudget(name, nil)
+			budgets = append(budgets, ArtifactBudget{
+				File:       name,
+				Bytes:      info.Size(),
+				LineBudget: measured.LineBudget,
+				ByteBudget: measured.ByteBudget,
+				Over:       true,
+			})
+			continue
+		}
+		raw, err := readBoundedRegularFile(filepath.Join(workspace, name), maxCandidateArtifactBytes)
 		if err != nil {
-			return nil, nil, err
+			unreadable = append(unreadable, name)
+			continue
 		}
 		measured, _ := state.ArtifactBudget(name, raw)
 		budgets = append(budgets, ArtifactBudget{
@@ -69,5 +84,6 @@ func observeArtifactBudgets(workspace string) ([]ArtifactBudget, []BulkFile, err
 	}
 	sort.Slice(budgets, func(i, j int) bool { return budgets[i].File < budgets[j].File })
 	sort.Slice(bulk, func(i, j int) bool { return bulk[i].File < bulk[j].File })
-	return budgets, bulk, nil
+	sort.Strings(unreadable)
+	return budgets, bulk, unreadable, nil
 }