fix(MDS071): read front matter from f.Source before the f.FS re-read

Address Copilot review: a File parsed without front-matter stripping
(e.g. lint.NewFile) keeps the prefix inline in f.Source, so prefer that
in-memory copy over a workspace-FS re-read. This makes required-frontmatter
correct for callers that don't wire f.FS (previously such a file's fields
read as missing) and avoids an unnecessary disk read. Split the fallback
test to cover both the f.Source and f.FS paths; coverage stays at 100%.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012fET55utKej7P3VWhiNnLW

Author: claude

internal/rules/requiredfrontmatter/rule.go

@@ -114,17 +114,23 @@ func (r *Rule) diag(f *lint.File, line int, msg string) lint.Diagnostic {
 }
 
 // docFrontMatter returns the file's parsed top-level front matter, or
-// nil when none is available. It prefers f.FrontMatter, which the
-// engine populates in production. When that is empty — files built via
-// lint.NewFile in unit and fixture tests, or a real file with no front
-// matter — it falls back to reading the file from the workspace FS so a
-// file's own front matter is still visible. An unreadable path yields
-// nil, which Check treats as "every field missing".
+// nil when none is available. It reads, in order: f.FrontMatter (the
+// engine populates it when it strips front matter); f.Source (a File
+// parsed without stripping — e.g. lint.NewFile — keeps the prefix
+// inline, so use that in-memory copy rather than a disk re-read); and
+// finally the file re-read from f.FS (the fixture harness builds a File
+// from an already-stripped body, so the original on disk still carries
+// the front matter). An unreadable path yields nil, which Check treats
+// as "every field missing".
 func (r *Rule) docFrontMatter(f *lint.File) map[string]any {
 	fmBytes := f.FrontMatter
-	if len(fmBytes) == 0 && f.FS != nil && f.Path != "" {
-		if data, err := fs.ReadFile(f.FS, filepath.ToSlash(f.Path)); err == nil {
-			fmBytes, _ = lint.StripFrontMatter(data)
+	if len(fmBytes) == 0 {
+		if prefix, _ := lint.StripFrontMatter(f.Source); len(prefix) > 0 {
+			fmBytes = prefix
+		} else if f.FS != nil && f.Path != "" {
+			if data, err := fs.ReadFile(f.FS, filepath.ToSlash(f.Path)); err == nil {
+				fmBytes, _ = lint.StripFrontMatter(data)
+			}
 		}
 	}
 	body := extractYAMLBody(fmBytes)

internal/rules/requiredfrontmatter/rule_test.go

@@ -119,21 +119,35 @@ func TestCheck_ExcludeReservedFiles(t *testing.T) {
 	assert.Len(t, r.Check(f), 1)
 }
 
-func TestCheck_FSFallbackReadsOwnFrontMatter(t *testing.T) {
-	// When f.FrontMatter is empty (files built via lint.NewFile), the
-	// rule reads the file from f.FS so its own front matter is visible.
-	src := "---\ntype: Playbook\n---\n# Steps\n"
-	f, err := lint.NewFile("play.md", []byte(src))
+func TestCheck_ReadsFrontMatterFromSource(t *testing.T) {
+	// A File parsed without stripping (lint.NewFile) keeps its front
+	// matter in f.Source; the rule reads it with no f.FS wired.
+	r := &Rule{Fields: []string{"type"}}
+	f, err := lint.NewFile("play.md", []byte("---\ntype: Playbook\n---\n# Steps\n"))
+	require.NoError(t, err)
+	assert.Nil(t, r.Check(f))
+
+	f2, err := lint.NewFile("play.md", []byte("---\ntitle: x\n---\n# Steps\n"))
 	require.NoError(t, err)
-	f.FS = fstest.MapFS{"play.md": &fstest.MapFile{Data: []byte(src)}}
+	assert.Len(t, r.Check(f2), 1)
+}
+
+func TestCheck_FSFallbackWhenSourceStripped(t *testing.T) {
+	// The fixture harness builds a File from an already-stripped body, so
+	// f.Source carries no front matter; the rule re-reads the original
+	// from f.FS to see the file's own front matter.
 	r := &Rule{Fields: []string{"type"}}
+	f, err := lint.NewFile("play.md", []byte("# Steps\n"))
+	require.NoError(t, err)
+	f.FS = fstest.MapFS{"play.md": &fstest.MapFile{
+		Data: []byte("---\ntype: Playbook\n---\n# Steps\n")}}
 	assert.Nil(t, r.Check(f))
 
-	// Same file path but the on-disk copy lacks type → flagged.
-	bad := "---\ntitle: x\n---\n# Steps\n"
-	f2, err := lint.NewFile("play.md", []byte(bad))
+	// Same path, but the on-disk copy lacks type → flagged.
+	f2, err := lint.NewFile("play.md", []byte("# Steps\n"))
 	require.NoError(t, err)
-	f2.FS = fstest.MapFS{"play.md": &fstest.MapFile{Data: []byte(bad)}}
+	f2.FS = fstest.MapFS{"play.md": &fstest.MapFile{
+		Data: []byte("---\ntitle: x\n---\n# Steps\n")}}
 	assert.Len(t, r.Check(f2), 1)
 }