devrites 6.0.4 → 6.1.0

package/engine/internal/notes/notes_test.go

@@ -1,545 +0,0 @@
-package notes
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/gate"
-)
-
-func writeFile(t *testing.T, root, rel, body string) {
-	t.Helper()
-	path := filepath.Join(root, filepath.FromSlash(rel))
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-const sampleNotes = `# Anchored notes
-
-- NOTE-001: pool cap rationale
-  SUBJECT: src/pool.go
-  QUOTE: maxConns = 4
-  BODY: fairness under bursty saves, not memory
-- NOTE-002: retry window
-  SUBJECT: src/retry.go
-  QUOTE: backoff = 250 * attempts
-`
-
-func TestParseNotesWellFormed(t *testing.T) {
-	doc := ParseNotes(sampleNotes)
-	if len(doc.Errors) != 0 {
-		t.Fatalf("errors: %v", doc.Errors)
-	}
-	if len(doc.Notes) != 2 {
-		t.Fatalf("notes: %d", len(doc.Notes))
-	}
-	n := doc.Notes[0]
-	if n.ID != "NOTE-001" || n.Subject != "src/pool.go" || n.Quote != "maxConns = 4" || n.Body == "" {
-		t.Fatalf("note: %+v", n)
-	}
-}
-
-func TestParseNotesRejectsMalformed(t *testing.T) {
-	for name, text := range map[string]string{
-		"duplicate id":    "- NOTE-001: a\n  SUBJECT: f.go\n  QUOTE: q\n- NOTE-001: b\n  SUBJECT: g.go\n  QUOTE: r\n",
-		"missing subject": "- NOTE-001: a\n  QUOTE: q\n",
-		"missing quote":   "- NOTE-001: a\n  SUBJECT: f.go\n",
-		"unindented attr": "- NOTE-001: a\nSUBJECT: f.go\n  QUOTE: q\n",
-		"orphan attr":     "  SUBJECT: f.go\n",
-		"traversal":       "- NOTE-001: a\n  SUBJECT: ../f.go\n  QUOTE: q\n",
-		"absolute":        "- NOTE-001: a\n  SUBJECT: /etc/passwd\n  QUOTE: q\n",
-		"empty summary":   "- NOTE-001: \n  SUBJECT: f.go\n  QUOTE: q\n",
-		"repeated quote":  "- NOTE-001: a\n  SUBJECT: f.go\n  QUOTE: q\n  QUOTE: r\n",
-	} {
-		t.Run(name, func(t *testing.T) {
-			if doc := ParseNotes(text); len(doc.Errors) == 0 {
-				t.Fatalf("want errors for %q", text)
-			}
-		})
-	}
-}
-
-func TestParseNotesMasksFencedBlocks(t *testing.T) {
-	text := "# Notes\n\n```\n- NOTE-999: fenced fake\n  SUBJECT: x.go\n  QUOTE: y\n```\n\n" + sampleNotes
-	doc := ParseNotes(text)
-	if len(doc.Errors) != 0 || len(doc.Notes) != 2 {
-		t.Fatalf("notes=%d errors=%v", len(doc.Notes), doc.Errors)
-	}
-}
-
-func TestParseNotesMasksListIndentedFences(t *testing.T) {
-	text := "# Notes\n\n- how to write a note\n\n    ```\n    - NOTE-999: fenced fake\n      SUBJECT: x.go\n      QUOTE: y\n    ```\n\n" + sampleNotes
-	doc := ParseNotes(text)
-	if len(doc.Errors) != 0 || len(doc.Notes) != 2 {
-		t.Fatalf("notes=%d errors=%v", len(doc.Notes), doc.Errors)
-	}
-}
-
-func TestOpenBlockingQuestionAfterIndentedCodeStaysVisible(t *testing.T) {
-	for name, text := range map[string]string{
-		"top-level indented code":         "# Q\n\n    - example\n    ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"list indented code":              "- a\n\n      - not a list\n       ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"unclosed list fence":             "- a\n\n    ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"unclosed ordered fence":          "1. step\n\n     ```\n## Q-001\nstatus: open\ngate: blocking\n",
-		"unclosed nested fence":           "- a\n  - b\n\n      ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"thematic break":                  "* * *\n\n    ```\n## Q-001\nstatus: open\ngate: blocking\n",
-		"ordered cannot interrupt":        "text\n2. foo\n\n    ```\n## Q-001\nstatus: open\ngate: blocking\n",
-		"list-indented fence ends":        "- a\n\n    ```\n    ## Q-002\n    ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"empty dash then list fence":      "-\n\n    ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"setext dash then list fence":     "Intro\n-\n\n    ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"empty star then list fence":      "Some text\n*\n\n    ```\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"empty dash then table":           "-\n\n    ```\n  | ID | Status | Gate |\n  |---|---|---|\n  | Q-001 | open | blocking |\n",
-		"unclosed list fence to EOF":      "- a\n\n    ```\n    text\n\n## Q-001\nstatus: open\ngate: blocking\n",
-		"list fence dedents before close": "- a\n\n    ```\n    text\nback\n    ```\n## Q-001\nstatus: open\ngate: blocking\n",
-		"tab-indented closer then table":  "- a\n\n    ```\n\t```\n  | ID | Status | Gate |\n  |---|---|---|\n  | Q-001 | open | blocking |\n    ```\n",
-	} {
-		t.Run(name, func(t *testing.T) {
-			if got := gate.OpenBlockingQuestionGates([]byte(text)); len(got) != 1 || got[0] != "blocking" {
-				t.Fatalf("OpenBlockingQuestionGates = %v, want [blocking]", got)
-			}
-		})
-	}
-}
-
-func TestGradeExactMovedStaleAmbiguousLost(t *testing.T) {
-	project := t.TempDir()
-	writeFile(t, project, "src/pool.go", "package src\n\nconst maxConns = 4\n")
-	writeFile(t, project, "src/retry.go", "package src\n\nvar backoff = 250 * attempts\n")
-
-	doc := ParseNotes(sampleNotes)
-	graded := GradeAll(project, doc)
-	if graded[0].Grade != GradeExact || graded[1].Grade != GradeExact {
-		t.Fatalf("grades: %v %v", graded[0].Grade, graded[1].Grade)
-	}
-
-	// moved: quote relocates to exactly one other file
-	writeFile(t, project, "src/pool.go", "package src\n\nconst maxConns = 8\n")
-	writeFile(t, project, "src/config/limits.go", "package config\nconst maxConns = 4\n")
-	graded = GradeAll(project, doc)
-	if graded[0].Grade != GradeMoved || graded[0].MovedTo != "src/config/limits.go" {
-		t.Fatalf("moved: %+v", graded[0])
-	}
-
-	// ambiguous: quote in two other files
-	writeFile(t, project, "src/config/other.go", "package config\nconst maxConns = 4\n")
-	graded = GradeAll(project, doc)
-	if graded[0].Grade != GradeAmbiguous {
-		t.Fatalf("ambiguous: %+v", graded[0])
-	}
-
-	// stale: subject alive, quote gone everywhere
-	writeFile(t, project, "src/config/other.go", "package config\nconst other = 1\n")
-	writeFile(t, project, "src/config/limits.go", "package config\nconst other = 2\n")
-	graded = GradeAll(project, doc)
-	if graded[0].Grade != GradeStale {
-		t.Fatalf("stale: %+v", graded[0])
-	}
-
-	// lost: subject file deleted entirely
-	if err := os.Remove(filepath.Join(project, "src/pool.go")); err != nil {
-		t.Fatal(err)
-	}
-	graded = GradeAll(project, doc)
-	if graded[0].Grade != GradeLost {
-		t.Fatalf("lost: %+v", graded[0])
-	}
-}
-
-func TestGradeSkipsDependencyAndWorkspaceDirs(t *testing.T) {
-	project := t.TempDir()
-	writeFile(t, project, "src/a.go", "package src\nvar other = 1\n")
-	writeFile(t, project, "node_modules/dep/index.js", "var depAnchor = 1\n")
-	writeFile(t, project, ".devrites/work/f/notes.md", "depAnchor = 1\n")
-	doc := ParseNotes("- NOTE-001: x\n  SUBJECT: src/missing.go\n  QUOTE: depAnchor = 1\n")
-	graded := GradeAll(project, doc)
-	if graded[0].Grade != GradeLost {
-		t.Fatalf("dependency dirs must not count as relocation: %+v", graded[0])
-	}
-}
-
-func TestGradeNormalizesWhitespace(t *testing.T) {
-	project := t.TempDir()
-	writeFile(t, project, "src/a.go", "package src\n\n\tvar   anchor\t=\t1\n")
-	doc := ParseNotes("- NOTE-001: x\n  SUBJECT: src/a.go\n  QUOTE: var anchor = 1\n")
-	if g := GradeAll(project, doc)[0]; g.Grade != GradeExact {
-		t.Fatalf("whitespace-normalized match: %+v", g)
-	}
-}
-
-func TestNextIDFillsLowest(t *testing.T) {
-	doc := ParseNotes("- NOTE-001: a\n  SUBJECT: f\n  QUOTE: q\n- NOTE-003: b\n  SUBJECT: g\n  QUOTE: r\n")
-	if got := doc.NextID(); got != "NOTE-004" {
-		t.Fatalf("NextID = %q", got)
-	}
-}
-
-func TestRenderAndRemoveRoundTrip(t *testing.T) {
-	text := Render("", "\n", "NOTE-001", "first", "a.go", "q1", "body")
-	text = Render(text, "\n", "NOTE-002", "second", "b.go", "q2", "")
-	doc := ParseNotes(text)
-	if len(doc.Errors) != 0 || len(doc.Notes) != 2 {
-		t.Fatalf("render parse: %v / %d", doc.Errors, len(doc.Notes))
-	}
-	removed := RemoveEntry(text, "\n", doc.Notes[0])
-	doc = ParseNotes(removed)
-	if len(doc.Notes) != 1 || doc.Notes[0].ID != "NOTE-002" {
-		t.Fatalf("after remove: %+v", doc.Notes)
-	}
-	if strings.Contains(removed, "NOTE-001") {
-		t.Fatal("removed text still carries NOTE-001")
-	}
-}
-
-func TestRepairSubjectRewritesOnlyThatLine(t *testing.T) {
-	doc := ParseNotes(sampleNotes)
-	note := doc.Notes[0]
-	out := RepairSubject(sampleNotes, "\n", note, "src/new/pool.go")
-	if !strings.Contains(out, "  SUBJECT: src/new/pool.go") {
-		t.Fatalf("repair out: %q", out)
-	}
-	if !strings.Contains(out, "SUBJECT: src/retry.go") {
-		t.Fatal("repair touched the other note")
-	}
-}
-
-// anchorQuote is the verbatim quote every subject in the cases below still
-// carries, so a decline to read the file is the only reason a note is not exact.
-const anchorQuote = "maxConns = 4"
-
-// writeOversizedQuoteSubject grows path past the read cap while keeping the
-// anchor quote.
-func writeOversizedQuoteSubject(t *testing.T, path string) {
-	t.Helper()
-	filler := strings.Repeat("padding line past the read cap\n", maxSearchFileBytes/28+1)
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte("package src\n\nconst "+anchorQuote+"\n"+filler), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	info, err := os.Stat(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if info.Size() <= int64(maxSearchFileBytes) {
-		t.Fatalf("oversized subject is %d bytes, not past the %d-byte read cap", info.Size(), maxSearchFileBytes)
-	}
-}
-
-// unreadableSubjects are the ways a subject this pass will not read as text can
-// still contain the quote. Each degrades an existing, quote-bearing subject.
-var unreadableSubjects = map[string]func(t *testing.T, path string){
-	"permission denied": func(t *testing.T, path string) {
-		if err := os.Chmod(path, 0o000); err != nil {
-			t.Fatal(err)
-		}
-		t.Cleanup(func() { _ = os.Chmod(path, 0o644) })
-		if _, err := os.ReadFile(path); err == nil {
-			t.Skip("chmod 000 does not deny reads for this process; the permission decline is not exercised here")
-		}
-	},
-	"nul prefixed": func(t *testing.T, path string) {
-		if err := os.WriteFile(path, []byte("\x00package src\n\nconst "+anchorQuote+"\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	},
-}
-
-// subjectProject builds a project whose quote-bearing subject this pass will
-// decline, next to one unrelated file carrying the same quote. That second
-// file is the trap: only a wrongly-run relocation scan would name it.
-func subjectProject(t *testing.T, degrade func(t *testing.T, path string)) string {
-	t.Helper()
-	project := t.TempDir()
-	writeFile(t, project, "src/pool.go", "package src\n\nconst "+anchorQuote+"\n")
-	writeFile(t, project, "other/unrelated.txt", "unrelated prose repeating "+anchorQuote+" verbatim\n")
-	degrade(t, filepath.Join(project, "src", "pool.go"))
-	return project
-}
-
-func anchorNotes() string {
-	return Render("", "\n", "NOTE-001", "pool cap rationale", "src/pool.go", anchorQuote, "")
-}
-
-// A subject this pass declines to read is not evidence that the quote moved.
-// The assertion is the negative, not the silence: no moved grade, no
-// relocation target, and repairMoved returns the artifact byte-identical.
-func TestUnreadableSubjectIsNotRelocatedOrRewritten(t *testing.T) {
-	for name, degrade := range unreadableSubjects {
-		t.Run(name, func(t *testing.T) {
-			project := subjectProject(t, degrade)
-
-			notesText := anchorNotes()
-			doc := ParseNotes(notesText)
-			if len(doc.Errors) != 0 {
-				t.Fatalf("parse: %v", doc.Errors)
-			}
-			graded := GradeAll(project, doc)
-			if graded[0].Grade == GradeExact {
-				t.Fatalf("declined subject graded exact without being read: %+v", graded[0])
-			}
-			if graded[0].Grade == GradeMoved {
-				t.Fatalf("declined subject graded moved -> %q", graded[0].MovedTo)
-			}
-			if graded[0].MovedTo != "" {
-				t.Fatalf("declined subject carries a relocation target: %q", graded[0].MovedTo)
-			}
-
-			repaired, repairedText := repairMoved(notesText, doc, graded)
-			if repaired != 0 {
-				t.Fatalf("repairMoved rewrote %d note(s) it did not positively determine moved", repaired)
-			}
-			if repairedText != notesText {
-				t.Fatalf("repairMoved changed the artifact:\n got %q\nwant %q", repairedText, notesText)
-			}
-		})
-	}
-}
-
-// cmdAdd re-verifies the quote against the subject before writing. It must
-// refuse a subject the pass will not read as text, so a note can never be
-// created against one.
-func TestAddRefusesSubjectItCannotReadAsText(t *testing.T) {
-	project := t.TempDir()
-	root := filepath.Join(project, ".devrites")
-	work := filepath.Join(root, "work", "feat")
-	if err := os.MkdirAll(work, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	writeFile(t, project, "src/pool.go", "\x00package src\n\nconst "+anchorQuote+"\n")
-
-	t.Setenv("DEVRITES_WORKSPACE", "")
-	var stdout, stderr bytes.Buffer
-	if code := cmdAdd(root, []string{"feat", "src/pool.go", anchorQuote, "pool cap rationale"},
-		&stdout, &stderr); code != ExitBlocked {
-		t.Fatalf("note add exit = %d, want %d for an unreadable subject:\n%s%s",
-			code, ExitBlocked, stdout.String(), stderr.String())
-	}
-	if _, err := os.Stat(filepath.Join(work, NotesFile)); err == nil {
-		t.Fatal("note add wrote notes.md for a subject it could not read")
-	}
-}
-
-// A subject past the read cap that still carries the quote anchors exactly. The
-// cap bounds relocation scanning, not whether a note can be anchored at all.
-func TestOversizedSubjectWithQuoteGradesExactAndAnchors(t *testing.T) {
-	project := t.TempDir()
-	writeFile(t, project, "other/unrelated.txt", "unrelated prose repeating "+anchorQuote+" verbatim\n")
-	writeOversizedQuoteSubject(t, filepath.Join(project, "src", "pool.go"))
-
-	doc := ParseNotes(anchorNotes())
-	graded := GradeAll(project, doc)
-	if graded[0].Grade != GradeExact || graded[0].MovedTo != "" || graded[0].Detail != "" {
-		t.Fatalf("oversized quote-bearing subject = %+v, want exact", graded[0])
-	}
-
-	root := filepath.Join(project, ".devrites")
-	work := filepath.Join(root, "work", "feat")
-	if err := os.MkdirAll(work, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	t.Setenv("DEVRITES_WORKSPACE", "")
-	var stdout, stderr bytes.Buffer
-	if code := cmdAdd(root, []string{"feat", "src/pool.go", anchorQuote, "pool cap rationale"},
-		&stdout, &stderr); code != ExitOK {
-		t.Fatalf("note add exit = %d, want %d for an oversized subject carrying the quote:\n%s%s",
-			code, ExitOK, stdout.String(), stderr.String())
-	}
-	stdout.Reset()
-	if code := cmdCheck(root, []string{"feat"}, &stdout, &stderr); code != ExitOK {
-		t.Fatalf("note check exit = %d, want %d:\n%s%s", code, ExitOK, stdout.String(), stderr.String())
-	}
-}
-
-// An oversized subject that has lost the quote is read to the end and graded on
-// what it holds, so the relocation scan may then name the single other home.
-func TestOversizedSubjectWithoutQuoteIsRegradedFromItsContent(t *testing.T) {
-	project := t.TempDir()
-	writeFile(t, project, "other/unrelated.txt", "unrelated prose repeating "+anchorQuote+" verbatim\n")
-	subject := filepath.Join(project, "src", "pool.go")
-	writeOversizedQuoteSubject(t, subject)
-	if err := os.WriteFile(subject, bytes.ReplaceAll(mustRead(t, subject), []byte(anchorQuote), []byte("maxConns = 8")), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	graded := GradeAll(project, ParseNotes(anchorNotes()))
-	if graded[0].Grade != GradeMoved || graded[0].MovedTo != "other/unrelated.txt" {
-		t.Fatalf("oversized subject without the quote = %+v, want moved -> other/unrelated.txt", graded[0])
-	}
-}
-
-func mustRead(t *testing.T, path string) []byte {
-	t.Helper()
-	b, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return b
-}
-
-// The quote is matched after whitespace normalization, so it must be found when
-// the raw whitespace around and inside it straddles any internal read boundary.
-func TestSubjectQuoteFoundAcrossReadBoundaries(t *testing.T) {
-	for _, pad := range []int{0, 1, 4095, 4096, 4097, 32764, 32766, 32767, 32768, 32769, 32770, 65520, 65530, 65533, 65534, 65535, 65536, 65537, 131070, 131072} {
-		for _, sp := range []string{" ", "\n\t ", "\u00a0\u2003"} {
-			project := t.TempDir()
-			body := strings.Repeat("\n", pad) + "const maxConns" + sp + "=" + sp + "4" + sp + "tail\n"
-			writeFile(t, project, "src/pool.go", body)
-			if g := GradeNote(project, &Note{Subject: "src/pool.go", Quote: anchorQuote}); g.Grade != GradeExact {
-				t.Fatalf("pad %d spacing %q graded %+v, want exact", pad, sp, g)
-			}
-			writeFile(t, project, "src/pool.go", strings.Repeat("\n", pad)+"const maxConns"+sp+"=")
-			if g := GradeNote(project, &Note{Subject: "src/pool.go", Quote: anchorQuote}); g.Grade == GradeExact {
-				t.Fatalf("pad %d spacing %q graded exact for a truncated quote", pad, sp)
-			}
-		}
-	}
-}
-
-// The rewrite is the harm, so the CLI oracle is a byte comparison of notes.md
-// across `note check --repair`, not a line-count or a "no false positive".
-func TestCheckRepairLeavesNotesByteIdenticalWhenSubjectUnreadable(t *testing.T) {
-	for name, degrade := range unreadableSubjects {
-		t.Run(name, func(t *testing.T) {
-			project := t.TempDir()
-			subjectPath := filepath.Join(project, "src", "pool.go")
-			writeFile(t, project, "src/pool.go", "package src\n\nconst "+anchorQuote+"\n")
-			writeFile(t, project, "other/unrelated.txt", "unrelated prose repeating "+anchorQuote+" verbatim\n")
-			root := filepath.Join(project, ".devrites")
-			work := filepath.Join(root, "work", "feat")
-			if err := os.MkdirAll(work, 0o755); err != nil {
-				t.Fatal(err)
-			}
-			notesPath := filepath.Join(work, NotesFile)
-			if err := os.WriteFile(notesPath, []byte(anchorNotes()), 0o644); err != nil {
-				t.Fatal(err)
-			}
-			degrade(t, subjectPath)
-
-			before, err := os.ReadFile(notesPath)
-			if err != nil {
-				t.Fatal(err)
-			}
-			t.Setenv("DEVRITES_WORKSPACE", "")
-			var stdout, stderr bytes.Buffer
-			code := cmdCheck(root, []string{"feat", "--repair"}, &stdout, &stderr)
-
-			// Check the rewrite first: re-pointing the anchor, even to a
-			// correct location, is itself the harm for a subject that was not read.
-			after, err := os.ReadFile(notesPath)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if !bytes.Equal(before, after) {
-				t.Fatalf("notes.md was rewritten in place:\nbefore %q\nafter  %q", before, after)
-			}
-			if code == ExitOK {
-				t.Fatalf("note check --repair exited 0 for a subject it never read:\n%s%s", stdout.String(), stderr.String())
-			}
-			if !strings.Contains(stdout.String(), "result: drifted") {
-				t.Fatalf("want a drifted result, got:\n%s", stdout.String())
-			}
-			for _, line := range strings.Split(stdout.String(), "\n") {
-				if strings.HasPrefix(line, "note: NOTE-001 moved") {
-					t.Fatalf("reported a relocation the scan was never entitled to run: %q\n%s", line, stdout.String())
-				}
-			}
-		})
-	}
-}
-
-// A relocation scan that could not enter part of the tree has not seen every
-// candidate, so a single hit among the readable files is not a unique location.
-func TestPartialScanDoesNotGradeSingleHitMoved(t *testing.T) {
-	project := t.TempDir()
-	writeFile(t, project, "visible/a.txt", "prose repeating "+anchorQuote+" verbatim\n")
-	writeFile(t, project, "hidden/b.txt", "prose repeating "+anchorQuote+" verbatim\n")
-	hidden := filepath.Join(project, "hidden")
-	if err := os.Chmod(hidden, 0o000); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = os.Chmod(hidden, 0o755) })
-	if _, err := os.ReadDir(hidden); err == nil {
-		t.Skip("chmod 000 does not deny directory reads for this process")
-	}
-	root := filepath.Join(project, ".devrites")
-	work := filepath.Join(root, "work", "feat")
-	if err := os.MkdirAll(work, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	notesPath := filepath.Join(work, NotesFile)
-	if err := os.WriteFile(notesPath, []byte(anchorNotes()), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	doc := ParseNotes(anchorNotes())
-	graded := GradeAll(project, doc)
-	if graded[0].Grade != GradeAmbiguous {
-		t.Fatalf("grade = %s (moved to %q), want %s for a partial scan", graded[0].Grade, graded[0].MovedTo, GradeAmbiguous)
-	}
-
-	before, err := os.ReadFile(notesPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Setenv("DEVRITES_WORKSPACE", "")
-	var stdout, stderr bytes.Buffer
-	cmdCheck(root, []string{"feat", "--repair"}, &stdout, &stderr)
-	after, err := os.ReadFile(notesPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(before, after) {
-		t.Fatalf("notes.md was rewritten from a partial scan:\nbefore %q\nafter  %q", before, after)
-	}
-}
-
-// Several notes whose subjects are gone share one repository walk: each
-// candidate file is read once however many notes are looking for a quote, and
-// every note keeps the grade and location it would get on its own.
-func TestGradeAllReadsEachCandidateOnce(t *testing.T) {
-	project := t.TempDir()
-	writeFile(t, project, "a.txt", "alpha quote one lives here\n")
-	writeFile(t, project, "b.txt", "beta quote two lives here\n")
-	writeFile(t, project, "c.txt", "beta quote two lives here too\n")
-	writeFile(t, project, "d.txt", "nothing relevant\n")
-	doc := ParseNotes(`- NOTE-001: one
-  SUBJECT: gone/one.txt
-  QUOTE: alpha quote one
-- NOTE-002: two
-  SUBJECT: gone/two.txt
-  QUOTE: beta quote two
-- NOTE-003: three
-  SUBJECT: gone/three.txt
-  QUOTE: absent from everywhere
-`)
-	reads := map[string]int{}
-	orig := readCandidate
-	readCandidate = func(path string) fileRead {
-		reads[filepath.Base(path)]++
-		return orig(path)
-	}
-	t.Cleanup(func() { readCandidate = orig })
-
-	graded := GradeAll(project, doc)
-	for name, n := range reads {
-		if n > 1 {
-			t.Errorf("%s read %d times, want at most once", name, n)
-		}
-	}
-	if graded[0].Grade != GradeMoved || graded[0].MovedTo != "a.txt" {
-		t.Errorf("note 1: %+v", graded[0])
-	}
-	if graded[1].Grade != GradeAmbiguous {
-		t.Errorf("note 2: %+v", graded[1])
-	}
-	if graded[2].Grade != GradeLost {
-		t.Errorf("note 3: %+v", graded[2])
-	}
-}