The Rubble Assayer
Hand it an untrusted blob or a prompt and it tells you: real signal, machine rubble, or a lie you didn't ask about.
The ingredients 3 gifts
The idea
You are handed a string and asked to trust it — a scraped field, a decoded payload, a prompt someone swears is safe. This assembly interrogates it three ways instead of one. legible guesses whether a string is human-readable text or machine-drawn rubble, and says how sure it is. grain compresses the data and compares its ratio against a size-matched random null model drawn live — it can tell structure from noise where a human eye can't. confessional, pointed at a prompt, reads back what the prompt does NOT constrain — the gaps you didn't think to close. Together they form an assayer: not 'is this valid?' but 'what actually is this, and what is it quietly not saying?'
The parts + how they wire
The blob enters confessional first when it's a prompt — it admits, against a closed checklist, which constraints the prompt leaves open (no length bound, no format lock, no refusal clause) → whatever survives goes to legible, which scores text-vs-rubble with a confidence number, so encrypted or corrupted or binary-masquerading-as-text gets flagged → grain is the fold that closes the verdict: it measures the string's real compressibility against a live random baseline of the same size, separating 'structured content' from 'high-entropy noise' from 'suspiciously compressible' (a red flag for padding or repetition attacks). The output is a three-axis assay card: readable?, structured?, and what-it-doesn't-constrain.
The one piece you build
The assay policy and its verdict fusion — several components, because the interesting part is what you DO with three disagreeing signals. legible says 'probably text, 0.6.' grain says 'compresses like structured JSON.' confessional says 'this prompt sets no output-length bound.' You build the router that feeds the right gift for the input type, the thresholds that turn three scores into one classification, and the escalation rules for when they conflict — which is exactly when something interesting is happening.
The technical breakdown
The three gifts are strong precisely because they measure different, non-overlapping things. legible is a surface classifier — character distribution, run structure — cheap and easily fooled alone. grain is information-theoretic: it draws a fresh random null of matched size every run and compares compression ratios, so its 'this is structured' verdict is calibrated against actual noise rather than a fixed threshold that drifts across data types. confessional is orthogonal to both — it doesn't look at entropy at all, it reads a prompt against a closed list of constraint types and reports absences. The fusion is where your judgment lives: agreement across all three is a confident verdict; disagreement (legible says rubble, grain says highly structured) is the signal that you're looking at something engineered — encoded, encrypted, or adversarial. This is a real subsystem, not glue: ~200+ lines of input routing, per-gift thresholding, conflict-resolution rules, and a verdict schema that carries all three raw scores so a human can overrule the fusion.
The honest edge
None of these prove intent. grain can tell you a string is suspiciously compressible; it cannot tell you the padding is an attack rather than a coincidence. legible's confidence is a guess about readability, not about safety — perfectly readable text can be perfectly malicious. confessional reads what a prompt fails to constrain from a closed checklist; a novel gap not on the checklist is invisible to it. The assayer's real output is not a safe/unsafe verdict — it is a well-characterized description of an unknown, with every raw score exposed. It tells you what you're holding and where the three measures disagree. Deciding to trust it is still yours.
These are ingredients, not instructions you have to follow. If you cook something from them — or something stranger — we want to see it.