feat(pipeline): report when a re-ingest disagrees with the page on disk (#104)

The asymmetry that makes unattended ingest safe (#103) also discarded a
real signal. When a fresh extraction produced a different version of a
section already on disk, the on-disk version won and the model's version
went in the bin without a word — so "the source is unchanged" and "the
source changed its mind and we ignored it" were indistinguishable.

wiki.MergeReport now returns the headings where the incoming version
disagreed and lost, and the ingest run reports them as warnings, which
AppendLog already writes into log.md.

This is the simplified answer to contradiction flagging at ingest. The
issue proposed calling brain-gardener's Judge from the ingest path, which
needs either a shared Go module across two repos or an HTTP service that
does not exist — and puts an LLM call on the write path, where a timeout
must neither fail the ingest nor silently mark nothing as contested.

None of that is necessary to get the signal. The merge already computes
the disagreement; it was throwing it away. Surfacing it costs nothing,
needs no model, no cue-word matcher, no cross-repo dependency, and is
deterministic.

Deliberately textual disagreement, not semantic contradiction. Deciding
whether a disagreement is a genuine contradiction stays with the
Judge-gated enrich pass that already runs hourly and is approval-gated by
design (brain-gardener#175). Detection here, adjudication there.

Merge is kept as a thin wrapper over MergeReport so existing callers are
untouched.

Refs #104, #103, brain-gardener#175, brain#21.

README.md

@@ -104,6 +104,24 @@ 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,10 +117,18 @@ 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, err := reviseOrCreate(dest, page)
+			content, conflicts, 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)
 			}
@@ -198,15 +206,16 @@ 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, error) {
+func reviseOrCreate(dest string, page wiki.Page) (string, []string, error) {
 	existing, err := os.ReadFile(dest)
 	switch {
 	case os.IsNotExist(err):
-		return page.Content, nil
+		return page.Content, nil, nil
 	case err != nil:
-		return "", fmt.Errorf("read existing %s: %w", page.Path, err)
+		return "", nil, fmt.Errorf("read existing %s: %w", page.Path, err)
 	}
-	return wiki.Merge(wiki.Page{Path: page.Path, Content: string(existing)}, page).Content, nil
+	merged, conflicts := wiki.MergeReport(wiki.Page{Path: page.Path, Content: string(existing)}, page)
+	return merged.Content, conflicts, nil
 }
 
 // mergeAll deduplicates pages by path, merging content from later occurrences.

ingestion/internal/pipeline/pipeline_test.go

@@ -8,6 +8,7 @@ import (
 	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
@@ -293,3 +294,34 @@ 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

@@ -3,7 +3,6 @@ package wiki
 
 import (
 	"fmt"
-	"sort"
 	"strings"
 )
 
@@ -37,10 +36,33 @@ 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
@@ -59,10 +81,15 @@ func Merge(a, b Page) Page {
 			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 strings.TrimSpace(sA.content) != strings.TrimSpace(sB.content) {
+				conflicts = append(conflicts, sB.heading)
+			}
 		}
 	}
 
-	return Page{Path: a.Path, Content: rebuildContent(refreshOwned(fmA, fmB), preambleA, secsA)}
+	return Page{Path: a.Path, Content: rebuildContent(refreshOwned(fmA, fmB), preambleA, secsA)}, conflicts
 }
 
 // generatorOwned names the frontmatter fields the ingest pipeline may refresh
@@ -82,131 +109,36 @@ var generatorOwned = map[string]bool{
 	"source_hash":  true,
 }
 
