¡truÍSMO! the idiom truthiness machine

THE truÍSMO MACHINE: stage by stage

STAGE 0 — Intake

You drop raw text anywhere (chat, dropbox/idioms.txt — markdown bold, numbering, typos, all fine). A deterministic script parses it: strips formatting, normalizes (Unicode NFKD, stopword-stripped fuzzy matching), and dedupes against everything already in the pipeline so re-drops cost nothing (your 175-line drop → 42 known, 119 new). Every item keeps its source line number forever — provenance starts at the moment of donation. Output: intake/drop_*_chunks.json.

STAGE 1 — Triage (classification fleet)

A parallel fleet (your drop took 9 agents: 7 truism batches + 1 superstition specialist + 1 synthesizer) classifies each item from knowledge — not research; that's deliberate, triage is cheap and gates are named for later. Each item gets:

• track: image (concrete picture) / proposition (imageless claim) / superstition (ritual-luck complex) / form-class (interesting as a form, like tautologies)
• tier: 1 crown candidate / 2 stock / 3 descent-trap (known-author, teaching shelf) / 4 park
• provenance smell: lineage / convergence-candidate / modern-coinage / known-author (named)
• relations: counter_saying_of, antithetical_pair_with, inversion_of, family
• confidence, 0-100, on everything

Then the synthesis agent reads all batches at once: merges family-name drift, builds the relation graph, ranks the top candidates, and — critically — catches the triage's own inconsistencies (it found a duplicate item triaged twice, a tier-policy drift, a track misassignment). I rule on each flagged inconsistency by hand. Output: intake/triage_*_batchD.md + machine-readable items.

STAGE 2 — Curation (research fleets, the anti-confabulation core)

Tier-1 items get researcher agents under the HONESTY header, the non-negotiables:

• Never invent a quotation, foreign phrase, date, or source. "Could not verify" is a valuable answer.
• Verified negatives are findings (Pliny's missing salt omen is a result).
• Every claim carries confidence; every source is tier-ranked (critical edition > major reference > Wikipedia-marked-tertiary > forums-marked-low).
• WebSearch/WebFetch mandatory; where memory and source disagree, the source wins, and say so.
• Group by the IMAGE each tongue reaches for, never flat by language.

Every researcher is paired with an adversarial checker who re-fetches the 4-6 most load-bearing attestations in their native script. Unfindable foreign phrases = fabrication = fail. This layer has caught five fabrications so far (spliced Chinese couplets, an invented "American" attribution, a provenance-chain misattribution) — each repaired with the checker's source-confirmed correction, flagged in-file, never silently. Output: truismo/seeds/*.json + spec/motif_source_*.md.

STAGE 3 — Gates (the lineage-vs-arrival deciders)

Separate research fleets attack the dated questions that decide everything: Is the Arabic form pre-1656? Is isseki-nicho a Meiji loan? Does the Mahabharata's written stratum postdate contact? Each gate gets a researcher + skeptic pair and returns one of: resolves-lineage / resolves-borrowed / resolves-independent / remains-gated (an honorable verdict — never force what evidence won't support). Gate results amend live payloads: Arabic moved gated→borrow on a 6.68-million-page verified negative; Greece moved gated→counted on Herodotus; Sanskrit moved counted→gated by our own dating rule. The corpus gets more honest in both directions.

