plan 50: address Copilot review on PR #154

- resolveCorpus: handle relative f.Path correctly. In CLI runs
  ResolveFiles returns './docs/a.md' while RootDir is absolute, so
  filepath.Rel would fail and the rule quietly fell back to FS-only
  scope. Split rootRelative() out: absolute paths go through Rel,
  relative ones are treated as root-relative, and '..' traversal
  rejects either.
- matchesFilters: match include/exclude globs against both the full
  slash path and basename, matching MDS027's semantics so patterns
  like 'draft.md' work regardless of directory depth.
- README: fix 'Default: enabled' to 'disabled (opt-in via .mdsmith.yml)'.
- Fixtures: drop the self-referential 'appears in ref/source.md'
  wording; neutral phrasing works in both duplicate.md and source.md.
- Tests: add coverage for relative f.Path under absolute RootDir,
  basename-only exclude patterns across directories, and '..'
  traversal falling through to FS scope.

Author: claude

internal/rules/MDS037-duplicated-content/README.md

@@ -11,7 +11,8 @@ Paragraphs should not repeat verbatim across Markdown files.
 - **ID**: MDS037
 - **Name**: `duplicated-content`
 - **Status**: ready
-- **Default**: enabled, include: [], exclude: [], min-chars: 200
+- **Default**: disabled (opt-in via `.mdsmith.yml`);
+  include: [], exclude: [], min-chars: 200
 - **Fixable**: no
 - **Implementation**:
   [source](./)
@@ -91,11 +92,12 @@ wrap: markdown
 ```markdown
 # Duplicate Fixture
 
-This fixture deliberately repeats a distinctive paragraph that also
-appears in ref/source.md, so MDS037 must report a diagnostic pointing
-back at the other file. The wording must cross the default two-hundred
-character threshold and stay unique relative to other rule fixtures so
-nothing else matches by accident.
+A distinctive paragraph appears in this file and in a sibling
+fixture, so MDS037 must flag the match and point at the other
+location. The wording stays above the default two-hundred character
+threshold after normalization. It stays unique relative to the
+other rule fixtures so nothing matches by accident across the test
+suite.
 ```
 
 <?/include?>
@@ -110,11 +112,12 @@ wrap: markdown
 ```markdown
 # Source Fixture
 
-This fixture deliberately repeats a distinctive paragraph that also
-appears in ref/source.md, so MDS037 must report a diagnostic pointing
-back at the other file. The wording must cross the default two-hundred
-character threshold and stay unique relative to other rule fixtures so
-nothing else matches by accident.
+A distinctive paragraph appears in this file and in a sibling
+fixture, so MDS037 must flag the match and point at the other
+location. The wording stays above the default two-hundred character
+threshold after normalization. It stays unique relative to the
+other rule fixtures so nothing matches by accident across the test
+suite.
 ```
 
 <?/include?>

internal/rules/MDS037-duplicated-content/bad/duplicate.md

@@ -6,8 +6,9 @@ diagnostics:
 ---
 # Duplicate Fixture
 
-This fixture deliberately repeats a distinctive paragraph that also
-appears in ref/source.md, so MDS037 must report a diagnostic pointing
-back at the other file. The wording must cross the default two-hundred
-character threshold and stay unique relative to other rule fixtures so
-nothing else matches by accident.
+A distinctive paragraph appears in this file and in a sibling
+fixture, so MDS037 must flag the match and point at the other
+location. The wording stays above the default two-hundred character
+threshold after normalization. It stays unique relative to the
+other rule fixtures so nothing matches by accident across the test
+suite.

internal/rules/MDS037-duplicated-content/bad/ref/source.md

@@ -1,7 +1,8 @@
 # Source Fixture
 
-This fixture deliberately repeats a distinctive paragraph that also
-appears in ref/source.md, so MDS037 must report a diagnostic pointing
-back at the other file. The wording must cross the default two-hundred
-character threshold and stay unique relative to other rule fixtures so
-nothing else matches by accident.
+A distinctive paragraph appears in this file and in a sibling
+fixture, so MDS037 must flag the match and point at the other
+location. The wording stays above the default two-hundred character
+threshold after normalization. It stays unique relative to the
+other rule fixtures so nothing matches by accident across the test
+suite.

