fix(ingest): keep the filename when the parsed title is mojibake

Two-layer PDFs (real text + an overlay watermark drawn at the same Y
coordinate) produce parsed titles like "GGlloobbaall SSttrraatteeggyy"
because chars from both layers interleave in row order. persistTree
was writing that straight to documents.title, replacing the friendly
filename that the upload handler had seeded.

isLikelyMojibakeTitle catches the doubled-glyph signature
(>30% adjacent same-letter pairs) plus suspiciously short titles
(<4 alphanumeric chars). When it fires we skip SetDocumentTitle, so
the row keeps its filename instead.

Unit test covers real titles, filename-style strings, the actual GINA
mojibake we observed, and a few edge cases.

Author: hallelx2

pkg/ingest/ingest.go

@@ -141,7 +141,12 @@ func (p *Pipeline) parse(ctx context.Context, pl Payload) (*parser.ParsedDoc, er
 // persistTree writes sections + full content in document order. Parents
 // are written before children so the FK on sections.parent_id holds.
 func (p *Pipeline) persistTree(ctx context.Context, docID tree.DocumentID, doc *parser.ParsedDoc) error {
-	if doc.Title != "" {
+	// Only overwrite the row's title (which was seeded with the
+	// filename at upload time) when the parsed title looks usable.
+	// Watermarked PDFs whose overlay text shares a Y coordinate with
+	// the real title produce mojibake like "GGlloobbaall SSttrraatteeggyy"
+	// — we'd rather keep the original filename than show that to a user.
+	if doc.Title != "" && !isLikelyMojibakeTitle(doc.Title) {
 		if err := p.DB.SetDocumentTitle(ctx, docID, doc.Title); err != nil {
 			return err
 		}
@@ -365,6 +370,42 @@ func (p *Pipeline) fail(ctx context.Context, id tree.DocumentID, stage string, c
 	}
 }
 
+// isLikelyMojibakeTitle returns true when s shows the doubled-glyph
+// signature of two-layer PDFs (an overlay watermark drawn over real
+// text at the same Y coordinate, so chars from both layers interleave
+// into runs like "GGlloobbaall"). Also flags suspiciously short titles
+// that are pure punctuation/whitespace.
+//
+// Conservative on purpose: we'd rather show a slightly weird real
+// title than silently fall back to the filename for a normal doc.
+func isLikelyMojibakeTitle(s string) bool {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return true
+	}
+	// Count alphabetic chars + adjacent same-letter pairs (case-insensitive).
+	letters := 0
+	doubled := 0
+	var prev rune
+	for _, r := range strings.ToLower(s) {
+		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
+			letters++
+			if r == prev {
+				doubled++
+			}
+			prev = r
+		} else {
+			prev = 0
+		}
+	}
+	if letters < 4 {
+		return true // too few letters to be a real title
+	}
+	// >30% adjacent-doubled letters is the signature of the two-layer
+	// glyph interleaving — normal English titles sit well under 5%.
+	return doubled*100/letters > 30
+}
+
 // approxTokens is a cheap 4-chars-per-token heuristic used at ingest
 // time so we don't spend a provider round-trip per section just to
 // populate metadata. Real token counts are reconciled when a retrieval

pkg/ingest/mojibake_test.go

@@ -0,0 +1,38 @@
+package ingest
+
+import "testing"
+
+func TestIsLikelyMojibakeTitle(t *testing.T) {
+	cases := []struct {
+		in      string
+		mojiBad bool
+	}{
+		// Real titles that must NOT be flagged.
+		{"Global Strategy for Asthma Management and Prevention", false},
+		{"Attention Is All You Need", false},
+		{"The Pragmatic Programmer", false},
+		{"Q1 2026 Financial Report", false},
+		{"Annual Review 2025", false},
+		{"a", true}, // too few letters
+		{"PDF", true},
+		{"GINA-2025-Update-25_11_08-WMS.pdf", false}, // filenames are valid
+		{"book", false},                              // exactly 4 letters
+		// The GINA watermark interleaving cases we actually saw.
+		{"GGlloobbaall  SSttrraatteeggyy  ffoorr", true},
+		{"AAsstthhmmaa  MMaannaaggeemmeenntt", true},
+		{"aanndd  PPrreevveennttiioonn", true},
+		// Edge cases.
+		{"", true},
+		{"   ", true},
+		{"Hello", false},
+		{"HHHHHHHHH", true}, // pure repetition
+		// Some abbreviation-heavy titles (common in academic papers).
+		{"BERT: Pre-training of Deep Bidirectional Transformers", false},
+	}
+	for _, tc := range cases {
+		got := isLikelyMojibakeTitle(tc.in)
+		if got != tc.mojiBad {
+			t.Errorf("isLikelyMojibakeTitle(%q) = %v, want %v", tc.in, got, tc.mojiBad)
+		}
+	}
+}