-// fmLine is one line of a frontmatter block: a parsed key/value pair, or a
-// raw line (blank, comment, or anything else that isn't a simple "key:
-// value") kept verbatim. Same shape as api.frontmatter's fmLine — this
-// package doesn't import that one (it's unexported there, and a's/b's
-// frontmatter here always arrives as a string, not a parsed struct), so the
-// small, already-proven set()-appends-if-absent behavior is reproduced
-// locally rather than string-index surgery reinvented per call site.
-type fmLine struct {
-	key, value, raw string
-}
-
-// parseFrontmatterBlock parses a "---\n...\n---\n" fenced block (the shape
-// parseSections produces) into an ordered line list. A block with no
-// opening/closing fence — including the empty string, a page with no
-// frontmatter at all — returns nil, ok=false: there is nothing to update in
-// place, only something to potentially create.
-func parseFrontmatterBlock(block string) (lines []fmLine, ok bool) {
-	if !strings.HasPrefix(block, "---\n") {
-		return nil, false
-	}
-	rest := block[len("---\n"):]
-	end := strings.Index(rest, "\n---\n")
-	if end < 0 {
-		return nil, false
-	}
-	for _, line := range strings.Split(rest[:end], "\n") {
-		// An indented line is a continuation (a YAML block-list item, a
-		// wrapped value) never a top-level key, regardless of whether it
-		// happens to contain a colon — "  - 'Chapter 3: The Reckoning'"
-		// is not a key named "- 'Chapter 3". Checked before Cut so a
-		// colon inside one never reaches the key/value path at all.
-		if line != "" && (line[0] == ' ' || line[0] == '\t') {
-			lines = append(lines, fmLine{raw: line})
-			continue
-		}
-		key, val, found := strings.Cut(line, ":")
-		key = strings.TrimSpace(key)
-		if !found || key == "" || strings.HasPrefix(strings.TrimSpace(line), "#") {
-			lines = append(lines, fmLine{raw: line})
-			continue
-		}
-		lines = append(lines, fmLine{key: key, value: strings.TrimSpace(val)})
-	}
-	return lines, true
-}
-
-// setLine updates key's value in place if lines already has it, or appends
-// a new entry if it doesn't — the one behavior the original refreshOwned
-// got wrong (PR #126 review, round 2: it only ever updated in place).
-func setLine(lines []fmLine, key, value string) []fmLine {
-	for i := range lines {
-		if lines[i].key == key {
-			lines[i].value = value
-			return lines
-		}
-	}
-	return append(lines, fmLine{key: key, value: value})
-}
-
-func renderFrontmatterBlock(lines []fmLine) string {
-	if len(lines) == 0 {
-		return ""
-	}
-	var sb strings.Builder
-	sb.WriteString("---\n")
-	for _, l := range lines {
-		switch {
-		case l.key == "":
-			sb.WriteString(l.raw)
-		case l.value == "":
-			// A key with nothing after the colon (the YAML block-list shape:
-			// "aliases:" followed by indented "- item" lines on their own
-			// raw lines) must stay bare — "key: " with a trailing space
-			// is a different, if invisible, byte sequence, and this file's
-			// whole purpose is byte-stability across an unrelated merge.
-			sb.WriteString(l.key)
-			sb.WriteByte(':')
-		default:
-			sb.WriteString(l.key)
-			sb.WriteString(": ")
-			sb.WriteString(l.value)
-		}
-		sb.WriteByte('\n')
-	}
-	sb.WriteString("---\n")
-	return sb.String()
-}
-
 // refreshOwned returns a's frontmatter with the generator-owned fields taken
 // from b where b supplies them. Fields absent from b keep a's value, so a
 // generator that stops emitting a field cannot blank it.