internal/rules/duplicatedcontent/rule.go

@@ -206,11 +206,17 @@ func runeLen(s string) int {
 // file within it. RootFS (the project root) is preferred; otherwise the
 // file's own directory is used. The returned selfName is forward-slash,
 // fs.FS-style so it can be compared to fs.WalkDir's path argument.
+//
+// f.Path may be absolute (CLI runs with a discovered root) or relative
+// to the project root (ResolveFiles returns things like "./docs/a.md").
+// Absolute paths go through filepath.Rel; relative paths are cleaned
+// and slashed in place. Either way, a self-path that escapes RootDir
+// (starts with "..") falls through to the FS scope rather than
+// walking the whole project root behind the user's back.
 func resolveCorpus(f *lint.File) (fs.FS, string) {
 	if f.RootFS != nil && f.RootDir != "" {
-		rel, err := filepath.Rel(f.RootDir, f.Path)
-		if err == nil && !strings.HasPrefix(rel, "..") {
-			return f.RootFS, filepath.ToSlash(rel)
+		if selfName, ok := rootRelative(f.RootDir, f.Path); ok {
+			return f.RootFS, selfName
 		}
 	}
 	if f.FS != nil {
@@ -219,6 +225,29 @@ func resolveCorpus(f *lint.File) (fs.FS, string) {
 	return nil, ""
 }
 
+// rootRelative returns path expressed relative to rootDir using forward
+// slashes, or ok=false when path escapes rootDir. Already-relative paths
+// are assumed to be rooted at rootDir and only cleaned; absolute paths
+// go through filepath.Rel.
+func rootRelative(rootDir, path string) (string, bool) {
+	var rel string
+	if filepath.IsAbs(path) {
+		r, err := filepath.Rel(rootDir, path)
+		if err != nil {
+			return "", false
+		}
+		rel = r
+	} else {
+		rel = filepath.Clean(path)
+	}
+	slash := filepath.ToSlash(rel)
+	slash = strings.TrimPrefix(slash, "./")
+	if slash == ".." || strings.HasPrefix(slash, "../") {
+		return "", false
+	}
+	return slash, true
+}
+
 // buildCorpusIndex walks corpus for .md files (excluding selfName) and
 // returns a map from paragraph fingerprint to every occurrence found.
 // Files that can't be read or parsed are silently skipped — this rule is
@@ -282,17 +311,24 @@ func isMarkdownPath(p string) bool {
 	return strings.HasSuffix(strings.ToLower(p), ".md")
 }
 
+// matchesFilters reports whether path is allowed by include/exclude.
+// To stay consistent with MDS027 cross-file-reference-integrity,
+// patterns are matched against both the full forward-slash path and
+// the basename, so `"draft.md"` excludes a file regardless of which
+// directory it sits in.
 func matchesFilters(path string, include, exclude []glob.Glob) bool {
+	slashPath := filepath.ToSlash(path)
+	base := filepath.Base(path)
 	for _, g := range exclude {
-		if g.Match(path) {
+		if g.Match(slashPath) || g.Match(base) {
 			return false
 		}
 	}
 	if len(include) == 0 {
 		return true
 	}
 	for _, g := range include {
-		if g.Match(path) {
+		if g.Match(slashPath) || g.Match(base) {
 			return true
 		}
 	}

internal/rules/duplicatedcontent/rule_test.go

@@ -261,6 +261,85 @@ func TestCheck_ConfigDiagOnBadExcludeGlob(t *testing.T) {
 	assert.Equal(t, lint.Error, diags[0].Severity)
 }
 
+func TestCheck_RootFSWithRelativeFilePath(t *testing.T) {
+	// Mirrors a normal CLI run: RootDir is absolute (from config
+	// discovery) while f.Path is the relative path returned by
+	// ResolveFiles (e.g. "./docs/a.md"). resolveCorpus must use the
+	// RootFS walk rather than silently falling back to the file's
+	// own directory and missing duplicates elsewhere in the tree.
+	dir := t.TempDir()
+	docs := filepath.Join(dir, "docs")
+	guides := filepath.Join(dir, "guides")
+	require.NoError(t, os.MkdirAll(docs, 0o755))
+	require.NoError(t, os.MkdirAll(guides, 0o755))
+
+	p := longParagraph("the quick brown fox jumps over the lazy dog")
+	writeFile(t, filepath.Join(docs, "a.md"), "# A\n\n"+p+"\n")
+	writeFile(t, filepath.Join(guides, "b.md"), "# B\n\n"+p+"\n")
+
+	data, err := os.ReadFile(filepath.Join(docs, "a.md"))
+	require.NoError(t, err)
+	// Relative path, as ResolveFiles would return.
+	relPath := filepath.Join("docs", "a.md")
+	f, err := lint.NewFile(relPath, data)
+	require.NoError(t, err)
+	f.FS = os.DirFS(docs)
+	f.SetRootDir(dir)
+
+	diags := (&Rule{}).Check(f)
+	require.Len(t, diags, 1)
+	assert.Contains(t, diags[0].Message, "guides/b.md",
+		"RootFS walk should have found the duplicate in a different directory")
+}
+
+func TestCheck_RootFSRejectsPathEscapingRoot(t *testing.T) {
+	// A file whose Path sits outside RootDir (via "../" traversal) must
+	// not scan the entire RootFS; resolveCorpus falls through to FS so
+	// the walk stays local.
+	dir := t.TempDir()
+	sub := filepath.Join(dir, "sub")
+	outside := filepath.Join(dir, "outside")
+	require.NoError(t, os.MkdirAll(sub, 0o755))
+	require.NoError(t, os.MkdirAll(outside, 0o755))
+
+	p := longParagraph("the quick brown fox jumps over the lazy dog")
+	// File under a nested RootDir, but its recorded path escapes via
+	// "../outside/dup.md" — which filepath.Rel would also flag.
+	writeFile(t, filepath.Join(outside, "dup.md"), "# Dup\n\n"+p+"\n")
+	writeFile(t, filepath.Join(sub, "peer.md"), "# Peer\n\n"+p+"\n")
+
+	data, err := os.ReadFile(filepath.Join(outside, "dup.md"))
+	require.NoError(t, err)
+	// Relative escape path: "../outside/dup.md" against RootDir=sub.
+	f, err := lint.NewFile(filepath.Join("..", "outside", "dup.md"), data)
+	require.NoError(t, err)
+	f.FS = os.DirFS(outside)
+	f.SetRootDir(sub)
+
+	diags := (&Rule{}).Check(f)
+	// peer.md is under sub/ which is no longer in scope; FS (=outside)
+	// only holds dup.md itself. No duplicates reported.
+	assert.Empty(t, diags)
+}
+
+func TestCheck_BasenameExcludePatternMatchesAcrossDirs(t *testing.T) {
+	// Consistent with MDS027: a basename pattern ("draft.md") excludes
+	// the file regardless of which directory the walker finds it in.
+	dir := t.TempDir()
+	sub := filepath.Join(dir, "nested")
+	require.NoError(t, os.MkdirAll(sub, 0o755))
+
+	p := longParagraph("the quick brown fox jumps over the lazy dog")
+	writeFile(t, filepath.Join(dir, "a.md"), "# A\n\n"+p+"\n")
+	writeFile(t, filepath.Join(sub, "draft.md"), "# Draft\n\n"+p+"\n")
+
+	f := newLintFileWithRoot(t, filepath.Join(dir, "a.md"), dir)
+	r := &Rule{Exclude: []string{"draft.md"}}
+	diags := r.Check(f)
+	assert.Empty(t, diags,
+		"basename-only exclude pattern should hide nested/draft.md")
+}
+
 func TestCheck_FallsBackToFSWhenRootFSMissing(t *testing.T) {
 	dir := t.TempDir()
 	p := longParagraph("the quick brown fox jumps over the lazy dog")