STAGE 4 — Annotation (vocabulary-claude's lane)

Vocab keys each motif into the formal vocabularies: image schemas S1-S28 + pragmatic functions F01-F14, the ratified 3-field record (schema / filler_domain / filler — the level something echoes at IS the finding), proposition keying (claim-shape / polarity / tradition), and the pilot superstition keying (mechanism / vehicle / valence+quantum). Friction reports are mandatory — where the keying fights the data, that's evidence, and it has already forced two new functions, a third polarity question, and the function-only matcher tier.

STAGE 5 — Payload authoring (my lane)

Each motif becomes one JSON conforming to truismo_motif_payload_schema_v0.1.md. The load-bearing parts:

• Attestations carry: language, family block, cluster, provenance class (anchor / cog / borrow / conv / gated), native phrase, transliteration, gloss, the honest lit paragraph, attested_in_corpus: null (until a real corpus confirms — no exceptions), confidence.
• Edges encode transmission: cog (inheritance), borrow (documented copy), contested (scholarly dispute — never merges components; independence is never collapsed on a disputed claim).
• THE COUNTS ARE NEVER HAND-TYPED. The cardinal rule. Tongues = distinct languages; tradition blocks = distinct families; arrivals = connected components of the non-gated global graph. Gated entries are excluded and surfaced separately ("+N candidates awaiting gates"). So the lineage map IS the measurement — data cannot disagree with display, because display is computed from data.
• The honesty block is schema-REQUIRED: who curated, what was repaired, every owed gate. A payload without it fails validation. The discipline travels with the data, not with anyone's goodwill.
• A validation script then checks everything mechanical: duplicate keys, dangling edges, illegal prov values, em-dashes, the brand string byte-exact (Í = U+00CD).

STAGE 6 — Render (design-claude's lane)

One generator (build-workup.mjs) eats any payload and emits a five-act page: the turning prism of attestations (a true chord-tiled n-gon), the decomposition act (per-track variant), the lineage constellation (stars colored by provenance, gold descent lines, dashed-rose borrows, dotted-gold contested), the measurement panel (the naive count animating down to the collapsed count, with "awaiting-O3" tiles where no computed number exists — never a fake number), and the honesty rail. Adding truism #500 = one JSON + one manifest line, zero new code.

Then design runs its own 8-agent skeptic pass against my payload (independent of my checkers — it caught the Icelandic single-character miscopy my layer missed), plus the acceptance check: the generator must re-derive my predicted numbers exactly (9/6/3+3, 13/9/5+3...). A mismatch means one of us is wrong, loudly.

STAGE 7 — The gates before humans see it

• a11y-claude's formal sweep — separate from design's automated axe runs, with manual keyboard/screen-reader judgment. It properly failed us once (focus indicators, arrow-key capture: things axe structurally can't see); the fix was template-level, one render healed all pages. Echo's hard rule: design AND a11y both pass, or it isn't user-facing.
• Legal: the truÍSMO mark, and license rulings on any corpus we'd ingest (CC-BY-SA, Opie & Tatem). No ingestion before clearance.
• You: greenlight per surface. Always last, always yours.

STAGE 8 — The store and the scorer (data-claude's lane, O3)

The echo_findings store (research Postgres, 33 columns, 6 tables) holds what payloads hold, relationally: the 3-field record, match methods with rho weights (how much a match type counts: exact 1.0 → gloss 0.45 → image_schema 0.40 → function_only 0.35 → legacy 0.25), and promotion_ok=false flags that enforce never-auto-promote in the schema itself — a function-only match physically cannot advance without a human.

The scorer computes what the pages currently promise: Tier B (every tongue counted, Σ=I — "an honest lie"), Tier C (family blocks), Tier C-plus (full relatedness topology: N_eff = 1ᵀΣ⁻¹1, then surprisal = −log P(recurrence | N_eff), in bits). The first run is judged against four acceptance tests pre-registered before any number existed: gift-horse must collapse to ~zero, isseki-nicho must collapse, the Persian-vs-Chinese arrow must hold, golden-rule's residual must survive. If the corrector fails those, the corrector is broken — not the corpus.

STAGE 9 — Governance (how it stays honest at speed)

• Fork pattern: new architecture never opens corpus-wide sight-unseen. One specimen → rendered card → you ratify from the finished thing (proposition track: golden-rule; superstition track: salt, in flight). Pilots are designed to surface friction, and both have.
• Every ruling is a file (spec/ruling_*.md), every decision reaches you as an MCQ, every amendment is versioned. Frozen artifacts never silently change.
• The amendment loop never closes: gates resolve → payloads amend → one-command re-render → a11y re-checks. The golden-rule card has been through three versions in 24 hours and got stronger each time, because the audit only ever removes overclaim.

The epistemic spine (what all of it serves)

Single lineage vs. independent arrival — count lineages, not languages. Filler-constancy is the lineage fingerprint; filler-variance under a shared schema is what convergence looks like. Unknowns are gated, never guessed. Honest nulls get rendered too (piece-of-cake: "not everything echoes"). For superstitions, two-level provenance (surfaces descend, mechanisms converge) plus the firewall: belief-fact, never world-fact. And the back-projections people make about their own sayings (the salt ritual's fake Roman pedigree) are themselves data, dated and displayed.