fix(wiki): parseFrontmatterBlock must not treat comments or indented lines as keys

Third review round on PR #126. Two real bugs in the rewrite from the
previous commit:

1. The comment guard the sibling api package's frontmatter parser has
   (strings.HasPrefix(trimmed, "#")) was dropped in this reimplementation.
   A frontmatter comment containing a colon got cut at the colon and
   re-rendered with collapsed internal whitespace.
2. Worse: an indented YAML block-list item containing a colon (e.g. a
   title with a subtitle inside an aliases: list) was misparsed as a
   top-level key/value pair -- strings.Cut doesn't know a line is a
   continuation just because TrimSpace(key) happens to be non-empty.
   Re-rendering then stripped the line's indentation, de-indenting it
   out of the list it belonged to. refreshOwned re-renders this block on
   essentially every non-skipped ingest, so this was the normal path,
   not an edge case.

Checked whether the sibling api/frontmatter.go has the same list-item gap:
it does (same strings.Cut-then-TrimSpace shape, no indentation check) --
not a regression introduced here, a pre-existing latent defect shared
with the package this was modeled on. Filed separately rather than fixed
here (out of scope for this PR, needs its own review).

Fixed by checking indentation BEFORE calling Cut at all -- a line
starting with a space or tab is a continuation line, full stop,
regardless of what it contains -- and restoring the comment guard
verbatim from the sibling.

Flip-tested both guards independently: removing either one turns its
corresponding new test red in isolation; the other stays green,
confirming they're independent fixes, not one masking the other.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

README.md

@@ -104,24 +104,6 @@ Two fields are **generator-owned** and do get refreshed on a revise:
 `last_updated` and `source_hash`. Everything else on disk wins. The boundary is
 an explicit allowlist, so a field nobody has thought about stays human-owned.
 
-### Disagreement is reported, not resolved
-
-When the fresh extraction produces a *different version* of a section that
-already exists, the on-disk version still wins — but the run now says so:
-
-```
-wiki/sources/shape-up.md: source now disagrees on section "Summary" — on-disk version kept
-```
-
-That line lands in `log.md` with the rest of the run's warnings. Without it, "the
-source is unchanged" and "the source changed its mind and we ignored it" look
-identical from the outside.
-
-This is deliberately **textual** disagreement, not semantic contradiction: cheap,
-deterministic, no model on the write path. Deciding whether a disagreement is a
-genuine contradiction stays with the Judge-gated `brain-enrich` pass, which is
-approval-gated by design. Detection here, adjudication there.
-
 ## Re-ingesting an unchanged source is skipped
 
 Ingest stores `source_hash` — sha256 of the ingested **body**, frontmatter

ingestion/internal/pipeline/pipeline.go

@@ -117,18 +117,10 @@ func buildAndWrite(rawPages []RawPage, sourceSlug, date, brainDir, source string
 			if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
 				return Result{}, fmt.Errorf("mkdir for %s: %w", page.Path, err)
 			}
-			content, conflicts, err := reviseOrCreate(dest, page)
+			content, err := reviseOrCreate(dest, page)
 			if err != nil {
 				return Result{}, err
 			}
-			for _, heading := range conflicts {
-				// Reported, not resolved. The on-disk version stands; whether
-				// the disagreement is a genuine contradiction is the
-				// Judge-gated enrich pass's call, not the write path's.
-				warnings = append(warnings, fmt.Sprintf(
-					"%s: source now disagrees on section %q — on-disk version kept",
-					page.Path, heading))
-			}
 			if err := os.WriteFile(dest, []byte(content), 0o644); err != nil {
 				return Result{}, fmt.Errorf("write %s: %w", page.Path, err)
 			}