-//
-// A field b supplies that a doesn't have yet — every page ingested before
-// this mechanism existed has no source_hash line at all — is appended, not
-// dropped (round 1 of review: dropping it silently meant source_hash never
-// populated for the pre-existing corpus). If a has no frontmatter fence at
-// all, one is created to hold the new fields rather than splicing raw
-// "key: value" text into the body (round 2: that corrupted the page and the
-// fields would duplicate on every subsequent merge, since unfenced text
-// isn't recognized as frontmatter by parseSections on the next pass).
 func refreshOwned(a, b string) string {
-	bLines, _ := parseFrontmatterBlock(b)
 	bVals := make(map[string]string)
-	for _, l := range bLines {
+	for _, line := range strings.Split(b, "\n") {
-		if l.key != "" && generatorOwned[l.key] {
+		key, value, found := strings.Cut(line, ":")
-			bVals[l.key] = l.value
+		if !found || !generatorOwned[strings.TrimSpace(key)] {
+			continue
 		}
+		bVals[strings.TrimSpace(key)] = strings.TrimSpace(value)
 	}
 	if len(bVals) == 0 {
 		return a
 	}
 
-	aLines, _ := parseFrontmatterBlock(a) // ok==false (no fence) -> aLines nil, same as "start fresh"
+	out := make([]string, 0, len(strings.Split(a, "\n")))
-
+	for _, line := range strings.Split(a, "\n") {
-	// Sorted for a deterministic, byte-stable result when more than one
+		key, _, found := strings.Cut(line, ":")
-	// field is appended in the same call — map iteration order isn't.
+		k := strings.TrimSpace(key)
-	keys := make([]string, 0, len(bVals))
+		if found && generatorOwned[k] {
-	for k := range bVals {
+			if v, ok := bVals[k]; ok {
-		keys = append(keys, k)
+				out = append(out, k+": "+v)
+				delete(bVals, k)
+				continue
 			}
-	sort.Strings(keys)
-	for _, k := range keys {
-		aLines = setLine(aLines, k, bVals[k])
 		}
-	return renderFrontmatterBlock(aLines)
+		out = append(out, line)
+	}
+	return strings.Join(out, "\n")
 }
 
 // parseSections splits markdown into its frontmatter, its preamble (content

ingestion/internal/wiki/merge_test.go

@@ -215,120 +215,55 @@ Rewritten by the model.
 	assert.NotContains(t, got, "Renamed by the model")
 }
 
-func TestMerge_GeneratorOwnedFieldsAreAppendedWhenAPageNeverHadThemBefore(t *testing.T) {
+func TestMerge_ReportsSectionsWhereTheFreshVersionWasDiscarded(t *testing.T) {
-	// Found in review of PR #126: refreshOwned only replaced a generator-owned
+	// The asymmetry that makes ingest safe (on-disk wins) also throws away a
-	// line that already existed in a's frontmatter — it never appended one a
+	// real signal: the source now says something different about a section we
-	// didn't have. Every page ingested before this feature shipped has no
+	// already have. Today that disagreement is silently discarded, so nobody
-	// source_hash line at all, so on its first re-ingest after deploy, the
+	// can tell "the source is unchanged" from "the source changed its mind and
-	// fresh hash was silently dropped and the skip-on-unchanged feature this
+	// we ignored it".
-	// PR exists to build would never engage for the entire pre-existing
-	// corpus, permanently, with nothing telling anyone.
 	existing := Page{Path: "wiki/sources/x.md", Content: `---
 title: 'X'
 ---
 
 ## Summary
 
-Original.
+Appetite is fixed, scope is variable.
+
+## Method
+
+Six-week cycles.
 `}
 	fresh := Page{Path: "wiki/sources/x.md", Content: `---
-title: 'Renamed by the model'
-last_updated: 2026-08-22
-source_hash: bbbb
----
-
-## Summary
-
-Rewritten by the model.
-`}
-
-	got := Merge(existing, fresh).Content
-
-	// Exact frontmatter block, not Contains: the second review round found
-	// that a substring check doesn't prove the fields landed inside a valid
-	// fence, in the right order, or that the fence itself wasn't corrupted —
-	// two independent mutations (closeIdx targeting the wrong fence, reversed
-	// sort) both survived a Contains-only version of this test.
-	want := "---\ntitle: 'X'\nlast_updated: 2026-08-22\nsource_hash: bbbb\n---\n\n## Summary\n\nOriginal.\n"
-	assert.Equal(t, want, got)
-}
-
-func TestMerge_GeneratorOwnedFieldsCreateAFrontmatterBlockWhenThePageHadNoneAtAll(t *testing.T) {
-	// Second review round on PR #126: when a has no frontmatter fence at all,
-	// the append fallback spliced raw, unfenced "key: value" lines straight
-	// into the body -- worse than the original bug, because the next
-	// parseSections call wouldn't recognize them as frontmatter (they don't
-	// start with `---`), so they'd be absorbed as ordinary preamble text and
-	// re-duplicate on every subsequent merge instead of updating in place.
-	existing := Page{Path: "wiki/sources/x.md", Content: "## Summary\n\nOriginal.\n"}
-	fresh := Page{Path: "wiki/sources/x.md", Content: `---
-last_updated: 2026-08-22
-source_hash: bbbb
----
-
-## Summary
-
-Rewritten by the model.
-`}
-
-	got := Merge(existing, fresh).Content
-
-	want := "---\nlast_updated: 2026-08-22\nsource_hash: bbbb\n---\n\n## Summary\n\nOriginal.\n"
-	assert.Equal(t, want, got)
-}
-
-func TestMerge_GeneratorOwnedFieldsMixedReplaceAndAppend(t *testing.T) {
-	// a already has last_updated (replace in place) but not source_hash
-	// (append) -- the two code paths in the same call, together.
-	existing := Page{Path: "wiki/sources/x.md", Content: `---
 title: 'X'
-last_updated: 2026-01-01
 ---
 
 ## Summary
 
-Original.
+Appetite is negotiable and scope is fixed.
+
+## Method
+
+Six-week cycles.
 `}
-	fresh := Page{Path: "wiki/sources/x.md", Content: `---
+
-last_updated: 2026-08-22
+	got, conflicts := MergeReport(existing, fresh)
-source_hash: bbbb
+
+	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
 
-Rewritten by the model.
+Appetite is fixed, scope is variable.
 `}
 
-	got := Merge(existing, fresh).Content
+	_, conflicts := MergeReport(page, page)
-
+	assert.Empty(t, conflicts, "identical content is not a disagreement")
-	want := "---\ntitle: 'X'\nlast_updated: 2026-08-22\nsource_hash: bbbb\n---\n\n## Summary\n\nOriginal.\n"
-	assert.Equal(t, want, got)
-}
-
-func TestRefreshOwned_CommentLinesSurviveUnmangled(t *testing.T) {
-	// Third review round on PR #126: parseFrontmatterBlock dropped the
-	// sibling api package's comment guard (strings.HasPrefix(trimmed, "#")).
-	// Without it, a comment line containing a colon gets cut at the colon
-	// and re-rendered with collapsed whitespace instead of surviving
-	// verbatim.
-	a := "---\n#see also:   https://x/y\ntitle: 'X'\n---\n"
-	b := "---\nsource_hash: bbbb\n---\n"
-
-	got := refreshOwned(a, b)
-	assert.Equal(t, "---\n#see also:   https://x/y\ntitle: 'X'\nsource_hash: bbbb\n---\n", got)
-}
-
-func TestRefreshOwned_IndentedListItemsWithColonsAreNotMisparsedAsKeys(t *testing.T) {
-	// Same round: an indented YAML block-list item that happens to contain a
-	// colon (e.g. a title with a subtitle) is a continuation line, never a
-	// top-level key, regardless of what strings.Cut finds in it. Misparsing
-	// it as a key/value pair and re-rendering strips its indentation,
-	// de-indenting it out of the list it belongs to -- and refreshOwned
-	// re-renders this block on essentially every non-skipped ingest, so this
-	// is the normal path, not an edge case.
-	a := "---\naliases:\n  - 'Chapter 3: The Reckoning'\ntitle: 'X'\n---\n"
-	b := "---\nsource_hash: bbbb\n---\n"
-
-	got := refreshOwned(a, b)
-	assert.Equal(t, "---\naliases:\n  - 'Chapter 3: The Reckoning'\ntitle: 'X'\nsource_hash: bbbb\n---\n", got)
 }