devrites 5.4.0 → 5.6.0

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
+}

package/engine/internal/lib/observe_budgets_test.go

@@ -0,0 +1,142 @@
+package lib
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/devrites/devrites/internal/state"
+)
+
+const budgetTasks = `# Tasks
+
+Current checkpoint: intro text.
+
+## SLICE-001 First
+Goal: one
+Dependencies: none
+depends_on: []
+
+### Notes
+nested heading stays inside the slice
+
+## SLICE-002 Second
+Goal: two
+Dependencies: SLICE-001
+depends_on: [SLICE-001]
+
+## Trailing section
+not a slice
+`
+
+func writeBudgetWorkspace(t *testing.T, files map[string]string) (root, workspace string) {
+	t.Helper()
+	root = filepath.Join(t.TempDir(), ".devrites")
+	workspace = filepath.Join(root, "work", "feature")
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	for name, body := range files {
+		if err := os.WriteFile(filepath.Join(workspace, name), []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return root, workspace
+}
+
+func TestExtractTaskSliceStopsAtNextH2AndKeepsH3(t *testing.T) {
+	block, ok := state.ExtractTaskSlice([]byte(budgetTasks), "SLICE-001")
+	if !ok {
+		t.Fatal("expected SLICE-001")
+	}
+	if !strings.HasPrefix(block, "## SLICE-001 First\n") || !strings.Contains(block, "### Notes") {
+		t.Fatalf("block=%q", block)
+	}
+	if strings.Contains(block, "SLICE-002") || strings.Contains(block, "Trailing") {
+		t.Fatalf("block leaked past the next heading: %q", block)
+	}
+	last, ok := state.ExtractTaskSlice([]byte(budgetTasks), "SLICE-002")
+	if !ok || strings.Contains(last, "Trailing section") {
+		t.Fatalf("last=%q ok=%v", last, ok)
+	}
+	if _, ok := state.ExtractTaskSlice([]byte(budgetTasks), "SLICE-003"); ok {
+		t.Fatal("SLICE-003 must not resolve")
+	}
+}
+
+func TestRunObserveSlicePrintsOneSection(t *testing.T) {
+	root, _ := writeBudgetWorkspace(t, map[string]string{"tasks.md": budgetTasks})
+	var stdout, stderr bytes.Buffer
+	if code := RunObserveSlice(root, "feature", "SLICE-002", &stdout, &stderr); code != 0 {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	if got := stdout.String(); !strings.HasPrefix(got, "## SLICE-002 Second\n") || strings.Contains(got, "SLICE-001 First") {
+		t.Fatalf("stdout=%q", got)
+	}
+
+	stdout.Reset()
+	if code := RunObserveSlice(root, "feature", "SLICE-009", &stdout, &stderr); code != 3 || !strings.Contains(stdout.String(), "BLOCKED") {
+		t.Fatalf("code=%d stdout=%q", code, stdout.String())
+	}
+	if code := RunObserveSlice(root, "feature", "slice-1", &stdout, &stderr); code != 2 {
+		t.Fatalf("code=%d for malformed id", code)
+	}
+}
+
+func TestObserveSummaryReportsBudgetsAndBulkFiles(t *testing.T) {
+	longLine := strings.Repeat("x", 60_000) + "\n"
+	root, _ := writeBudgetWorkspace(t, map[string]string{
+		"state.md":                "| phase | build |\n| schema | 3 |\n" + longLine,
+		"tasks.md":                budgetTasks,
+		"vet-review-input-1.json": strings.Repeat("{}", 40_000),
+		"small-note.json":         "{}",
+	})
+	summary, err := ObserveSummaryFor(root, "feature")
+	if err != nil {
+		t.Fatal(err)
+	}
+	byFile := map[string]ArtifactBudget{}
+	for _, b := range summary.ArtifactBudgets {
+		byFile[b.File] = b
+	}
+	if st, ok := byFile["state.md"]; !ok || !st.Over || st.Lines != 3 || st.ByteBudget != 120*state.BudgetBytesPerLine {
+		t.Fatalf("state.md budget=%+v ok=%v (long line must trip the byte budget)", st, ok)
+	}
+	if tk, ok := byFile["tasks.md"]; !ok || tk.Over {
+		t.Fatalf("tasks.md budget=%+v ok=%v", tk, ok)
+	}
+	if summary.TaskGraph == nil || len(summary.TaskGraph.Slices) != 2 ||
+		summary.TaskGraph.Slices[0].ID != "SLICE-001" || len(summary.TaskGraph.Slices[0].DependsOn) != 0 ||
+		summary.TaskGraph.Slices[1].DependsOn[0] != "SLICE-001" {
+		t.Fatalf("task_graph.slices=%+v", summary.TaskGraph)
+	}
+	if len(summary.BulkFiles) != 1 || summary.BulkFiles[0].File != "vet-review-input-1.json" {
+		t.Fatalf("bulk_files=%+v", summary.BulkFiles)
+	}
+}
+
+func TestObserveSummaryReportsSequenceCursor(t *testing.T) {
+	root, _ := writeBudgetWorkspace(t, map[string]string{
+		"state.md": "| phase | build |\n| schema | 3 |\n| sequence_parent | feat-1 |\n| sequence_position | 2 |\n| sequence_workspaces_remaining | 3 |\n",
+	})
+	summary, err := ObserveSummaryFor(root, "feature")
+	if err != nil {
+		t.Fatal(err)
+	}
+	seq := summary.Sequence
+	if seq == nil || seq.Parent != "feat-1" || seq.Position != "2" || seq.WorkspacesRemaining != "3" {
+		t.Fatalf("sequence=%+v", seq)
+	}
+	root, _ = writeBudgetWorkspace(t, map[string]string{
+		"state.md": "| phase | build |\n| schema | 3 |\n",
+	})
+	summary, err = ObserveSummaryFor(root, "feature")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if summary.Sequence != nil {
+		t.Fatalf("sequence must be absent without cursor fields: %+v", summary.Sequence)
+	}
+}

package/engine/internal/lib/observe_summary.go

@@ -2,30 +2,50 @@ package lib
 
 import (
 	"encoding/json"
+	"fmt"
 	"io"
 
+	"github.com/devrites/devrites/internal/devritespaths"
 	"github.com/devrites/devrites/internal/state"
 )
 
+// ObserveSlice is one slice's identity and ordering edges, enough for a root to pick
+// the next buildable slice without loading tasks.md.
+type ObserveSlice struct {
+	ID        string   `json:"id"`
+	DependsOn []string `json:"depends_on"`
+}
+
 // ObserveTaskGraph is the slice-graph subset of ObserveSummary.
 type ObserveTaskGraph struct {
-	SliceCount int      `json:"slice_count"`
-	Cycle      []string `json:"cycle,omitempty"`
-	Unknown    []string `json:"unknown_dependencies,omitempty"`
-	Problems   []string `json:"problems,omitempty"`
-	OK         bool     `json:"ok"`
+	SliceCount int            `json:"slice_count"`
+	Slices     []ObserveSlice `json:"slices,omitempty"`
+	Cycle      []string       `json:"cycle,omitempty"`
+	Unknown    []string       `json:"unknown_dependencies,omitempty"`
+	Problems   []string       `json:"problems,omitempty"`
+	OK         bool           `json:"ok"`
 }
 
 // ObserveSummary is a sanitized, machine-readable workspace snapshot.
+type ObserveSequenceCursor struct {
+	Parent              string `json:"parent"`
+	Position            string `json:"position"`
+	WorkspacesRemaining string `json:"workspaces_remaining"`
+	Role                string `json:"role,omitempty"`
+}
+
 type ObserveSummary struct {
-	Slug              string            `json:"slug"`
-	Phase             string            `json:"phase,omitempty"`
-	Status            string            `json:"status,omitempty"`
-	NextAction        string            `json:"next_action,omitempty"`
-	MissingSections   []string          `json:"missing_sections,omitempty"`
-	MissingFiles      []string          `json:"missing_files,omitempty"`
-	PrinciplesPresent bool              `json:"principles_present"`
-	TaskGraph         *ObserveTaskGraph `json:"task_graph,omitempty"`
+	Slug              string                 `json:"slug"`
+	Phase             string                 `json:"phase,omitempty"`
+	Status            string                 `json:"status,omitempty"`
+	NextAction        string                 `json:"next_action,omitempty"`
+	MissingSections   []string               `json:"missing_sections,omitempty"`
+	MissingFiles      []string               `json:"missing_files,omitempty"`
+	PrinciplesPresent bool                   `json:"principles_present"`
+	TaskGraph         *ObserveTaskGraph      `json:"task_graph,omitempty"`
+	ArtifactBudgets   []ArtifactBudget       `json:"artifact_budgets,omitempty"`
+	BulkFiles         []BulkFile             `json:"bulk_files,omitempty"`
+	Sequence          *ObserveSequenceCursor `json:"sequence,omitempty"`
 }
 
 // ObserveSummaryFor builds a summary for one feature slug.
@@ -45,17 +65,58 @@ func ObserveSummaryFor(root, slug string) (ObserveSummary, error) {
 	}
 
 	if graph, graphErr := CheckTaskGraph(root, slug); graphErr == nil && (len(graph.Slices) > 0 || len(graph.Problems) > 0) {
+		slices := make([]ObserveSlice, 0, len(graph.Slices))
+		for _, slice := range graph.Slices {
+			deps := make([]string, 0, len(slice.Dependencies))
+			deps = append(deps, slice.Dependencies...)
+			slices = append(slices, ObserveSlice{ID: slice.ID, DependsOn: deps})
+		}
 		summary.TaskGraph = &ObserveTaskGraph{
 			SliceCount: len(graph.Slices),
+			Slices:     slices,
 			Cycle:      append([]string(nil), graph.Cycle...),
 			Unknown:    append([]string(nil), graph.Unknown...),
 			Problems:   append([]string(nil), graph.Problems...),
 			OK:         len(graph.Problems) == 0,
 		}
 	}
+	if report.SequenceParent != "" || report.SequencePosition != "" || report.SequenceWorkspacesRemaining != "" || report.SequenceRole != "" {
+		summary.Sequence = &ObserveSequenceCursor{
+			Parent:              report.SequenceParent,
+			Position:            report.SequencePosition,
+			WorkspacesRemaining: report.SequenceWorkspacesRemaining,
+			Role:                report.SequenceRole,
+		}
+	}
+	if workspace, wsErr := devritespaths.ExistingFeatureDirChecked(root, slug); wsErr == nil {
+		if budgets, bulk, budgetErr := observeArtifactBudgets(workspace); budgetErr == nil {
+			summary.ArtifactBudgets = budgets
+			summary.BulkFiles = bulk
+		}
+	}
 	return summary, nil
 }
 
+// RunObserveSlice prints one SLICE-### section of tasks.md for a slug.
+func RunObserveSlice(root, slug, id string, stdout, stderr io.Writer) int {
+	if !state.ValidSliceID(id) {
+		fmt.Fprintf(stderr, "observe slice: %q is not a SLICE-### id\n", id)
+		return 2
+	}
+	raw, err := readWorkspaceArtifact(root, slug, "tasks.md")
+	if err != nil {
+		fmt.Fprintf(stderr, "observe slice: %v\n", err)
+		return 2
+	}
+	block, ok := state.ExtractTaskSlice(raw, id)
+	if !ok {
+		fmt.Fprintf(stdout, "observe slice: BLOCKED: %s not found in tasks.md\n", id)
+		return 3
+	}
+	fmt.Fprint(stdout, block)
+	return 0
+}
+
 func missingSectionNames(sections []state.Section) []string {
 	if len(sections) == 0 {
 		return nil

package/engine/internal/lib/workspace_read.go

@@ -8,23 +8,28 @@ import (
 	"github.com/devrites/devrites/internal/devritespaths"
 )
 
+// workspaceArtifactLimit bounds one artifact read. Slice extraction must keep
+// working on a workspace whose tasks.md is over budget: the budget gate flags the
+// file, while Build still reads its own slice instead of the whole document.
+const workspaceArtifactLimit = 16 << 20
+
 func readWorkspaceArtifact(root, slug, name string) ([]byte, error) {
 	workspace, err := devritespaths.ExistingFeatureDirChecked(root, slug)
 	if err != nil {
-		return nil, fmt.Errorf("task-graph: workspace unavailable: %w", err)
+		return nil, fmt.Errorf("workspace artifact: workspace unavailable: %w", err)
 	}
 	path := filepath.Join(workspace, name)
 	info, err := os.Stat(path)
 	if err != nil {
-		return nil, fmt.Errorf("task-graph: %s unavailable: %w", name, err)
+		return nil, fmt.Errorf("workspace artifact: %s unavailable: %w", name, err)
 	}
-	if info.Size() > 1<<20 {
-		return nil, fmt.Errorf("task-graph: %s exceeds 1 MiB limit", name)
+	if info.Size() > workspaceArtifactLimit {
+		return nil, fmt.Errorf("workspace artifact: %s exceeds %d MiB limit", name, workspaceArtifactLimit>>20)
 	}
-	// #nosec G304 -- workspace task-graph file; 1 MiB cap checked above
+	// #nosec G304 -- workspace artifact; size cap checked above
 	raw, err := os.ReadFile(path)
 	if err != nil {
-		return nil, fmt.Errorf("task-graph: cannot read %s: %w", name, err)
+		return nil, fmt.Errorf("workspace artifact: cannot read %s: %w", name, err)
 	}
 	return raw, nil
 }