devrites 5.3.0 → 5.5.0

package/engine/internal/lib/manifest_union.go

@@ -0,0 +1,326 @@
+package lib
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/state"
+)
+
+// maxSequenceChain bounds the sequence_parent walk so a malformed cycle cannot
+// loop forever; real chains are far smaller.
+const maxSequenceChain = 64
+
+// RunMergeManifest folds predecessor candidate manifests into the release
+// workspace's `## Candidate manifest` so a release milestone's prove/review/seal
+// binds the union surface instead of only its own slices. On a path collision
+// the later sequence position's row wins (it records the most recent touch).
+// Everything outside the manifest section of the release workspace's
+// touched-files.md is preserved.
+//
+// args is `<slug>` to walk the recorded `sequence_parent` chain, or
+// `<slug> <predecessor> [<predecessor>...]` for an explicit ordered list —
+// required for chains recorded before the sequence cursor fields existed.
+// Exit codes:
+//
+//	0  merged and written
+//	2  usage error
+//	3  blocked: a workspace, manifest, or chain check failed
+//	1  internal/IO error
+func RunMergeManifest(root string, args []string, stdout, stderr io.Writer) int {
+	if len(args) < 1 {
+		fmt.Fprintln(stderr, "usage: devrites-engine state merge-manifest <slug> [<predecessor>...]")
+		return 2
+	}
+	slug := args[0]
+	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: workspace for %s: %v\n", slug, err)
+		return 3
+	}
+	if err := state.RequireWorkspaceSchema(root, slug); err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: %v\n", err)
+		return 3
+	}
+	manifestPath := filepath.Join(workspace, "touched-files.md")
+	releaseRaw, err := readBoundedRegularFile(manifestPath, maxCandidateManifestBytes)
+	if err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: candidate manifest %s: %v\n", manifestPath, err)
+		return 3
+	}
+
+	var manifests [][]candidateRow
+	if len(args) > 1 {
+		manifests, err = explicitManifests(root, slug, args[1:])
+	} else {
+		// The walked chain is validated inside walkSequenceChain; only its
+		// manifests feed the union.
+		_, manifests, err = walkSequenceChain(root, slug, workspace)
+	}
+	if err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: %v\n", err)
+		return 3
+	}
+
+	merged := make(map[string]candidateRow)
+	collisions := 0
+	fold := func(rows []candidateRow) {
+		for _, row := range rows {
+			if _, dup := merged[row.path]; dup {
+				collisions++
+			}
+			merged[row.path] = row
+		}
+	}
+	for _, rows := range manifests {
+		fold(rows)
+	}
+	releaseRows, err := parseCandidateManifest(releaseRaw)
+	if err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: candidate manifest %s: %v\n", manifestPath, err)
+		return 3
+	}
+	fold(releaseRows)
+
+	paths := make([]string, 0, len(merged))
+	for path := range merged {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+	body := make([]string, 0, len(paths)+2)
+	if len(paths) == 0 {
+		body = append(body, "No project files.")
+	} else {
+		body = append(body, "| State | File | Slice | Reason |", "| --- | --- | --- | --- |")
+		for _, path := range paths {
+			row := merged[path]
+			body = append(body, fmt.Sprintf("| %s | `%s` | %s | %s |", row.state, row.path, row.slice, row.reason))
+		}
+	}
+	updated, err := replaceManifestSectionBody(releaseRaw, body)
+	if err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: BLOCKED: candidate manifest %s: %v\n", manifestPath, err)
+		return 3
+	}
+	if err := state.AtomicWrite(manifestPath, updated, 0o644); err != nil {
+		fmt.Fprintf(stderr, "merge-manifest: cannot write %s: %v\n", manifestPath, err)
+		return 1
+	}
+	fmt.Fprintf(stdout, "merge-manifest: merged %d manifest(s) into %d row(s)", len(manifests)+1, len(paths))
+	if collisions > 0 {
+		fmt.Fprintf(stdout, " (%d path collision(s), later position kept)", collisions)
+	}
+	fmt.Fprintln(stdout)
+	return 0
+}
+
+// explicitManifests parses the caller-ordered predecessor list. When the
+// workspace carries a sequence_parent cursor, the last predecessor must be the
+// recorded parent; a mismatch means the list does not describe this chain.
+func explicitManifests(root, slug string, predecessors []string) ([][]candidateRow, error) {
+	seen := make(map[string]struct{}, len(predecessors))
+	for _, pred := range predecessors {
+		if pred == slug {
+			return nil, fmt.Errorf("predecessor %q names the target workspace", pred)
+		}
+		if _, dup := seen[pred]; dup {
+			return nil, fmt.Errorf("duplicate predecessor %q", pred)
+		}
+		seen[pred] = struct{}{}
+	}
+	if parent := sequenceParent(root, slug); parent != "" && parent != predecessors[len(predecessors)-1] {
+		return nil, fmt.Errorf("%s records sequence_parent %q; pass the full ordered predecessor list ending with it (or no list to walk the recorded chain)", slug, parent)
+	}
+	manifests := make([][]candidateRow, 0, len(predecessors))
+	for _, pred := range predecessors {
+		rows, err := predecessorManifestRows(root, pred)
+		if err != nil {
+			return nil, fmt.Errorf("predecessor %s: %w", pred, err)
+		}
+		manifests = append(manifests, rows)
+	}
+	return manifests, nil
+}
+
+// walkSequenceChain follows the target workspace's sequence_parent links to the
+// chain head, returning predecessors oldest-first with their manifests. Every
+// link must resolve to a live or archived workspace carrying the cursor field;
+// a broken link refuses the merge rather than producing a partial union.
+func walkSequenceChain(root, slug, workspace string) ([]string, [][]candidateRow, error) {
+	visited := map[string]struct{}{slug: {}}
+	chain := []string{}
+	manifests := [][]candidateRow{}
+	dir := workspace
+	for len(chain) < maxSequenceChain {
+		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)
+		}
+		parent, _ := state.CursorField(strings.Split(string(raw), "\n"), state.CursorSequenceParent)
+		if parent == "" {
+			break
+		}
+		if _, dup := visited[parent]; dup {
+			return nil, nil, fmt.Errorf("sequence_parent cycle at %q", parent)
+		}
+		visited[parent] = struct{}{}
+		rows, err := predecessorManifestRows(root, parent)
+		if err != nil {
+			return nil, nil, fmt.Errorf("sequence_parent %s: %w", parent, err)
+		}
+		dir, err = devritespaths.ExistingFeatureDirChecked(root, parent)
+		if errors.Is(err, os.ErrNotExist) {
+			dir, err = devritespaths.ExistingArchivedFeatureDirChecked(root, parent)
+		}
+		if err != nil {
+			return nil, nil, fmt.Errorf("sequence_parent %s: %w", parent, err)
+		}
+		chain = append(chain, parent)
+		manifests = append(manifests, rows)
+	}
+	if len(chain) == 0 {
+		return nil, nil, fmt.Errorf("%s has no sequence_parent; pass an explicit ordered predecessor list", slug)
+	}
+	for i, j := 0, len(chain)-1; i < j; i, j = i+1, j-1 {
+		chain[i], chain[j] = chain[j], chain[i]
+		manifests[i], manifests[j] = manifests[j], manifests[i]
+	}
+	return chain, manifests, nil
+}
+
+func sequenceParent(root, slug string) string {
+	dir, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return ""
+	}
+	raw, err := readBoundedRegularFile(filepath.Join(dir, "state.md"), maxCandidateManifestBytes)
+	if err != nil {
+		return ""
+	}
+	parent, _ := state.CursorField(strings.Split(string(raw), "\n"), state.CursorSequenceParent)
+	return parent
+}
+
+// VerifyReleaseUnion enforces the release-milestone contract at the candidate
+// and seal gates: a workspace whose cursor declares `sequence_role: release`
+// must carry a candidate manifest covering every predecessor in its recorded
+// `sequence_parent` chain. Workspaces without the role are unaffected.
+func VerifyReleaseUnion(root, slug string) error {
+	dir, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if err != nil {
+		return fmt.Errorf("workspace for %s: %w", slug, err)
+	}
+	raw, err := readBoundedRegularFile(filepath.Join(dir, "state.md"), maxCandidateManifestBytes)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil // no state.md: nothing declares the release role
+	}
+	if err != nil {
+		return fmt.Errorf("%s state.md: %w", slug, err)
+	}
+	role, _ := state.CursorField(strings.Split(string(raw), "\n"), state.CursorSequenceRole)
+	if role != "release" {
+		return nil
+	}
+	_, manifests, err := walkSequenceChain(root, slug, dir)
+	if err != nil {
+		return err
+	}
+	manifestRaw, err := readBoundedRegularFile(filepath.Join(dir, "touched-files.md"), maxCandidateManifestBytes)
+	if err != nil {
+		return fmt.Errorf("candidate manifest: %w", err)
+	}
+	rows, err := parseCandidateManifest(manifestRaw)
+	if err != nil {
+		return fmt.Errorf("candidate manifest: %w", err)
+	}
+	declared := make(map[string]struct{}, len(rows))
+	for _, row := range rows {
+		declared[row.path] = struct{}{}
+	}
+	var missing []string
+	for _, ancestor := range manifests {
+		for _, row := range ancestor {
+			if _, ok := declared[row.path]; !ok {
+				missing = append(missing, row.path)
+			}
+		}
+	}
+	if len(missing) > 0 {
+		sort.Strings(missing)
+		const show = 8
+		list := missing
+		if len(list) > show {
+			list = append(append([]string(nil), missing[:show]...), fmt.Sprintf("…and %d more", len(missing)-show))
+		}
+		return fmt.Errorf("release manifest does not cover the recorded sequence chain; run `devrites-engine state merge-manifest %s`. Missing: %s", slug, strings.Join(list, ", "))
+	}
+	return nil
+}
+
+// predecessorManifestRows loads the candidate manifest of a sealed or archived
+// predecessor workspace. Live workspaces win over archive entries so an
+// unshipped sequence member is always found first.
+func predecessorManifestRows(root, slug string) ([]candidateRow, error) {
+	dir, err := devritespaths.ExistingFeatureDirChecked(root, slug)
+	if errors.Is(err, os.ErrNotExist) {
+		dir, err = devritespaths.ExistingArchivedFeatureDirChecked(root, slug)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("no live or archived workspace: %w", err)
+	}
+	raw, err := readBoundedRegularFile(filepath.Join(dir, "touched-files.md"), maxCandidateManifestBytes)
+	if err != nil {
+		return nil, fmt.Errorf("candidate manifest: %w", err)
+	}
+	rows, err := parseCandidateManifest(raw)
+	if err != nil {
+		return nil, fmt.Errorf("candidate manifest: %w", err)
+	}
+	return rows, nil
+}
+
+// replaceManifestSectionBody rewrites the body of the single
+// `## Candidate manifest` section, keeping every other byte of the file —
+// headings, `## Touched files` narrative, and `## Review trail` — intact.
+func replaceManifestSectionBody(raw []byte, body []string) ([]byte, error) {
+	text := string(raw)
+	crlf := strings.Contains(text, "\r\n")
+	lines := strings.Split(text, "\n")
+	start, count := -1, 0
+	for i, line := range lines {
+		if strings.TrimSpace(line) == "## Candidate manifest" {
+			start = i + 1
+			count++
+		}
+	}
+	if count != 1 {
+		return nil, errors.New("requires exactly one ## Candidate manifest section")
+	}
+	end := len(lines)
+	for i := start; i < len(lines); i++ {
+		if strings.HasPrefix(strings.TrimSpace(lines[i]), "## ") {
+			end = i
+			break
+		}
+	}
+	emitted := append([]string(nil), body...)
+	if crlf {
+		for i := range emitted {
+			emitted[i] += "\r"
+		}
+	}
+	if end < len(lines) {
+		emitted = append(emitted, "")
+		if crlf {
+			emitted[len(emitted)-1] = "\r"
+		}
+	}
+	lines = append(lines[:start], append(emitted, lines[end:]...)...)
+	return []byte(strings.Join(lines, "\n")), nil
+}

