devrites 6.0.4 → 6.1.1

package/engine/internal/lib/metrics.go

@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/state"
 )
 
 // MetricsFile is the per-feature append-only event ledger. One JSON object per
@@ -150,6 +151,16 @@ func recordMetric(root, slug, phase, event, role string, bytes int64) {
 	_ = f.Close()
 }
 
+// cursorPhase is the feature's recorded cursor phase, or "" when state.md is
+// unreadable; engine checks label their metrics with it.
+func cursorPhase(root, slug string) string {
+	report, err := state.Status(root, slug)
+	if err != nil {
+		return ""
+	}
+	return string(report.Phase)
+}
+
 func metricsSummary(root string, args []string, stdout, stderr io.Writer) int {
 	bySlice := slices.Contains(args, "--by-slice")
 	args = slices.DeleteFunc(slices.Clone(args), func(a string) bool { return a == "--by-slice" })
@@ -170,10 +181,14 @@ func metricsSummary(root string, args []string, stdout, stderr io.Writer) int {
 		return sliceCostSummary(root, slug, stdout, stderr)
 	}
 	f, err := os.Open(filepath.Join(dir, MetricsFile)) // #nosec G304 -- dir is a validated workspace and filename is fixed
-	if err != nil {
+	if os.IsNotExist(err) {
 		fmt.Fprintf(stdout, "metrics: no events recorded for %s\n", slug)
 		return 0
 	}
+	if err != nil {
+		fmt.Fprintf(stderr, "metrics: ledger unreadable: %v\n", err)
+		return 2
+	}
 	defer func() { _ = f.Close() }()
 
 	type phaseAgg struct {
@@ -190,11 +205,20 @@ func metricsSummary(root string, args []string, stdout, stderr io.Writer) int {
 	totalBytes := int64(0)
 	totalEvents := 0
 	bad := 0
-	scanner := bufio.NewScanner(f)
-	scanner.Buffer(make([]byte, 64<<10), 1<<20)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
+	// A reader, not a Scanner: one event line carries an unbounded --note. A
+	// final line without a newline is handled, then the next read is ("", EOF).
+	reader := bufio.NewReader(f)
+	for {
+		raw, readErr := reader.ReadString('\n')
+		if readErr != nil && readErr != io.EOF {
+			fmt.Fprintf(stderr, "metrics: ledger unreadable after %d events: %v\n", totalEvents, readErr)
+			return 2
+		}
+		line := strings.TrimSpace(raw)
 		if line == "" {
+			if readErr == io.EOF {
+				break
+			}
 			continue
 		}
 		var ev metricEvent
@@ -222,10 +246,6 @@ 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/migrate.go

@@ -31,7 +31,7 @@ type migratePlan struct {
 	questions []migrateQuestion
 }
 
-// Migrate normalizes a pre-v5 feature workspace to the current schema: it
+// Migrate normalizes an older-schema feature workspace to the current schema: it
 // converts legacy bullet cursor fields into canonical table rows, records the
 // schema row, and creates missing required artifacts as empty stubs. Bound
 // proof files are preserved byte-exact; content is never synthesized. The
@@ -130,6 +130,23 @@ func Migrate(root string, args []string, stdout, stderr io.Writer) int {
 			return nil
 		}
 
+		next := lines
+		for _, step := range plan.steps {
+			if step.kind == "phase" {
+				next = state.UpsertCursorField(next, state.CursorPhase, plan.phase)
+			}
+		}
+		if converted, changed := state.ConvertCursorToTable(next); changed {
+			next = converted
+		}
+		next = state.UpsertCursorField(next, state.CursorSchema, fmt.Sprint(state.SchemaVersion))
+		// Upserts silently decline what they cannot write (for example after
+		// an unclosed fence), so confirm the schema row reads back before
+		// touching anything.
+		if value, ok := state.CursorField(next, state.CursorSchema); !ok || strings.TrimSpace(value) != fmt.Sprint(state.SchemaVersion) {
+			return fmt.Errorf("state.md cannot be normalized: the schema row does not read back (check for an unclosed fence or malformed cursor); nothing written")
+		}
+
 		// New stub files go first: they are idempotent, never bound, and
 		// state.md is the commit point written last.
 		for _, step := range plan.steps {
@@ -145,16 +162,6 @@ func Migrate(root string, args []string, stdout, stderr io.Writer) int {
 			}
 			applied++
 		}
-		next := lines
-		for _, step := range plan.steps {
-			if step.kind == "phase" {
-				next = state.UpsertCursorField(next, state.CursorPhase, plan.phase)
-			}
-		}
-		if converted, changed := state.ConvertCursorToTable(next); changed {
-			next = converted
-		}
-		next = state.UpsertCursorField(next, state.CursorSchema, fmt.Sprint(state.SchemaVersion))
 		if err := fsutil.WriteFileAtomic(ledger, []byte(strings.Join(next, "\n")), 0o644); err != nil {
 			return err
 		}
@@ -175,6 +182,7 @@ func buildMigratePlan(root, slug string, lines []string, answered map[string]str
 	phase, hasPhase := state.CursorField(lines, state.CursorPhase)
 
 	if value, ok := answered["phase"]; ok {
+		value = phaseWord(value)
 		plan.steps = append(plan.steps, migrateStep{kind: "phase", detail: "record phase " + value + " from answer"})
 		phase, hasPhase = value, true
 	}
@@ -183,11 +191,12 @@ func buildMigratePlan(root, slug string, lines []string, answered map[string]str
 			prompt: "state.md records no phase; re-run with --answer phase=<phase>"})
 		return plan
 	}
-	if _, ok := state.PolicyFor(state.Phase(phase)); !ok {
+	if _, ok := state.PolicyFor(state.Phase(phaseWord(phase))); !ok {
 		plan.questions = append(plan.questions, migrateQuestion{id: "phase",
 			prompt: "state.md records unknown phase " + phase + "; re-run with --answer phase=<phase>"})
 		return plan
 	}
+	phase = phaseWord(phase)
 	plan.phase = phase
 
 	if state.CursorForm(lines) == "legacy" {
@@ -209,6 +218,15 @@ func buildMigratePlan(root, slug string, lines []string, answered map[string]str
 	return plan
 }
 
+// phaseWord reads a cursor phase the way the engine does: lower-cased first
+// word, so "Build" and "build (slice 2)" both mean build.
+func phaseWord(value string) string {
+	if fields := strings.Fields(strings.ToLower(value)); len(fields) > 0 {
+		return fields[0]
+	}
+	return ""
+}
+
 // stringSlice collects repeated string flag values.
 type stringSlice []string
 

package/engine/internal/lib/next.go

@@ -6,9 +6,11 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"strings"
 
 	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/markdowntext"
 	"github.com/devrites/devrites/internal/state"
 	"github.com/devrites/devrites/internal/workflow"
 )
@@ -86,7 +88,11 @@ func RunNext(root string, args []string, stdout, stderr io.Writer) int {
 				continue
 			}
 			missing = missingArtifacts(featureDir, policy.RequiredArtifacts)
-			if len(missing) == 0 {
+			// A phase that adds no required artifact over the previous one
+			// (build after vet, polish after prove) cannot be proven done by
+			// artifact presence, so it is never skipped. Converge is the
+			// exception: a conditional recovery pass that build hands past.
+			if len(missing) == 0 && (addsArtifact(policies[i-1], policy) || policy.Target == state.PhaseConverge) {
 				skips = append(skips, fmt.Sprintf("%s (artifacts complete)", policy.Target))
 				continue
 			}
@@ -121,6 +127,15 @@ func printSkips(stdout io.Writer, skips []string) {
 	}
 }
 
+func addsArtifact(prev, policy state.PhasePolicy) bool {
+	for _, artifact := range policy.RequiredArtifacts {
+		if !slices.Contains(prev.RequiredArtifacts, artifact) {
+			return true
+		}
+	}
+	return false
+}
+
 func missingArtifacts(featureDir string, required []state.ArtifactPath) []string {
 	var missing []string
 	for _, artifact := range required {
@@ -139,12 +154,17 @@ var (
 )
 
 // countOpenQuestions tolerates both the block form ("status: open") and the
-// register table form ("| Q-001 | open | ... |").
+// register table form ("| Q-001 | open | ... |"), outside fenced blocks.
 func countOpenQuestions(path string) int {
 	data, err := os.ReadFile(path) // #nosec G304 -- path is a validated workspace artifact
 	if err != nil {
 		return 0
 	}
+	// Fenced examples are not live questions. Text Structural rejects is
+	// counted raw, so an unreadable register over-counts rather than hides.
+	if visible, err := markdowntext.Structural(data); err == nil {
+		data = visible
+	}
 	count := 0
 	for _, line := range strings.Split(string(data), "\n") {
 		if openStatusLine.MatchString(line) || openTableCell.MatchString(line) {

package/engine/internal/lib/open_visual.go

@@ -63,7 +63,9 @@ func OpenVisual(root string, args []string, stdout, stderr io.Writer) int {
 			return 2
 		}
 		visualDir := filepath.Join(feature, "visual")
-		if !safepath.WithinResolved(htmlPath, visualDir) {
+		// visual/ itself may be a symlink: resolving both sides would then
+		// accept any file under its target.
+		if !safepath.WithinResolved(visualDir, feature) || !safepath.WithinResolved(htmlPath, visualDir) {
 			fmt.Fprintf(stderr, "open-visual: refused: resolved path escapes workspace visual/\n")
 			return 2
 		}

package/engine/internal/lib/recall.go

@@ -0,0 +1,355 @@
+package lib
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/devrites/devrites/internal/devritespaths"
+	"github.com/devrites/devrites/internal/markdowntext"
+	"github.com/devrites/devrites/internal/parallel"
+)
+
+// RecallUsage is the help and usage-error text for `recall`.
+const RecallUsage = `usage: devrites-engine recall --paths <p1,p2,...> [--paths <p>]... [--limit n]
+
+Lists archived features (.devrites/archive/<slug>/) whose touched-files.md
+candidate manifest covers a queried project-relative path: exact or as a
+directory prefix, case-folded. Ranked by overlap count, then newest archive
+directory mtime, then slug; --limit caps the features shown (default 10).
+Each feature prints up to 8 pointers (then "+N more"): decisions.md DEC-###
+entries and ## Carry-forward constraints bullets whose Files: overlap (or a
+constraint naming no files), and review.md/seal.md/drift.md lines that mention
+a queried path. Fenced examples are ignored. Pointer files are relative to
+.devrites. Read-only: computed on every call; nothing is written, cached, or
+indexed. An unreadable archive entry prints "unreadable:" and the scan goes on.
+Exit 0 ok (including no archive or no match), 1 invalid archive directory, 2 usage.`
+
+const (
+	recallDefaultLimit = 10
+	recallPointerCap   = 8
+	recallClipRunes    = 120
+)
+
+// recallPointerFiles are scanned in this order; decisions.md is structural,
+// the rest are searched for path mentions.
+var recallPointerFiles = []string{"decisions.md", "review.md", "seal.md", "drift.md"}
+
+var recallDecisionHeading = regexp.MustCompile(`^#{1,6}[ \t]+DEC-[0-9]+`)
+
+type recallFeature struct {
+	slug    string
+	dir     string
+	mtime   time.Time
+	matched []string // queried paths the manifest covers, in query order
+}
+
+// RunRecall answers "what did earlier features decide or find about these
+// paths" by reading the archive on every call (ADR-0014/ADR-0022 forbid an
+// engine index or ledger). It never writes, not even a metric.
+func RunRecall(root string, args []string, stdout, stderr io.Writer) int {
+	queries, limit, ok := parseRecallArgs(args, stderr)
+	if !ok {
+		return 2
+	}
+	archiveDir, err := devritespaths.ArchiveDirChecked(root)
+	if err != nil {
+		fmt.Fprintf(stderr, "recall: invalid archive directory: %v\n", err)
+		return 1
+	}
+	entries, err := os.ReadDir(archiveDir)
+	if errors.Is(err, fs.ErrNotExist) {
+		fmt.Fprintln(stdout, "recall: no archive")
+		return 0
+	}
+	if err != nil {
+		fmt.Fprintf(stderr, "recall: read archive: %v\n", err)
+		return 1
+	}
+	var features []recallFeature
+	var unreadable []string
+	for _, entry := range entries {
+		name := entry.Name()
+		// Hidden scratch dirs and stray files are not archived features.
+		if strings.HasPrefix(name, ".") || entry.Type().IsRegular() {
+			continue
+		}
+		label := "archive/" + name
+		dir, err := devritespaths.ExistingArchivedFeatureDirChecked(root, name)
+		if err != nil {
+			unreadable = append(unreadable, fmt.Sprintf("%s (%v)", label, err))
+			continue
+		}
+		raw, err := readBoundedRegularFile(filepath.Join(dir, "touched-files.md"), maxCandidateManifestBytes)
+		if errors.Is(err, fs.ErrNotExist) {
+			continue // never built: touched nothing
+		}
+		var rows []candidateRow
+		if err == nil {
+			rows, err = parseCandidateManifest(raw)
+		}
+		if err != nil {
+			unreadable = append(unreadable, fmt.Sprintf("%s/touched-files.md (%v)", label, err))
+			continue
+		}
+		matched := recallMatched(queries, rows)
+		if len(matched) == 0 {
+			continue
+		}
+		feature := recallFeature{slug: name, dir: dir, matched: matched}
+		if info, err := entry.Info(); err == nil {
+			feature.mtime = info.ModTime()
+		}
+		features = append(features, feature)
+	}
+	sort.SliceStable(features, func(i, j int) bool {
+		a, b := features[i], features[j]
+		if len(a.matched) != len(b.matched) {
+			return len(a.matched) > len(b.matched)
+		}
+		if !a.mtime.Equal(b.mtime) {
+			return a.mtime.After(b.mtime)
+		}
+		return a.slug < b.slug
+	})
+	if len(features) == 0 {
+		fmt.Fprintln(stdout, "recall: no archived feature touched these paths")
+	} else {
+		fmt.Fprintf(stdout, "recall: %d archived feature(s) touched these paths\n", len(features))
+		if len(features) > limit {
+			fmt.Fprintf(stdout, "recall: truncated to %d feature(s) (--limit)\n", limit)
+			features = features[:limit]
+		}
+		for _, f := range features {
+			fmt.Fprintf(stdout, "feature %s overlap=%d paths=%s\n", f.slug, len(f.matched), strings.Join(f.matched, ","))
+			writeRecallPointers(stdout, f.dir, "archive/"+f.slug, queries)
+		}
+	}
+	for _, line := range unreadable {
+		fmt.Fprintf(stdout, "unreadable: %s\n", line)
+	}
+	return 0
+}
+
+func parseRecallArgs(args []string, stderr io.Writer) ([]string, int, bool) {
+	limit := recallDefaultLimit
+	var queries []string
+	seen := map[string]bool{}
+	for i := 0; i < len(args); i++ {
+		switch args[i] {
+		case "--paths":
+			value := argAt(args, i+1)
+			i++
+			if strings.TrimSpace(value) == "" || strings.HasPrefix(value, "-") {
+				fmt.Fprintln(stderr, "recall: --paths requires a comma-separated path list (not a flag)")
+				return nil, 0, false
+			}
+			for _, raw := range strings.Split(value, ",") {
+				if strings.TrimSpace(raw) == "" {
+					continue
+				}
+				path, err := parallel.NormalizePath(raw)
+				if err == nil && strings.HasPrefix(path, "-") {
+					err = fmt.Errorf("path must not look like a flag: %q", raw)
+				}
+				if err != nil {
+					fmt.Fprintf(stderr, "recall: --paths: %v\n", err)
+					return nil, 0, false
+				}
+				if key := strings.ToLower(path); !seen[key] {
+					seen[key] = true
+					queries = append(queries, path)
+				}
+			}
+		case "--limit":
+			n, err := strconv.Atoi(argAt(args, i+1))
+			if err != nil || n < 1 {
+				fmt.Fprintf(stderr, "recall: --limit expects a positive integer, got %q\n", argAt(args, i+1))
+				return nil, 0, false
+			}
+			limit = n
+			i++
+		default:
+			fmt.Fprintf(stderr, "recall: unexpected argument %q\n%s\n", args[i], RecallUsage)
+			return nil, 0, false
+		}
+	}
+	if len(queries) == 0 {
+		fmt.Fprintln(stderr, RecallUsage)
+		return nil, 0, false
+	}
+	return queries, limit, true
+}
+
+// recallMatched returns the queries covered by a manifest row, folding case
+// and matching directory prefixes with the claim-overlap rule.
+func recallMatched(queries []string, rows []candidateRow) []string {
+	var matched []string
+	for _, q := range queries {
+		for _, row := range rows {
+			if claimPathsOverlap(row.path, q) {
+				matched = append(matched, q)
+				break
+			}
+		}
+	}
+	return matched
+}
+
+func writeRecallPointers(w io.Writer, dir, label string, queries []string) {
+	var pointers, unreadable []string
+	for _, name := range recallPointerFiles {
+		raw, err := readBoundedRegularFile(filepath.Join(dir, name), maxCandidateArtifactBytes)
+		if errors.Is(err, fs.ErrNotExist) {
+			continue
+		}
+		if err == nil {
+			raw, err = markdowntext.Structural(raw)
+		}
+		if err != nil {
+			unreadable = append(unreadable, fmt.Sprintf("%s/%s (%v)", label, name, err))
+			continue
+		}
+		lines := strings.Split(string(raw), "\n")
+		var hits []int
+		if name == "decisions.md" {
+			hits = recallDecisionHits(lines, queries)
+		} else {
+			for i, line := range lines {
+				if recallMentions(line, queries) {
+					hits = append(hits, i)
+				}
+			}
+		}
+		for _, i := range hits {
+			pointers = append(pointers, fmt.Sprintf("%s/%s:%d  %s", label, name, i+1, clipRunes(strings.TrimSpace(lines[i]), recallClipRunes)))
+		}
+	}
+	for i, p := range pointers {
+		if i == recallPointerCap {
+			fmt.Fprintf(w, "  +%d more\n", len(pointers)-recallPointerCap)
+			break
+		}
+		fmt.Fprintf(w, "  %s\n", p)
+	}
+	for _, u := range unreadable {
+		fmt.Fprintf(w, "  unreadable: %s\n", u)
+	}
+}
+
+// recallDecisionHits returns the line indexes of DEC-### headings whose
+// Files: field overlaps the queries, and of carry-forward constraint bullets
+// that overlap or name no files. Fenced lines arrive already blanked.
+func recallDecisionHits(lines []string, queries []string) []int {
+	var hits []int
+	dec, decDone, carry := -1, false, false
+	for i, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		rest := strings.TrimLeft(trimmed, "#")
+		if level := len(trimmed) - len(rest); level > 0 && (rest == "" || rest[0] == ' ' || rest[0] == '\t') {
+			dec, decDone = -1, false
+			if recallDecisionHeading.MatchString(trimmed) {
+				dec = i
+			}
+			// As in handoff's dead ends, a ### subheading stays in the section.
+			if level <= 2 {
+				carry = strings.EqualFold(trimmed, "## Carry-forward constraints")
+			}
+			continue
+		}
+		if dec >= 0 {
+			if files, ok := recallFilesField(trimmed); ok && !decDone && recallOverlaps(files, queries) {
+				hits = append(hits, dec)
+				decDone = true
+			}
+			continue
+		}
+		entry, ok := strings.CutPrefix(trimmed, "- ")
+		if !carry || !ok || strings.TrimSpace(entry) == "" {
+			continue
+		}
+		var files []string
+		if at := strings.LastIndex(entry, "Files:"); at >= 0 {
+			files = recallPathList(entry[at+len("Files:"):])
+		}
+		if len(files) == 0 || recallOverlaps(files, queries) {
+			hits = append(hits, i)
+		}
+	}
+	return hits
+}
+
+// recallFilesField parses a `Files:` field line such as "- Files: a, b" or
+// "**Files:** `a` `b`".
+func recallFilesField(trimmed string) ([]string, bool) {
+	s := strings.TrimLeft(trimmed, "-*+ \t")
+	if !strings.HasPrefix(strings.ToLower(s), "files:") {
+		return nil, false
+	}
+	return recallPathList(strings.TrimLeft(s[len("files:"):], "* \t")), true
+}
+
+func recallPathList(s string) []string {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case "", "none", "n/a", "-", "—":
+		return nil
+	}
+	var out []string
+	for _, field := range strings.FieldsFunc(s, func(r rune) bool { return r == ',' || r == ';' || unicode.IsSpace(r) }) {
+		field = strings.TrimSuffix(strings.Trim(field, "`'\"()[]"), ".")
+		if path, err := parallel.NormalizePath(field); err == nil {
+			out = append(out, path)
+		}
+	}
+	return out
+}
+
+func recallOverlaps(files, queries []string) bool {
+	for _, f := range files {
+		for _, q := range queries {
+			if claimPathsOverlap(f, q) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// recallMentions reports a case-folded occurrence of a queried path that is
+// not part of a longer path: "src/a.go" matches "`src/a.go:12`" but not
+// "mysrc/a.go", "lib/src/a.go", or "src/a.gox".
+func recallMentions(line string, queries []string) bool {
+	lower := strings.ToLower(line)
+	for _, q := range queries {
+		q = strings.ToLower(q)
+		for from := 0; from < len(lower); {
+			at := strings.Index(lower[from:], q)
+			if at < 0 {
+				break
+			}
+			start, end := from+at, from+at+len(q)
+			before := start == 0 || !recallPathByte(lower[start-1])
+			after := end == len(lower) || lower[end] == '/' || !recallPathByte(lower[end]) ||
+				lower[end] == '.' && (end+1 == len(lower) || !recallPathByte(lower[end+1]))
+			if before && after {
+				return true
+			}
+			from = start + 1
+		}
+	}
+	return false
+}
+
+func recallPathByte(c byte) bool {
+	return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' ||
+		c == '_' || c == '-' || c == '.' || c == '/' || c >= 0x80
+}

package/engine/internal/lib/regression.go

@@ -7,7 +7,9 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -49,6 +51,8 @@ var doneSliceStates = map[string]bool{
 var (
 	regressACRe      = regexp.MustCompile(`(?im)^[ \t]*- \[([xX ])\] (AC-\d+)`)
 	regressSliceRe   = regexp.MustCompile(`(?m)^## (SLICE-\d+)\b[^\n]*`)
+	regressBuiltRe   = regexp.MustCompile(`(?m)^[ \t]*[-*] \[[xX]\][^\n]*`)
+	regressSliceIDRe = regexp.MustCompile(`(?i)\b(?:SLICE-|Slice )(\d+)\b`)
 	regressStatusRe  = regexp.MustCompile(`(?im)^Status:[ \t]*([^\s]+)`)
 	regressQHeaderRe = regexp.MustCompile(`(?im)^## (q-\d{4}-\d{2}-\d{2}-\d+)\b`)
 	regressQStatusRe = regexp.MustCompile(`(?im)^status:[ \t]*([^\s]+)`)
@@ -170,6 +174,22 @@ func fingerprintWorkspace(root, slug, workspace string) (progressFingerprint, er
 	if err == nil {
 		fp.DoneSlices = doneSlices(masked)
 	}
+	// The canonical slice grammar has no Status field: Build records the
+	// built list in state.md as checked items naming the slice.
+	masked, err = maskedArtifact(workspace, "state.md")
+	note("state.md", err)
+	if err == nil {
+		for _, item := range regressBuiltRe.FindAllString(masked, -1) {
+			for _, m := range regressSliceIDRe.FindAllStringSubmatch(item, -1) {
+				// `SLICE-001` and `Slice 1` name the same slice.
+				n, _ := strconv.Atoi(m[1])
+				id := fmt.Sprintf("SLICE-%03d", n)
+				if !slices.Contains(fp.DoneSlices, id) {
+					fp.DoneSlices = append(fp.DoneSlices, id)
+				}
+			}
+		}
+	}
 
 	raw, err := os.ReadFile(filepath.Join(workspace, acceptance.GatesFile)) // #nosec G304 -- workspace artifact
 	note(acceptance.GatesFile, err)