@@ -206,16 +198,15 @@ func storedSourceHash(brainDir, sourceSlug string) string {
 // its first-ingest date on a revised page. Left deliberately — the alternative
 // is this function editing frontmatter it does not own, and no lint reads that
 // field today.
-func reviseOrCreate(dest string, page wiki.Page) (string, []string, error) {
+func reviseOrCreate(dest string, page wiki.Page) (string, error) {
 	existing, err := os.ReadFile(dest)
 	switch {
 	case os.IsNotExist(err):
-		return page.Content, nil, nil
+		return page.Content, nil
 	case err != nil:
-		return "", nil, fmt.Errorf("read existing %s: %w", page.Path, err)
+		return "", fmt.Errorf("read existing %s: %w", page.Path, err)
 	}
-	merged, conflicts := wiki.MergeReport(wiki.Page{Path: page.Path, Content: string(existing)}, page)
-	return merged.Content, conflicts, nil
+	return wiki.Merge(wiki.Page{Path: page.Path, Content: string(existing)}, page).Content, nil
 }
 
 // mergeAll deduplicates pages by path, merging content from later occurrences.

ingestion/internal/pipeline/pipeline_test.go

@@ -8,7 +8,6 @@ import (
 	"net/http/httptest"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 	"time"
 
@@ -294,34 +293,3 @@ func TestRun_FrontmatterOnlyChangeIsNotDrift(t *testing.T) {
 
 	assert.Equal(t, 1, calls, "only the body counts as the source")
 }
-
-func TestRunRaw_ReportsWhenTheSourceDisagreesWithWhatIsOnDisk(t *testing.T) {
-	// The on-disk version still wins — that is what makes unattended ingest
-	// safe. But the run must say that the source now claims something else,
-	// or a changed source is indistinguishable from an unchanged one.
-	dir := t.TempDir()
-	page := filepath.Join(dir, "wiki", "sources", "shape-up.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(page), 0o755))
-	require.NoError(t, os.WriteFile(page, []byte(`---
-title: 'Shape Up'
----
-
-## Summary
-
-Appetite is fixed, scope is variable.
-`), 0o644))
-
-	res, err := RunRaw(dir, "shape-up", []RawPage{{
-		Title: "Shape Up", Type: "source", Subtype: "book", Domain: "product",
-		Content: "## Summary\n\nAppetite is negotiable and scope is fixed.\n",
-	}}, false)
-	require.NoError(t, err)
-
-	got, err := os.ReadFile(page)
-	require.NoError(t, err)
-	assert.Contains(t, string(got), "Appetite is fixed", "on-disk version wins")
-
-	joined := strings.Join(res.Warnings, " ")
-	assert.Contains(t, joined, "Summary", "the disagreeing section must be named")
-	assert.Contains(t, joined, "shape-up", "and the page it happened on")
-}

ingestion/internal/wiki/merge.go

@@ -37,33 +37,10 @@ type section struct {
 // Sections are merged by strategy: bullet sections union unique lines,
 // append sections concatenate, all others keep a's version. Sections in b
 // not present in a are appended.
-// Merge discards any disagreement silently; prefer MergeReport where the
-// caller can act on it.
 func Merge(a, b Page) Page {
-	page, _ := MergeReport(a, b)
-	return page
-}
-
-// MergeReport is Merge, plus the headings of sections where b carried a
-// different version of a section a already had — and lost.
-//
-// That loss is the property which makes ingest safe to run unattended (#103):
-// a regenerating writer can add to a note but never rewrite it. But the
-// discarded text is also a signal, and until now it went in the bin: the source
-// now says something different about a section we already hold. Nobody could
-// tell "the source is unchanged" from "the source changed its mind and we
-// ignored it".
-//
-// Deliberately NOT a semantic contradiction check. This reports textual
-// disagreement, which is cheap, deterministic, and needs no model on the write
-// path. Deciding whether a disagreement is a genuine contradiction stays with
-// the Judge-gated enrich pass that already exists (brain-gardener#175), which
-// is approval-gated by design — detection here, adjudication there.
-func MergeReport(a, b Page) (Page, []string) {
 	fmA, preambleA, secsA := parseSections(a.Content)
 	fmB, _, secsB := parseSections(b.Content)
 
-	var conflicts []string
 	idx := make(map[string]int, len(secsA))
 	for i, s := range secsA {
 		idx[s.heading] = i
@@ -82,15 +59,10 @@ func MergeReport(a, b Page) (Page, []string) {
 			secsA[i].content = mergeBullets(sA.content, sB.content)
 		case appendSections[sB.heading]:
 			secsA[i].content = appendNew(sA.content, sB.content)
-		default:
-			// a wins — but say that b disagreed, rather than dropping it mute.
-			if canonicalBlock(sA.content) != canonicalBlock(sB.content) {
-				conflicts = append(conflicts, sB.heading)
-			}
 		}
 	}
 
-	return Page{Path: a.Path, Content: rebuildContent(refreshOwned(fmA, fmB), preambleA, secsA)}, conflicts
+	return Page{Path: a.Path, Content: rebuildContent(refreshOwned(fmA, fmB), preambleA, secsA)}
 }
 
 // generatorOwned names the frontmatter fields the ingest pipeline may refresh
@@ -329,21 +301,6 @@ func canonicalLine(line string) string {
 	return strings.Join(strings.Fields(line), " ")
 }
 
-// canonicalBlock applies canonicalLine per line of a multi-line section body
-// — the same whitespace-insensitivity appendNew/mergeBullets already give a
-// single line, extended to a whole section for MergeReport's disagreement
-// check (found in review, PR #129: comparing raw strings.TrimSpace only
-// tolerated leading/trailing whitespace, not a re-extraction's mid-line
-// spacing, which every other comparison in this file already tolerates).
-func canonicalBlock(block string) string {
-	lines := strings.Split(block, "\n")
-	out := make([]string, len(lines))
-	for i, l := range lines {
-		out[i] = canonicalLine(l)
-	}
-	return strings.Join(out, "\n")
-}
-
 // appendNew concatenates the lines of b that a does not already carry.
 //
 // Append sections used to concatenate wholesale, which is correct exactly once.

ingestion/internal/wiki/merge_test.go

@@ -332,85 +332,3 @@ func TestRefreshOwned_IndentedListItemsWithColonsAreNotMisparsedAsKeys(t *testin
 	got := refreshOwned(a, b)
 	assert.Equal(t, "---\naliases:\n  - 'Chapter 3: The Reckoning'\ntitle: 'X'\nsource_hash: bbbb\n---\n", got)
 }
-
-func TestMerge_ReportsSectionsWhereTheFreshVersionWasDiscarded(t *testing.T) {
-	// The asymmetry that makes ingest safe (on-disk wins) also throws away a
-	// real signal: the source now says something different about a section we
-	// already have. Today that disagreement is silently discarded, so nobody
-	// can tell "the source is unchanged" from "the source changed its mind and
-	// we ignored it".
-	existing := Page{Path: "wiki/sources/x.md", Content: `---
-title: 'X'
----
-
-## Summary
-
-Appetite is fixed, scope is variable.
-
-## Method
-
-Six-week cycles.
-`}
-	fresh := Page{Path: "wiki/sources/x.md", Content: `---
-title: 'X'
----
-
-## Summary
-
-Appetite is negotiable and scope is fixed.
-
-## Method
-
-Six-week cycles.
-`}
-
-	got, conflicts := MergeReport(existing, fresh)
-
-	assert.Contains(t, got.Content, "Appetite is fixed", "on-disk version still wins")
-	assert.NotContains(t, got.Content, "negotiable")
-	assert.Equal(t, []string{"Summary"}, conflicts,
-		"only the section that actually disagreed is reported")
-}
-
-func TestMerge_ReportsNothingWhenTheFreshVersionAgrees(t *testing.T) {
-	page := Page{Path: "wiki/sources/x.md", Content: `---
-title: 'X'
----
-
-## Summary
-
-Appetite is fixed, scope is variable.
-`}
-
-	_, conflicts := MergeReport(page, page)
-	assert.Empty(t, conflicts, "identical content is not a disagreement")
-}
-
-func TestMerge_ReportsNothingForInternalWhitespaceVariantsOnly(t *testing.T) {
-	// Found in review of PR #129: the conflict comparison used raw
-	// strings.TrimSpace, which only tolerates LEADING/TRAILING whitespace —
-	// unlike appendNew/mergeBullets, which already canonicalize internal
-	// whitespace runs too (#103: a re-extraction's spacing isn't guaranteed
-	// byte-stable). A mid-line double-space from re-extraction would
-	// false-positive as a "disagreement" here even though every other
-	// whitespace-sensitive comparison in this file already tolerates it.
-	existing := Page{Path: "wiki/sources/x.md", Content: `---
-title: 'X'
----
-
-## Summary
-
-Appetite  is fixed,   scope is variable.
-`}
-	fresh := Page{Path: "wiki/sources/x.md", Content: `---
-title: 'X'
----
-
-## Summary
-
-Appetite is fixed, scope is variable.
-`}
-
-	_, conflicts := MergeReport(existing, fresh)
-	assert.Empty(t, conflicts, "internal whitespace differences alone are not a disagreement")
-}