package/engine/internal/lib/manifest_union_test.go

@@ -0,0 +1,214 @@
+package lib
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const unionManifest = `# Touched files: SLUG
+
+## Touched files
+SLUG scope.
+
+## Candidate manifest
+| State | File | Slice | Reason |
+| --- | --- | --- | --- |
+ROWS
+## Review trail
+SLUG trail.
+`
+
+func manifestBody(rows ...string) string {
+	return strings.Join(rows, "\n") + "\n"
+}
+
+func unionWorkspace(t *testing.T, root, slug, rows string, archived bool) {
+	t.Helper()
+	parent := "work"
+	if archived {
+		parent = "archive"
+	}
+	dir := filepath.Join(root, parent, slug)
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	stateBody := "| phase | seal |\n| schema | 3 |\n"
+	if err := os.WriteFile(filepath.Join(dir, "state.md"), []byte(stateBody), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	manifest := strings.ReplaceAll(unionManifest, "SLUG", slug)
+	manifest = strings.Replace(manifest, "ROWS\n", rows, 1)
+	if err := os.WriteFile(filepath.Join(dir, "touched-files.md"), []byte(manifest), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func unionRoot(t *testing.T) string {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	if err := os.MkdirAll(filepath.Join(root, "work"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return root
+}
+
+func TestMergeManifestUnionsOrderedPredecessors(t *testing.T) {
+	root := unionRoot(t)
+	unionWorkspace(t, root, "feat-1", manifestBody(
+		"| present | `src/a.ts` | SLICE-001 | Added. |",
+		"| present | `src/shared.ts` | SLICE-001 | First write. |",
+	), false)
+	unionWorkspace(t, root, "feat-2", manifestBody(
+		"| present | `src/b.ts` | SLICE-002 | Added. |",
+		"| present | `src/shared.ts` | SLICE-002 | Rewritten. |",
+	), true) // archived predecessor still resolves
+	unionWorkspace(t, root, "release", manifestBody(
+		"| present | `src/r.ts` | SLICE-001 | Release wiring. |",
+	), false)
+
+	var stdout, stderr bytes.Buffer
+	code := RunMergeManifest(root, []string{"release", "feat-1", "feat-2"}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	raw, err := os.ReadFile(filepath.Join(root, "work", "release", "touched-files.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(raw)
+	want := []string{
+		"| present | `src/a.ts` | SLICE-001 | Added. |",
+		"| present | `src/b.ts` | SLICE-002 | Added. |",
+		"| present | `src/r.ts` | SLICE-001 | Release wiring. |",
+		"| present | `src/shared.ts` | SLICE-002 | Rewritten. |", // later position wins
+	}
+	for _, row := range want {
+		if !strings.Contains(text, row) {
+			t.Fatalf("merged manifest missing %q:\n%s", row, text)
+		}
+	}
+	if strings.Contains(text, "First write.") {
+		t.Fatalf("losing collision row survived:\n%s", text)
+	}
+	if !strings.Contains(text, "## Touched files\nrelease scope.") || !strings.Contains(text, "## Review trail\nrelease trail.") {
+		t.Fatalf("non-manifest sections were not preserved:\n%s", text)
+	}
+	if !strings.Contains(stdout.String(), "collision") {
+		t.Fatalf("stdout should report the resolved collision: %q", stdout.String())
+	}
+}
+
+func TestMergeManifestWalksSequenceChain(t *testing.T) {
+	root := unionRoot(t)
+	unionWorkspace(t, root, "feat-1", manifestBody("| present | `src/a.ts` | SLICE-001 | Added. |"), false)
+	unionWorkspace(t, root, "feat-2", manifestBody(
+		"| present | `src/a.ts` | SLICE-002 | Touched again. |",
+		"| present | `src/b.ts` | SLICE-002 | Added. |",
+	), false)
+	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
+	for slug, parent := range map[string]string{"feat-2": "feat-1", "release": "feat-2"} {
+		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)
+		}
+	}
+
+	var stdout, stderr bytes.Buffer
+	if code := RunMergeManifest(root, []string{"release"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("chain walk: code=%d stderr=%s", code, stderr.String())
+	}
+	raw, err := os.ReadFile(filepath.Join(root, "work", "release", "touched-files.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(raw)
+	for _, row := range []string{
+		"| present | `src/a.ts` | SLICE-002 | Touched again. |",
+		"| present | `src/b.ts` | SLICE-002 | Added. |",
+		"| present | `src/r.ts` | SLICE-001 | Release. |",
+	} {
+		if !strings.Contains(text, row) {
+			t.Fatalf("chain-merged manifest missing %q:\n%s", row, text)
+		}
+	}
+
+	// A workspace outside the chain has nothing to walk.
+	stderr.Reset()
+	unionWorkspace(t, root, "lone", manifestBody("| present | `src/x.ts` | SLICE-001 | Lone. |"), false)
+	if code := RunMergeManifest(root, []string{"lone"}, &stdout, &stderr); code != 3 {
+		t.Fatalf("no chain: code=%d stderr=%s", code, stderr.String())
+	}
+}
+
+func TestVerifyReleaseUnionEnforcesChainCoverage(t *testing.T) {
+	root := unionRoot(t)
+	unionWorkspace(t, root, "feat-1", manifestBody("| present | `src/a.ts` | SLICE-001 | Added. |"), false)
+	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
+	for slug, extra := range map[string]string{
+		"release": "| sequence_parent | feat-1 |\n| sequence_role | release |\n",
+		"feat-1":  "",
+	} {
+		if extra == "" {
+			continue
+		}
+		statePath := filepath.Join(root, "work", slug, "state.md")
+		raw, _ := os.ReadFile(statePath)
+		if err := os.WriteFile(statePath, append(raw, []byte(extra)...), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// A release workspace whose manifest misses a predecessor path is blocked.
+	if err := VerifyReleaseUnion(root, "release"); err == nil || !strings.Contains(err.Error(), "merge-manifest") {
+		t.Fatalf("expected union gap, got %v", err)
+	}
+	// Workspaces without the role are not checked.
+	if err := VerifyReleaseUnion(root, "feat-1"); err != nil {
+		t.Fatalf("non-release workspace: %v", err)
+	}
+
+	// After the merge, coverage holds.
+	var stdout, stderr bytes.Buffer
+	if code := RunMergeManifest(root, []string{"release"}, &stdout, &stderr); code != 0 {
+		t.Fatalf("merge: code=%d stderr=%s", code, stderr.String())
+	}
+	if err := VerifyReleaseUnion(root, "release"); err != nil {
+		t.Fatalf("post-merge: %v", err)
+	}
+}
+
+func TestMergeManifestRejectsParentMismatchAndMissingPredecessor(t *testing.T) {
+	root := unionRoot(t)
+	unionWorkspace(t, root, "feat-1", manifestBody("| present | `src/a.ts` | SLICE-001 | Added. |"), false)
+	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
+	statePath := filepath.Join(root, "work", "release", "state.md")
+	raw, _ := os.ReadFile(statePath)
+	raw = append(raw, []byte("| sequence_parent | feat-1 |\n")...)
+	if err := os.WriteFile(statePath, raw, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	var stdout, stderr bytes.Buffer
+	// The recorded parent must be the last predecessor; omitting it blocks.
+	if code := RunMergeManifest(root, []string{"release", "other"}, &stdout, &stderr); code != 3 {
+		t.Fatalf("parent mismatch: code=%d stderr=%s", code, stderr.String())
+	}
+	if !strings.Contains(stderr.String(), "sequence_parent") {
+		t.Fatalf("stderr=%q", stderr.String())
+	}
+	stderr.Reset()
+	if code := RunMergeManifest(root, []string{"release", "feat-1", "ghost"}, &stdout, &stderr); code != 3 {
+		t.Fatalf("missing predecessor: code=%d stderr=%s", code, stderr.String())
+	}
+	stderr.Reset()
+	if code := RunMergeManifest(root, []string{"release", "release", "feat-1"}, &stdout, &stderr); code != 3 {
+		t.Fatalf("self predecessor: code=%d", code)
+	}
+	if code := RunMergeManifest(root, []string{}, &stdout, &stderr); code != 2 {
+		t.Fatalf("missing args: code=%d", code)
+	}
+}

package/engine/internal/lib/observe_budgets.go

@@ -0,0 +1,73 @@
+package lib
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+
+	"github.com/devrites/devrites/internal/state"
+)
+
+const bulkFileThreshold = 64 << 10
+
+// ArtifactBudget reports one canonical workspace artifact against its budget.
+type ArtifactBudget struct {
+	File       string `json:"file"`
+	Lines      int    `json:"lines"`
+	Bytes      int64  `json:"bytes"`
+	LineBudget int    `json:"line_budget"`
+	ByteBudget int64  `json:"byte_budget"`
+	Over       bool   `json:"over"`
+	Override   bool   `json:"override,omitempty"`
+}
+
+// BulkFile is a non-canonical regular file in the workspace root above bulkFileThreshold.
+type BulkFile struct {
+	File  string `json:"file"`
+	Bytes int64  `json:"bytes"`
+}
+
+// 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) {
+	entries, err := os.ReadDir(workspace)
+	if err != nil {
+		return nil, nil, err
+	}
+	var budgets []ArtifactBudget
+	var bulk []BulkFile
+	for _, entry := range entries {
+		if !entry.Type().IsRegular() {
+			continue
+		}
+		info, err := entry.Info()
+		if err != nil {
+			return nil, nil, err
+		}
+		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 err != nil {
+			return nil, nil, err
+		}
+		measured, _ := state.ArtifactBudget(name, raw)
+		budgets = append(budgets, ArtifactBudget{
+			File:       name,
+			Lines:      measured.Lines,
+			Bytes:      measured.Bytes,
+			LineBudget: measured.LineBudget,
+			ByteBudget: measured.ByteBudget,
+			Over:       measured.Over,
+			Override:   measured.Override,
+		})
+	}
+	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
+}