@mailwoman/corpus 9.4.0 → 10.1.0

package/lib/tools/golden-relabel-street.ts

@@ -1,686 +0,0 @@
-/**
- * @copyright Sister Software
- * @license AGPL-3.0
- * @author Teffen Ellis, et al.
- *
- *   Golden-set street-suffix relabel — v0.1.2 → v0.1.3.
- *
- *   ## Why this exists
- *
- *   The golden answer key and the training corpus disagreed about ONE thing, and the v9.0.0
- *   promotion eval read the disagreement as a model regression (`us.street` 87.4 vs a floor of
- *   87.8). The corpus SPLITS a US street into `street` + `street_suffix` — TIGER's adapter
- *   decomposes at `corpus/src/adapters/tiger/street-decompose.ts`, the `street-affix` slice recipe
- *   teaches it from USPS Pub-28, and `ComponentTag` carries `street_suffix` as a first-class tag.
- *   The golden set FOLDED it: 2,216 US rows carry a `street`, and exactly 2 of them label a
- *   `street_suffix`. Operator ruling, 2026-08-06: **the split is canonical**; the golden is the
- *   stale side. This tool moves the answer key onto the corpus convention.
- *
- *   ## The instrument
- *
- *   `matchTrailingSuffix` from `@mailwoman/codex/us` — the USPS Pub-28 Appendix C table, which is
- *   also what the corpus slice recipe splits on. The table is NOT re-implemented here, and the
- *   libpostal dictionary TIGER reads is deliberately not used: measured on this golden set the two
- *   disagree on 51 US rows, and the disagreements run in the codex table's favour (libpostal's
- *   `directionals.txt` lists `center|c`, so TIGER reads the `C` of "C STREET" as a directional
- *   prefix and then emits no suffix at all).
- *
- *   ## What it changes, and what it refuses to
- *
- *   Applied only to rows whose `country` is `US`. Three branches, mirroring the SHAPE of TIGER's
- *   `decomposeStreet` on codex tables:
- *
- *   - **street type** — the last whitespace-separated word is a Pub-28 suffix, and something is left
- *       over: "Main St" → `street: "Main"`, `street_suffix: "St"` (1,559 rows).
- *   - **street type + post-directional** — the last word is a directional AND the one before it is a
- *       Pub-28 suffix: "Pennsylvania Avenue NW" → `street: "Pennsylvania"`,
- *       `street_suffix: "Avenue NW"` (347 rows). The post-directional joins the suffix rather than
- *       becoming a tag of its own, because that is what the corpus adapter emits; there is no
- *       `street_postfix` tag to move it to.
- *   - **everything else is left folded** and reported. In particular a BARE post-directional tail
- *       ("Seymour East", "BROADWAY N" — 16 rows) is NOT split: a directional is not a Pub-28 suffix,
- *       and the observed rows in that class are unit-contaminated ("1ST AVE SW BOX E", where the
- *       trailing "E" is a box letter).
- *
- *   FR rows are untouched, deliberately and permanently as far as this tool is concerned. French
- *   street typology puts the type FIRST ("Rue de la Paix") and the golden labels only 7 of 665 FR
- *   street rows with a `street_prefix`; whether FR should split at all is a different question with
- *   a different table behind it, and nothing here should be read as having answered it.
- *
- *   ## Surface bytes
- *
- *   The split is a break at a whitespace run in the ORIGINAL string — no trimming, no case
- *   normalization, no re-joining of tokens. `street + gap + street_suffix` reconstructs the input
- *   byte-for-byte, so the whitespace between them belongs to neither span (the same shape the corpus
- *   adapter's spans have). The tool asserts this per row and refuses to write a file if it ever
- *   fails.
- */
-
-import {
-	isStreetDirectionalToken,
-	matchTrailingSuffix,
-	type USStreetSuffix,
-	NAME_PRONE_US_SUFFIXES,
-} from "@mailwoman/codex/us"
-import { pathExists, readDirectoryEntries, readLocalBuffer, readLocalTextFile } from "@mailwoman/core/fs/readers"
-import { makeDirectories, writeLocalFile, writeLocalJSONFile, writeLocalTextFile } from "@mailwoman/core/fs/writers"
-import { sha256File } from "@mailwoman/core/hash"
-import { parseJSONStrict, tryParsingJSON } from "@mailwoman/core/json"
-import { isPresent } from "@mailwoman/core/objects"
-import { escapeRegExp } from "@mailwoman/core/strings/regexp"
-import { basename, join } from "path-ts"
-import { TextSpliterator } from "spliterator"
-
-// ── Types ──────────────────────────────────────────────────────────────────
-
-/**
- * A golden-set row, as stored one-per-line in `us.jsonl` / `fr.jsonl` / `adversarial.jsonl`. Only the fields this tool
- * reads are modeled; every other key rides through untouched.
- */
-export interface GoldenStreetRow {
-	raw: string
-	components: Record<string, string>
-	country?: string
-	source?: string
-	notes?: string
-	[key: string]: unknown
-}
-
-/**
- * What the tool decided about one row. Every value except the two `split-*` classes means "left folded".
- */
-export type GoldenRelabelClass =
-	| "split-suffix"
-	| "split-suffix-postdirectional"
-	| "split-prefix-only"
-	| "already-split"
-	| "single-token"
-	| "suffix-only-street"
-	| "postdirectional-tail-only"
-	| "no-suffix-match"
-	| "no-street"
-	| "not-us"
-	| "untrimmed-street"
-
-/**
- * A review trigger on a row the tool DID change. A flag is never an adjudication — it marks the row for the operator's
- * deck, and the split is applied either way.
- */
-export interface GoldenRelabelFlag {
-	kind: "name-prone-suffix" | "venue-context" | "remainder-is-affix"
-	detail: string
-}
-
-/**
- * Row-level relabel outcome.
- */
-export interface GoldenRelabelResult {
-	/**
-	 * The row to write. Identical object reference when nothing changed.
-	 */
-	row: GoldenStreetRow
-	changed: boolean
-	rowClass: GoldenRelabelClass
-	flags: GoldenRelabelFlag[]
-	/**
-	 * A leading directional was lifted into `street_prefix` on this row.
-	 */
-	prefixSplit: boolean
-	/**
-	 * The street span as it stood in the parent version — recorded for the review deck.
-	 */
-	beforeStreet?: string
-}
-
-// ── The name-prone suffix set ──────────────────────────────────────────────
-
-/**
- * Pub-28 canonicals that are also ordinary head nouns of PROPER NAMES — "Lincoln Park", "Boston Common", "Willow
- * Brook". A split on one of these is still applied (the table is the table), but the row lands in the review deck
- * because the trailing word may belong to the name rather than to the street type.
- *
- * Chosen against the surfaces this golden set actually carries (park 6, green 5, hill 7, heights 3, hollow 3, brook 3,
- * pass 3 — the whole flagged class is 60 rows of 1,906), not from the whole 200-entry table: flagging every possible
- * name-head would mark a third of the corrections and stop being a review artifact.
- */
-// ── Byte-exact tail split ──────────────────────────────────────────────────
-
-interface TailSplit {
-	head: string
-	gap: string
-	tail: string
-}
-
-/**
- * Split `s` at its LAST whitespace run, returning the three pieces verbatim. Null when there is no interior whitespace,
- * when the head would be empty, or when `s` carries leading/trailing whitespace (a golden row is stored trimmed; an
- * untrimmed one is reported rather than silently normalized).
- */
-function splitLastWord(s: string): TailSplit | null {
-	if (s !== s.trim() || !s) return null
-	const match = /^(.*\S)(\s+)(\S+)$/.exec(s)
-
-	if (!match) return null
-
-	return { head: match[1]!, gap: match[2]!, tail: match[3]! }
-}
-
-/**
- * Split `s` at its FIRST whitespace run — the leading-directional counterpart of {@link splitLastWord}. `head` is the
- * first word, `tail` the rest, both verbatim.
- */
-function splitFirstWord(s: string): TailSplit | null {
-	if (s !== s.trim() || !s) return null
-	const match = /^(\S+)(\s+)(\S.*)$/.exec(s)
-
-	if (!match) return null
-
-	return { head: match[1]!, gap: match[2]!, tail: match[3]! }
-}
-
-// ── Row-level relabel ──────────────────────────────────────────────────────
-
-/**
- * Rebuild `components` with `street_suffix` inserted immediately after `street`, so the written row reads in address
- * order rather than with the new tag appended at the end.
- */
-function withStreetSpans(
-	components: Record<string, string>,
-	spans: { prefix?: string; street: string; suffix?: string }
-): Record<string, string> {
-	const out: Record<string, string> = {}
-
-	for (const [key, value] of Object.entries(components)) {
-		if (key === "street") {
-			if (spans.prefix) {
-				out.street_prefix = spans.prefix
-			}
-
-			out.street = spans.street
-
-			if (spans.suffix) {
-				out.street_suffix = spans.suffix
-			}
-
-			continue
-		}
-
-		if (key === "street_prefix" || key === "street_suffix") continue
-		out[key] = value
-	}
-
-	return out
-}
-
-/**
- * Options for {@linkcode relabelGoldenStreetRow}.
- */
-export interface RelabelStreetRowOptions {
-	/**
-	 * Also lift a folded LEADING directional out into `street_prefix`. Default true.
-	 *
-	 * On by default because the fold applies both ways and the answer key has to be corrected on both, or the correction
-	 * is not a correction: 207 of the 1,682 split dev rows (12.3%) still opened with a directional after the suffix move
-	 * — "N Desmet Avenue" would have graded `street: "N Desmet"` against a model that says `street_prefix: "N", street:
-	 * "Desmet"`. Turn it OFF only to measure what the prefix fold alone costs.
-	 */
-	splitPrefix?: boolean
-}
-
-/**
- * Decide, and apply, the US street-span split for ONE golden row. Pure: never mutates its argument, and returns the
- * same object reference when the row is left alone.
- */
-export function relabelGoldenStreetRow(
-	row: GoldenStreetRow,
-	options: RelabelStreetRowOptions = {}
-): GoldenRelabelResult {
-	const splitPrefix = options.splitPrefix ?? true
-
-	const keep = (rowClass: GoldenRelabelClass): GoldenRelabelResult => ({
-		row,
-		changed: false,
-		rowClass,
-		flags: [],
-		prefixSplit: false,
-	})
-
-	if ((row.country ?? "").toUpperCase() !== "US") return keep("not-us")
-	const street = row.components.street
-
-	if (!street) return keep("no-street")
-
-	if (row.components.street_suffix) return keep("already-split")
-
-	if (street !== street.trim()) return keep("untrimmed-street")
-
-	const flags: GoldenRelabelFlag[] = []
-	let rowClass: GoldenRelabelClass
-	let name = street
-	let suffix: string | undefined
-	let suffixGap = ""
-	let canonical: USStreetSuffix | undefined
-
-	const split = splitLastWord(street)
-
-	if (!split) {
-		rowClass = matchTrailingSuffix(street) ? "suffix-only-street" : "single-token"
-	} else if (isStreetDirectionalToken(split.tail)) {
-		// Street type + post-directional ("Pennsylvania Avenue NW"). The corpus adapter emits the pair as
-		// ONE suffix span, and there is no post-directional tag to move it to.
-		const inner = splitLastWord(split.head)
-		const typeMatch = inner ? matchTrailingSuffix(inner.tail) : null
-
-		if (!inner || !typeMatch) {
-			rowClass = "postdirectional-tail-only"
-		} else {
-			rowClass = "split-suffix-postdirectional"
-			name = inner.head
-			suffix = `${inner.tail}${split.gap}${split.tail}`
-			suffixGap = inner.gap
-			canonical = typeMatch.canonical
-		}
-	} else {
-		const typeMatch = matchTrailingSuffix(street)
-
-		if (!typeMatch) {
-			rowClass = "no-suffix-match"
-		} else {
-			rowClass = "split-suffix"
-			name = split.head
-			suffix = split.tail
-			suffixGap = split.gap
-			canonical = typeMatch.canonical
-		}
-	}
-
-	// Leading directional → street_prefix, on whatever name survived the suffix move. Independent of the
-	// suffix branch, because "N Main" is as folded as "N Main St" is.
-	let prefix: string | undefined
-	let prefixGap = ""
-
-	if (splitPrefix && !row.components.street_prefix) {
-		const lead = splitFirstWord(name)
-
-		if (lead && isStreetDirectionalToken(lead.head)) {
-			prefix = lead.head
-			prefixGap = lead.gap
-			name = lead.tail
-		}
-	}
-
-	if (!suffix && !prefix) return keep(rowClass)
-
-	if (!suffix) {
-		rowClass = "split-prefix-only"
-	}
-
-	// The invariant this tool exists to keep: the spans plus the whitespace between them ARE the original
-	// span, byte for byte. Anything else means a token was rewritten.
-	const rebuilt = `${prefix ? prefix + prefixGap : ""}${name}${suffix ? suffixGap + suffix : ""}`
-
-	if (rebuilt !== street) {
-		throw new Error(`golden-relabel: span reconstruction failed for ${JSON.stringify(street)}`)
-	}
-
-	if (canonical && NAME_PRONE_US_SUFFIXES.has(canonical)) {
-		flags.push({
-			kind: "name-prone-suffix",
-			detail: `${canonical} heads proper names as often as street types`,
-		})
-	}
-
-	const venue = row.components.venue
-
-	if (suffix && venue && new RegExp(`(^|\\W)${escapeRegExp(suffix)}(\\W|$)`, "i").test(venue)) {
-		flags.push({
-			kind: "venue-context",
-			detail: `venue ${JSON.stringify(venue)} also carries ${JSON.stringify(suffix)}`,
-		})
-	}
-
-	// Narrow on purpose: a name that happens to be a Pub-28 canonical is NOT interesting ("Mountain Rd",
-	// "Valley Dr", "Mills Ln" are ordinary streets, and flagging them buried the deck — 108 rows of noise
-	// on the first run). A name that is a bare DIRECTIONAL is: "East Rd" leaves `street: "East"`, which is
-	// a direction, not a name.
-	if (isStreetDirectionalToken(name)) {
-		flags.push({
-			kind: "remainder-is-affix",
-			detail: `street would become the bare directional ${JSON.stringify(name)}`,
-		})
-	}
-
-	return {
-		row: {
-			...row,
-			components: withStreetSpans(row.components, {
-				...(prefix ? { prefix } : row.components.street_prefix ? { prefix: row.components.street_prefix } : {}),
-				street: name,
-				...(suffix ? { suffix } : {}),
-			}),
-		},
-		changed: true,
-		rowClass,
-		flags,
-		prefixSplit: Boolean(prefix),
-		beforeStreet: street,
-	}
-}
-
-// ── Directory-level relabel ────────────────────────────────────────────────
-
-/**
- * Per-class row counts for one relabelled file.
- */
-export type GoldenRelabelCounts = Record<GoldenRelabelClass, number>
-
-/**
- * One line of the review deck: what a changed (or notably unchanged) row looked like before and after.
- */
-export interface GoldenRelabelDeckEntry {
-	file: string
-	line: number
-	raw: string
-	rowClass: GoldenRelabelClass
-	before: Record<string, string>
-	after: Record<string, string>
-	flags: GoldenRelabelFlag[]
-}
-
-/**
- * Options for {@linkcode relabelGoldenDirectory}.
- */
-export interface RelabelGoldenOptions {
-	/**
-	 * Parent golden version dir (read-only), e.g. `data/eval/golden/v0.1.2`.
-	 */
-	input: string
-	/**
-	 * Output golden version dir. Created; never overwritten in place.
-	 */
-	output: string
-	/**
-	 * Review-deck JSONL path. Default `<output>/REVIEW-DECK.jsonl`.
-	 */
-	deck?: string
-	/**
-	 * Parent version label recorded in the manifest. Default: the input dir's basename.
-	 */
-	parentLabel?: string
-	/**
-	 * Tool provenance recorded in the manifest — the commit the relabel ran at.
-	 */
-	commit?: string
-	/**
-	 * Passed through to {@linkcode relabelGoldenStreetRow}. Default true.
-	 */
-	splitPrefix?: boolean
-}
-
-/**
- * Aggregate outcome for a whole golden version.
- */
-export interface RelabelGoldenReport {
-	files: Record<
-		string,
-		{ entries: number; changed: number; flagged: number; prefixSplit: number; counts: GoldenRelabelCounts }
-	>
-	deckPath: string
-	outputDir: string
-	totalChanged: number
-	totalFlagged: number
-}
-
-const EMPTY_COUNTS = (): GoldenRelabelCounts => ({
-	"split-suffix": 0,
-	"split-suffix-postdirectional": 0,
-	"split-prefix-only": 0,
-	"already-split": 0,
-	"single-token": 0,
-	"suffix-only-street": 0,
-	"postdirectional-tail-only": 0,
-	"no-suffix-match": 0,
-	"no-street": 0,
-	"not-us": 0,
-	"untrimmed-street": 0,
-})
-
-/**
- * Classes that are LEFT FOLDED but still belong in the deck, because the operator asked to see them by name: a street
- * that is entirely one suffix word, and a bare post-directional tail.
- */
-const DECK_WORTHY_UNCHANGED: ReadonlySet<GoldenRelabelClass> = new Set([
-	"suffix-only-street",
-	"postdirectional-tail-only",
-	"untrimmed-street",
-])
-
-/**
- * Relabel every `.jsonl` in a golden version dir, writing a new version dir plus a review deck and a MANIFEST that
- * records the convention, the parent, and the counts. Non-JSONL siblings (README, split manifests) are copied forward
- * so the new version is self-contained; nested split dirs (`dev/`, `test/`) are relabelled recursively.
- */
-export async function relabelGoldenDirectory(
-	options: RelabelGoldenOptions,
-	report: (line: string) => void = console.log
-): Promise<RelabelGoldenReport> {
-	const { input, output } = options
-	const deckPath = options.deck ?? join(output, "REVIEW-DECK.jsonl")
-	await makeDirectories(output)
-
-	const deck: GoldenRelabelDeckEntry[] = []
-	const files: RelabelGoldenReport["files"] = {}
-
-	const walk = async (dirIn: string, dirOut: string, prefix: string): Promise<void> => {
-		await makeDirectories(dirOut)
-
-		for (const name of await readDirectoryEntries(dirIn)) {
-			const from = join(dirIn, name.name)
-			const to = join(dirOut, name.name)
-
-			if (name.isDirectory()) {
-				await walk(from, to, `${prefix}${name.name}/`)
-
-				continue
-			}
-
-			if (!name.name.endsWith(".jsonl")) {
-				// MANIFEST is rewritten below; everything else (README, SPLIT-MANIFEST) rides forward.
-				if (name.name !== "MANIFEST.json") {
-					await writeLocalFile(await readLocalBuffer(from), to)
-				}
-
-				continue
-			}
-
-			const counts = EMPTY_COUNTS()
-			let changed = 0
-			let flagged = 0
-			let prefixSplit = 0
-			const out: string[] = []
-			let lineNumber = 0
-
-			for (const line of TextSpliterator.from(await readLocalTextFile(from))) {
-				if (!line.trim()) continue
-
-				lineNumber++
-				// A corrupt answer-key line must STOP the relabel, not silently drop a row — a golden file
-				// short by one row is a floor threshold against a different denominator.
-				const row = parseJSONStrict<GoldenStreetRow>(line)
-				const result = relabelGoldenStreetRow(row, { splitPrefix: options.splitPrefix ?? true })
-
-				counts[result.rowClass]++
-
-				if (result.changed) {
-					changed++
-				}
-
-				if (result.prefixSplit) {
-					prefixSplit++
-				}
-
-				if (result.flags.length) {
-					flagged++
-				}
-
-				if (result.changed || DECK_WORTHY_UNCHANGED.has(result.rowClass)) {
-					deck.push({
-						file: `${prefix}${name.name}`,
-						line: lineNumber,
-						raw: row.raw,
-						rowClass: result.rowClass,
-						before: row.components,
-						after: result.row.components,
-						flags: result.flags,
-					})
-				}
-
-				out.push(JSON.stringify(result.row))
-			}
-
-			await writeLocalTextFile(out.join("\n") + "\n", to)
-			files[`${prefix}${name.name}`] = { entries: lineNumber, changed, flagged, prefixSplit, counts }
-
-			report(
-				`  ${prefix}${name.name}: ${lineNumber} rows, ${changed} changed (${prefixSplit} with a prefix lift), ${flagged} flagged`
-			)
-		}
-	}
-
-	report(`relabel ${input} → ${output}`)
-	await walk(input, output, "")
-
-	await writeLocalTextFile(deck.map((entry) => JSON.stringify(entry)).join("\n") + "\n", deckPath)
-	await writeLocalFile(renderDeckMarkdown(deck, basename(input), basename(output)), deckPath.replace(/\.jsonl$/, ".md"))
-
-	const manifestFiles: Record<
-		string,
-		{ entries: number; sha256: string; changed: number; flagged: number; prefix_split: number }
-	> = {}
-
-	for (const [name, stats] of Object.entries(files)) {
-		manifestFiles[name] = {
-			entries: stats.entries,
-			sha256: await sha256File(join(output, name)),
-			changed: stats.changed,
-			flagged: stats.flagged,
-			prefix_split: stats.prefixSplit,
-		}
-	}
-
-	const totalChanged = Object.values(files).reduce((n, f) => n + f.changed, 0)
-	const totalFlagged = Object.values(files).reduce((n, f) => n + f.flagged, 0)
-
-	const manifest = {
-		version: basename(output),
-		parent: options.parentLabel ?? basename(input),
-		generated_at: new Date().toISOString(),
-		tool: "corpus/src/tools/golden-relabel-street.ts (mailwoman corpus golden-relabel)",
-		...(options.commit ? { commit: options.commit } : {}),
-		convention: {
-			street_convention: { US: "split", "*": "folded" },
-			declared:
-				"US street spans are labeled SPLIT: a leading directional is its own `street_prefix` span, the Pub-28 " +
-				"street type (plus a post-directional, when one trails it) is its own `street_suffix` span, and `street` " +
-				"carries only the name. Non-US rows keep the folded convention of the parent version. A scorer that " +
-				"folds `street_prefix`/`street`/`street_suffix` back together before comparing is NOT grading this " +
-				"answer key.",
-			instrument:
-				"@mailwoman/codex/us — matchTrailingSuffix (USPS Pub-28 Appendix C) for the type, " +
-				"isStreetDirectionalToken for the directionals",
-			left_folded:
-				"single-token streets, streets that are entirely one suffix word, bare post-directional tails, and any " +
-				"street whose trailing word is not in the Pub-28 table",
-			prefix_split: options.splitPrefix ?? true,
-		},
-		counts: {
-			changed: totalChanged,
-			flagged: totalFlagged,
-			prefix_split: Object.values(files).reduce((n, f) => n + f.prefixSplit, 0),
-			per_file: Object.fromEntries(Object.entries(files).map(([name, stats]) => [name, stats.counts])),
-		},
-		files: manifestFiles,
-		review_deck: basename(deckPath),
-	}
-
-	await writeLocalJSONFile(manifest, join(output, "MANIFEST.json"))
-	report(`✓ ${totalChanged} rows split, ${totalFlagged} flagged — deck at ${deckPath}`)
-
-	return { files, deckPath, outputDir: output, totalChanged, totalFlagged }
-}
-
-/**
- * Render the operator-facing half of the review deck: the flagged rows first (those are the ones asking for a ruling),
- * then the classes the tool LEFT FOLDED by name, then a sample of the ordinary corrections. The JSONL sibling carries
- * every row; this file is the one a human reads.
- */
-function renderDeckMarkdown(deck: GoldenRelabelDeckEntry[], parent: string, version: string): string {
-	const span = (components: Record<string, string>): string =>
-		[components.street_prefix, components.street, components.street_suffix]
-			.filter(isPresent)
-			.map((s) => JSON.stringify(s))
-			.join(" + ")
-
-	// The split dirs are copies of the same rows — dedupe the deck to the top-level files for reading.
-	const top = deck.filter((entry) => !entry.file.includes("/"))
-	const flagged = top.filter((entry) => entry.flags.length)
-	const folded = top.filter((entry) => isLeftFolded(entry.rowClass))
-	const plain = top.filter((entry) => !entry.flags.length && !isLeftFolded(entry.rowClass))
-
-	const rows = (entries: GoldenRelabelDeckEntry[]): string =>
-		entries
-			.map(
-				(entry) =>
-					`| ${entry.file}:${entry.line} | ${span(entry.before)} | ${span(entry.after)} | ${entry.flags.map((f) => f.kind).join(", ") || "—"} | ${JSON.stringify(entry.raw)} |`
-			)
-			.join("\n")
-
-	const header = "| row | before | after | flags | raw |\n|---|---|---|---|---|"
-
-	return [
-		`# Golden street-suffix relabel review deck — ${parent} → ${version}`,
-		"",
-		"Rows are deduped to the top-level files (`dev/` and `test/` carry the same rows).",
-		"A flag is a REVIEW TRIGGER, not an adjudication: the split below is already applied.",
-		"",
-		`## Flagged (${flagged.length}) — needs a ruling`,
-		"",
-		header,
-		rows(flagged),
-		"",
-		`## Left folded (${folded.length}) — the tool declined to split these`,
-		"",
-		header,
-		rows(folded),
-		"",
-		`## Ordinary corrections (${plain.length}) — first 100 shown; the JSONL deck has all`,
-		"",
-		header,
-		rows(plain.slice(0, 100)),
-		"",
-	].join("\n")
-}
-
-/**
- * Every relabel class that means the row was left folded, for callers that want to report the residue.
- */
-export function isLeftFolded(rowClass: GoldenRelabelClass): boolean {
-	return rowClass !== "split-suffix" && rowClass !== "split-suffix-postdirectional" && rowClass !== "split-prefix-only"
-}
-
-/**
- * True when a golden dir declares the US-split convention — i.e. it is safe to grade it with an UNFOLDED scorer.
- */
-export async function goldenDeclaresSplitStreets(dir: string): Promise<boolean> {
-	for (const candidate of [join(dir, "MANIFEST.json"), join(dir, "..", "MANIFEST.json")]) {
-		if (!(await pathExists(candidate))) continue
-
-		const manifest = tryParsingJSON<{ convention?: { street_convention?: Record<string, string> } }>(
-			await readLocalTextFile(candidate)
-		)
-
-		if (manifest?.convention?.street_convention?.US === "split") return true
-	}
-
-	return false
-}