feat(#137): add doc-map input for path-scoped doc injection

- New --doc-map flag (DOC_MAP_FILE env var): path to YAML config mapping
  source path globs to governing design docs
- New --doc-map-max-bytes flag (DOC_MAP_MAX_BYTES env var): cap on total
  injected doc content, default 100KB
- review/docmap.go: DocMapConfig parsing, glob matching with ** support,
  doc loading via VCS with directory expansion and size guard
- budget.Sections: new DesignDocs field, trimmed after conventions
- budget.buildResult: injects DesignDocs under ## Design Documents heading
- action.yml: doc-map and doc-map-max-bytes inputs wired to env vars
- CHANGELOG.md: created with unreleased entry
- Tests: ParseDocMapConfig, MatchDocs, globMatch, LoadMatchingDocs

review/docmap.go

@@ -0,0 +1,303 @@
+// Package review provides doc-map parsing and doc injection for path-scoped
+// design document context in AI code reviews.
+package review
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/goccy/go-yaml"
+)
+
+const (
+	// DefaultDocMapMaxBytes is the default cap on total injected doc content.
+	DefaultDocMapMaxBytes = 100 * 1024 // 100 KB
+)
+
+// DocMapping maps a set of path glob patterns to governing doc files/directories.
+type DocMapping struct {
+	Paths []string `yaml:"paths"` // glob patterns matched against changed PR files
+	Docs  []string `yaml:"docs"`  // doc file paths or directories in the reviewed repo
+}
+
+// DocMapConfig is the top-level structure of a doc-map YAML file.
+type DocMapConfig struct {
+	Mappings []DocMapping `yaml:"mappings"`
+}
+
+// DocMapOptions configures behavior for doc loading.
+type DocMapOptions struct {
+	// MaxBytes caps the total size of injected doc content. Default: DefaultDocMapMaxBytes.
+	MaxBytes int
+}
+
+// DocFetcher reads file and directory content from a VCS repository.
+// It is a subset of vcsClient, defined here to keep the review package free
+// of cmd-level dependencies.
+type DocFetcher interface {
+	// GetFileContent returns the content of a single file at default branch.
+	GetFileContent(ctx context.Context, owner, repo, path string) (string, error)
+	// GetAllFilesInPath returns all files (path → content) under a directory.
+	GetAllFilesInPath(ctx context.Context, owner, repo, path string) (map[string]string, error)
+}
+
+// ParseDocMapConfig reads and parses a doc-map YAML file from a local path.
+// Unknown top-level keys produce a warning but are not fatal.
+func ParseDocMapConfig(localPath string) (*DocMapConfig, error) {
+	data, err := readFileBytes(localPath)
+	if err != nil {
+		return nil, fmt.Errorf("read doc-map file %q: %w", localPath, err)
+	}
+
+	var cfg DocMapConfig
+	if err := yaml.UnmarshalWithOptions(data, &cfg, yaml.Strict()); err != nil {
+		// Re-parse without strict mode to log which keys are unknown.
+		var relaxed DocMapConfig
+		if err2 := yaml.Unmarshal(data, &relaxed); err2 != nil {
+			return nil, fmt.Errorf("parse doc-map YAML %q: %w", localPath, err)
+		}
+		slog.Warn("doc-map YAML contains unknown keys (ignored)", "file", localPath, "error", err)
+		cfg = relaxed
+	}
+	return &cfg, nil
+}
+
+// MatchDocs returns deduplicated doc paths for the given changed file paths.
+// A mapping matches if any of its path globs matches any of the changed files.
+func MatchDocs(cfg *DocMapConfig, changedFiles []string) []string {
+	seen := make(map[string]struct{})
+	var result []string
+
+	for _, mapping := range cfg.Mappings {
+		if len(mapping.Paths) == 0 || len(mapping.Docs) == 0 {
+			continue
+		}
+		if mappingMatches(mapping.Paths, changedFiles) {
+			for _, doc := range mapping.Docs {
+				if doc == "" {
+					continue
+				}
+				if _, ok := seen[doc]; !ok {
+					seen[doc] = struct{}{}
+					result = append(result, doc)
+				}
+			}
+		}
+	}
+	return result
+}
+
+// mappingMatches returns true if any glob in patterns matches any file in files.
+func mappingMatches(patterns, files []string) bool {
+	for _, pat := range patterns {
+		for _, f := range files {
+			if globMatch(pat, f) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// globMatch matches a path against a glob pattern that may contain **.
+// It supports:
+//   - Standard path.Match patterns (*, ?, [range])
+//   - ** as a path segment that matches zero or more segments
+//   - Trailing /** to match a directory and all its contents
+//
+// The pattern and path use forward slash as separator.
+func globMatch(pattern, path string) bool {
+	return globMatchParts(splitPath(pattern), splitPath(path))
+}
+
+// splitPath splits a slash-separated path into non-empty parts.
+func splitPath(p string) []string {
+	// Clean and split on "/"
+	parts := strings.Split(p, "/")
+	result := make([]string, 0, len(parts))
+	for _, part := range parts {
+		if part != "" {
+			result = append(result, part)
+		}
+	}
+	return result
+}
+
+// globMatchParts recursively matches pattern parts against path parts.
+func globMatchParts(patParts, pathParts []string) bool {
+	for len(patParts) > 0 {
+		pat := patParts[0]
+		if pat == "**" {
+			patParts = patParts[1:]
+			if len(patParts) == 0 {
+				// Trailing **: matches any remaining path (including empty).
+				return true
+			}
+			// ** in the middle: try matching the rest at every position.
+			for i := 0; i <= len(pathParts); i++ {
+				if globMatchParts(patParts, pathParts[i:]) {
+					return true
+				}
+			}
+			return false
+		}
+		// Non-** segment: path must have a segment here.
+		if len(pathParts) == 0 {
+			return false
+		}
+		matched, err := filepath.Match(pat, pathParts[0])
+		if err != nil || !matched {
+			return false
+		}
+		patParts = patParts[1:]
+		pathParts = pathParts[1:]
+	}
+	// All pattern parts consumed; path must also be consumed.
+	return len(pathParts) == 0
+}
+
+// LoadMatchingDocs fetches content for the given doc paths via VCS and returns
+// a formatted string suitable for injection into the system prompt.
+//
+// Behavior:
+//   - Paths that look like directories (end with /, or GetAllFilesInPath returns files)
+//     are expanded to all .md files under them.
+//   - Missing files are logged as warnings and skipped.
+//   - Total content is capped at opts.MaxBytes; truncation is noted inline.
+func LoadMatchingDocs(ctx context.Context, fetcher DocFetcher, owner, repo string, docPaths []string, opts DocMapOptions) (string, error) {
+	if opts.MaxBytes <= 0 {
+		opts.MaxBytes = DefaultDocMapMaxBytes
+	}
+
+	var sb strings.Builder
+	totalBytes := 0
+	limitReached := false
+
+	for _, docPath := range docPaths {
+		if ctx.Err() != nil {
+			break
+		}
+		if limitReached {
+			slog.Warn("doc-map: context size limit reached, skipping remaining docs",
+				"remaining_path", docPath, "limit_bytes", opts.MaxBytes)
+			break
+		}
+
+		entries, err := loadDocEntries(ctx, fetcher, owner, repo, docPath)
+		if err != nil {
+			slog.Warn("doc-map: could not load doc, skipping", "path", docPath, "error", err)
+			continue
+		}
+		if len(entries) == 0 {
+			slog.Debug("doc-map: no .md files found under path", "path", docPath)
+			continue
+		}
+
+		for _, entry := range entries {
+			if limitReached {
+				break
+			}
+			available := opts.MaxBytes - totalBytes
+			if available <= 0 {
+				limitReached = true
+				sb.WriteString("\n\n> ⚠️ Design document context truncated — size limit reached.\n")
+				break
+			}
+
+			content := entry.content
+			truncated := false
+			if len(content) > available {
+				content = truncateUTF8(content, available)
+				truncated = true
+				limitReached = true
+			}
+
+			sb.WriteString("### ")
+			sb.WriteString(entry.path)
+			sb.WriteString("\n\n")
+			sb.WriteString(content)
+			sb.WriteString("\n")
+			if truncated {
+				sb.WriteString("\n> ⚠️ (truncated — size limit reached)\n")
+			}
+			totalBytes += len(content)
+			slog.Debug("doc-map: injected doc", "path", entry.path, "bytes", len(content))
+		}
+	}
+
+	if sb.Len() == 0 {
+		return "", nil
+	}
+	return sb.String(), nil
+}
+
+// docEntry holds a single doc file path and content.
+type docEntry struct {
+	path    string
+	content string
+}
+
+// loadDocEntries returns the doc content for a given path.
+// If the path is a directory, all .md files under it are returned.
+// If it's a file, a single entry is returned.
+func loadDocEntries(ctx context.Context, fetcher DocFetcher, owner, repo, docPath string) ([]docEntry, error) {
+	// Try directory expansion first.
+	files, err := fetcher.GetAllFilesInPath(ctx, owner, repo, docPath)
+	if err == nil && len(files) > 0 {
+		// Filter for .md files only.
+		var entries []docEntry
+		for path, content := range files {
+			if isMDFile(path) {
+				entries = append(entries, docEntry{path: path, content: content})
+			}
+		}
+		// Sort for deterministic output.
+		sortDocEntries(entries)
+		return entries, nil
+	}
+
+	// Try as a single file.
+	content, fileErr := fetcher.GetFileContent(ctx, owner, repo, docPath)
+	if fileErr != nil {
+		// Return the file error (more specific than directory error).
+		return nil, fmt.Errorf("fetch doc %q: %w", docPath, fileErr)
+	}
+	return []docEntry{{path: docPath, content: content}}, nil
+}
+
+// isMDFile returns true if the file has a .md extension.
+func isMDFile(path string) bool {
+	return strings.HasSuffix(strings.ToLower(path), ".md")
+}
+
+// sortDocEntries sorts entries by path for deterministic output.
+func sortDocEntries(entries []docEntry) {
+	// Simple insertion sort (doc lists are small).
+	for i := 1; i < len(entries); i++ {
+		for j := i; j > 0 && entries[j].path < entries[j-1].path; j-- {
+			entries[j], entries[j-1] = entries[j-1], entries[j]
+		}
+	}
+}
+
+// readFileBytes reads the contents of a local file.
+func readFileBytes(path string) ([]byte, error) {
+	return os.ReadFile(path)
+}
+
+// truncateUTF8 truncates s to at most maxBytes without splitting multi-byte
+// UTF-8 characters. Returns a valid UTF-8 string of at most maxBytes bytes.
+func truncateUTF8(s string, maxBytes int) string {
+	if len(s) <= maxBytes {
+		return s
+	}
+	for maxBytes > 0 && !utf8.RuneStart(s[maxBytes]) {
+		maxBytes--
+	}
+	return s[:maxBytes]
+}

review/docmap_test.go

@@ -0,0 +1,394 @@
+package review
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// fakeDocFetcher is a mock DocFetcher for tests.
+type fakeDocFetcher struct {
+	files map[string]string // path -> content
+	dirs  map[string]map[string]string // dir path -> (file path -> content)
+}
+
+func (f *fakeDocFetcher) GetFileContent(_ context.Context, _, _, path string) (string, error) {
+	if content, ok := f.files[path]; ok {
+		return content, nil
+	}
+	return "", errors.New("file not found: " + path)
+}
+
+func (f *fakeDocFetcher) GetAllFilesInPath(_ context.Context, _, _, path string) (map[string]string, error) {
+	if files, ok := f.dirs[path]; ok {
+		return files, nil
+	}
+	// Return empty (not an error) for unknown directories.
+	return nil, nil
+}
+
+// ============================================================
+// ParseDocMapConfig
+// ============================================================
+
+func TestParseDocMapConfig_Valid(t *testing.T) {
+	yaml := `
+mappings:
+  - paths:
+      - "lib/foo/**"
+    docs:
+      - docs/foo.md
+  - paths:
+      - "lib/bar/**"
+      - "lib/baz.go"
+    docs:
+      - docs/bar.md
+      - docs/shared/
+`
+	f := writeTempYAML(t, yaml)
+	cfg, err := ParseDocMapConfig(f)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(cfg.Mappings) != 2 {
+		t.Fatalf("expected 2 mappings, got %d", len(cfg.Mappings))
+	}
+	if cfg.Mappings[0].Paths[0] != "lib/foo/**" {
+		t.Errorf("unexpected path: %q", cfg.Mappings[0].Paths[0])
+	}
+	if cfg.Mappings[1].Docs[1] != "docs/shared/" {
+		t.Errorf("unexpected doc: %q", cfg.Mappings[1].Docs[1])
+	}
+}
+
+func TestParseDocMapConfig_InvalidYAML(t *testing.T) {
+	f := writeTempYAML(t, "mappings: [{{invalid")
+	_, err := ParseDocMapConfig(f)
+	if err == nil {
+		t.Fatal("expected error for invalid YAML, got nil")
+	}
+}
+
+func TestParseDocMapConfig_EmptyMappings(t *testing.T) {
+	f := writeTempYAML(t, "mappings: []\n")
+	cfg, err := ParseDocMapConfig(f)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(cfg.Mappings) != 0 {
+		t.Errorf("expected 0 mappings, got %d", len(cfg.Mappings))
+	}
+}
+
+func TestParseDocMapConfig_UnknownKeys(t *testing.T) {
+	// Unknown keys should produce a warning but not fail.
+	yaml := `
+mappings:
+  - paths: ["lib/foo/**"]
+    docs: ["docs/foo.md"]
+extra_key: ignored
+`
+	f := writeTempYAML(t, yaml)
+	// Should succeed (lenient parsing).
+	cfg, err := ParseDocMapConfig(f)
+	if err != nil {
+		t.Fatalf("unexpected error for unknown keys: %v", err)
+	}
+	if len(cfg.Mappings) != 1 {
+		t.Errorf("expected 1 mapping, got %d", len(cfg.Mappings))
+	}
+}
+
+func TestParseDocMapConfig_FileNotFound(t *testing.T) {
+	_, err := ParseDocMapConfig("/nonexistent/path/doc-map.yml")
+	if err == nil {
+		t.Fatal("expected error for missing file, got nil")
+	}
+}
+
+// ============================================================
+// MatchDocs
+// ============================================================
+
+func TestMatchDocs_NoMatch(t *testing.T) {
+	cfg := &DocMapConfig{
+		Mappings: []DocMapping{
+			{Paths: []string{"lib/foo/**"}, Docs: []string{"docs/foo.md"}},
+		},
+	}
+	got := MatchDocs(cfg, []string{"lib/bar/baz.go"})
+	if len(got) != 0 {
+		t.Errorf("expected no matches, got %v", got)
+	}
+}
+
+func TestMatchDocs_SingleMatch(t *testing.T) {
+	cfg := &DocMapConfig{
+		Mappings: []DocMapping{
+			{Paths: []string{"lib/foo/**"}, Docs: []string{"docs/foo.md"}},
+		},
+	}
+	got := MatchDocs(cfg, []string{"lib/foo/bar.go"})
+	if len(got) != 1 || got[0] != "docs/foo.md" {
+		t.Errorf("expected [docs/foo.md], got %v", got)
+	}
+}
+
+func TestMatchDocs_MultipleMatchesDeduplicated(t *testing.T) {
+	cfg := &DocMapConfig{
+		Mappings: []DocMapping{
+			{Paths: []string{"lib/foo/**"}, Docs: []string{"docs/shared.md", "docs/foo.md"}},
+			{Paths: []string{"lib/bar/**"}, Docs: []string{"docs/shared.md", "docs/bar.md"}},
+		},
+	}
+	got := MatchDocs(cfg, []string{"lib/foo/a.go", "lib/bar/b.go"})
+	// Both match; docs/shared.md should appear only once.
+	wantSet := map[string]bool{
+		"docs/shared.md": true,
+		"docs/foo.md":    true,
+		"docs/bar.md":    true,
+	}
+	if len(got) != 3 {
+		t.Errorf("expected 3 docs, got %d: %v", len(got), got)
+	}
+	for _, d := range got {
+		if !wantSet[d] {
+			t.Errorf("unexpected doc: %q", d)
+		}
+	}
+}
+
+func TestMatchDocs_EmptyPaths(t *testing.T) {
+	// Mapping with empty paths list should not match anything.
+	cfg := &DocMapConfig{
+		Mappings: []DocMapping{
+			{Paths: []string{}, Docs: []string{"docs/foo.md"}},
+		},
+	}
+	got := MatchDocs(cfg, []string{"lib/foo/bar.go"})
+	if len(got) != 0 {
+		t.Errorf("expected no matches for empty paths, got %v", got)
+	}
+}
+
+func TestMatchDocs_EmptyDocs(t *testing.T) {
+	// Mapping with empty docs list should produce nothing.
+	cfg := &DocMapConfig{
+		Mappings: []DocMapping{
+			{Paths: []string{"lib/foo/**"}, Docs: []string{}},
+		},
+	}
+	got := MatchDocs(cfg, []string{"lib/foo/bar.go"})
+	if len(got) != 0 {
+		t.Errorf("expected no docs for empty docs list, got %v", got)
+	}
+}
+
+func TestMatchDocs_ExactMatch(t *testing.T) {
+	cfg := &DocMapConfig{
+		Mappings: []DocMapping{
+			{Paths: []string{"lib/baz.go"}, Docs: []string{"docs/baz.md"}},
+		},
+	}
+	got := MatchDocs(cfg, []string{"lib/baz.go"})
+	if len(got) != 1 || got[0] != "docs/baz.md" {
+		t.Errorf("expected [docs/baz.md], got %v", got)
+	}
+}
+
+// ============================================================
+// globMatch
+// ============================================================
+
+func TestGlobMatch(t *testing.T) {
+	tests := []struct {
+		name    string
+		pattern string
+		path    string
+		want    bool
+	}{
+		{"exact match", "lib/foo/bar.go", "lib/foo/bar.go", true},
+		{"exact no match", "lib/foo/bar.go", "lib/foo/baz.go", false},
+		{"star wildcard", "lib/foo/*.go", "lib/foo/bar.go", true},
+		{"star no match cross-dir", "lib/foo/*.go", "lib/foo/sub/bar.go", false},
+		{"trailing doublestar", "lib/foo/**", "lib/foo/bar.go", true},
+		{"trailing doublestar nested", "lib/foo/**", "lib/foo/sub/deep/bar.go", true},
+		// Note: trailing ** matches the parent path too; PR file lists contain file paths
+		// (not directories), so this corner case does not arise in practice.
+		{"trailing doublestar matches parent", "lib/foo/**", "lib/foo", true},
+		{"doublestar in middle", "lib/**/bar.go", "lib/foo/sub/bar.go", true},
+		{"doublestar in middle no match", "lib/**/bar.go", "lib/foo/sub/baz.go", false},
+		{"leading doublestar", "**/bar.go", "lib/foo/bar.go", true},
+		{"leading doublestar top-level", "**/bar.go", "bar.go", true},
+		{"question mark", "lib/foo/ba?.go", "lib/foo/bar.go", true},
+		{"question mark no match", "lib/foo/ba?.go", "lib/foo/ba.go", false},
+		{"star matches none in segment", "lib/*/bar.go", "lib/bar.go", false},
+		{"star single segment", "lib/*/bar.go", "lib/foo/bar.go", true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := globMatch(tc.pattern, tc.path)
+			if got != tc.want {
+				t.Errorf("globMatch(%q, %q) = %v, want %v", tc.pattern, tc.path, got, tc.want)
+			}
+		})
+	}
+}
+
+// ============================================================
+// LoadMatchingDocs
+// ============================================================
+
+func TestLoadMatchingDocs_FileInjection(t *testing.T) {
+	fetcher := &fakeDocFetcher{
+		files: map[string]string{
+			"docs/foo.md": "# Foo Design\n\nThis is the foo doc.",
+		},
+	}
+	content, err := LoadMatchingDocs(context.Background(), fetcher, "owner", "repo",
+		[]string{"docs/foo.md"}, DocMapOptions{MaxBytes: DefaultDocMapMaxBytes})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(content, "# Foo Design") {
+		t.Errorf("expected doc content, got: %q", content)
+	}
+	if !strings.Contains(content, "### docs/foo.md") {
+		t.Errorf("expected heading with path, got: %q", content)
+	}
+}
+
+func TestLoadMatchingDocs_MissingFileSkipped(t *testing.T) {
+	fetcher := &fakeDocFetcher{
+		files: map[string]string{
+			"docs/present.md": "present",
+		},
+	}
+	content, err := LoadMatchingDocs(context.Background(), fetcher, "owner", "repo",
+		[]string{"docs/missing.md", "docs/present.md"}, DocMapOptions{MaxBytes: DefaultDocMapMaxBytes})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(content, "present") {
+		t.Errorf("expected present doc content, got: %q", content)
+	}
+	// Missing file should be skipped, not cause a failure.
+}
+
+func TestLoadMatchingDocs_DirectoryExpansion(t *testing.T) {
+	fetcher := &fakeDocFetcher{
+		dirs: map[string]map[string]string{
+			"docs/domain/": {
+				"docs/domain/a.md": "# A",
+				"docs/domain/b.md": "# B",
+				"docs/domain/c.go": "package domain", // should be skipped (not .md)
+			},
+		},
+	}
+	content, err := LoadMatchingDocs(context.Background(), fetcher, "owner", "repo",
+		[]string{"docs/domain/"}, DocMapOptions{MaxBytes: DefaultDocMapMaxBytes})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(content, "# A") {
+		t.Errorf("expected doc A content, got: %q", content)
+	}
+	if !strings.Contains(content, "# B") {
+		t.Errorf("expected doc B content, got: %q", content)
+	}
+	if strings.Contains(content, "package domain") {
+		t.Errorf("non-.md file should not be injected, got: %q", content)
+	}
+}
+
+func TestLoadMatchingDocs_DirectoryNoMDFiles(t *testing.T) {
+	fetcher := &fakeDocFetcher{
+		dirs: map[string]map[string]string{
+			"src/": {
+				"src/main.go": "package main",
+			},
+		},
+	}
+	content, err := LoadMatchingDocs(context.Background(), fetcher, "owner", "repo",
+		[]string{"src/"}, DocMapOptions{MaxBytes: DefaultDocMapMaxBytes})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if content != "" {
+		t.Errorf("expected empty content for dir with no .md files, got: %q", content)
+	}
+}
+
+func TestLoadMatchingDocs_NoMatchingPaths(t *testing.T) {
+	fetcher := &fakeDocFetcher{}
+	content, err := LoadMatchingDocs(context.Background(), fetcher, "owner", "repo",
+		[]string{}, DocMapOptions{MaxBytes: DefaultDocMapMaxBytes})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if content != "" {
+		t.Errorf("expected empty content for no paths, got: %q", content)
+	}
+}
+
+func TestLoadMatchingDocs_ContextSizeGuard(t *testing.T) {
+	bigContent := strings.Repeat("x", 200)
+	fetcher := &fakeDocFetcher{
+		files: map[string]string{
+			"docs/a.md": bigContent,
+			"docs/b.md": bigContent,
+			"docs/c.md": bigContent,
+		},
+	}
+	// Limit to 350 bytes — enough for a.md fully and part of b.md.
+	content, err := LoadMatchingDocs(context.Background(), fetcher, "owner", "repo",
+		[]string{"docs/a.md", "docs/b.md", "docs/c.md"}, DocMapOptions{MaxBytes: 350})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(content) > 600 {
+		t.Errorf("content too large, expected ≤600 bytes total, got %d", len(content))
+	}
+	if !strings.Contains(content, "truncated") {
+		t.Errorf("expected truncation notice, got: %q", content)
+	}
+}
+
+func TestLoadMatchingDocs_Deduplication(t *testing.T) {
+	fetcher := &fakeDocFetcher{
+		files: map[string]string{
+			"docs/shared.md": "shared content",
+		},
+	}
+	// MatchDocs deduplicates before calling LoadMatchingDocs, but test it with
+	// duplicates in input too.
+	content, err := LoadMatchingDocs(context.Background(), fetcher, "owner", "repo",
+		[]string{"docs/shared.md"}, DocMapOptions{MaxBytes: DefaultDocMapMaxBytes})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(content, "shared content") {
+		t.Errorf("expected shared content, got: %q", content)
+	}
+}
+
+// ============================================================
+// Helpers
+// ============================================================
+
+func writeTempYAML(t *testing.T, content string) string {
+	t.Helper()
+	f, err := os.CreateTemp(t.TempDir(), "doc-map-*.yml")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer f.Close()
+	if _, err := f.WriteString(content); err != nil {
+		t.Fatalf("failed to write temp file: %v", err)
+	}
+	return filepath.Clean(f.Name())
+}