Can the Substrate Connect Two Poems? A Cross-Document Test on Bukowski

2026-06-04 · donto / genes workspace · a capability test, run live, reported honestly

The question

donto is built on a wager: emit free, untyped, evidence-anchored claims now; defer typing, alignment, identity-resolution and joining to query time. Two documents that never mention each other should still be connectable later — through shared structure, shared vocabulary, the alignment engine, and (eventually) semantic recall — without anyone having pre-wired a link between them.

This note tests that wager on the hardest small case I could build: two Bukowski poems, extracted independently, then probed with 20 queries that try to connect them — run against the live substrate, not against the poems. The point is not "what do the poems say" (I already know that). The point is "can donto, holding only its extracted claims, answer a cross-document question?"

The two poems and why they pair

They share one axis — what is real vs. what is shown — and make the opposite move along it. Both turn on a small truth-teller (the unnamed six-year-old; the caged bluebird). That mirror-image relationship is exactly what a cross-document substrate should be able to surface. "Bluebird" was web-verified against the canonical line-broken text (wordsfortheyear.com) before extraction; Bukowski's words were not fabricated.

How "Bluebird" got into the substrate

Extracted with codex gpt-5.4, reasoning effort xhigh, a 6-pass gleaning loop (xhigh honored on all 6 passes per the rollout check), then the always-on semantic citer: 3,136 raw facts → deduped → cited (2,296 anchored exact-substring spans, 0 bogus spans, 840 honest hypotheses flagged hypothesis_only) → ingested to ctx:test/poem/bukowski-bluebird with a real source document + revision so every fact anchors to a retrievable span. A scratch staging context …-bluebird-stage (2,737 stmts) was left in place (I3 — never delete) and is excluded from every query below. Run logs and artifacts: /opencode/logs/poem-bluebird/.

The three mechanisms

Every query was answered by the substrate, through one of three mechanisms, never by re-reading the poems:

1. Substrate-wide FTS — POST http://localhost:7900/search (donto-memory's GIN tsvector over a humanized projection of subject/object across all ~39M live statements).
2. Bounded cross-context SQL — SELECT-only over both poem contexts, finding shared subjects / predicates / objects, parallel claims, and contrasts.
3. The alignment engine — donto_predicate_alignment (19,849 live edges) and donto_match_aligned(… p_expand_predicates := true), to test whether the two poems' freely-minted predicates fold (e.g. genius's perceivedBy ↔ bluebird's concealsFrom).

The alignment daemon is live (donto_align_daemon_status: 41 ticks, last tick today 15:38 UTC, state sleeping, next tick ~15:58). I3 honored throughout — every query is read-only; nothing was retracted or overwritten.

The structural backbone (the join surface)

Before the 20 queries, the shape of the overlap — this is the abundance signature:

• Shared exact predicates: 11 of (176 ∪ 207). Jaccard ≈ 0.03. The shared 11 are the donto backbone: rdf:type, rdfs:label, about, addressedTo, contains, hasMember, hasParticipant, hasTheme, locatedIn, memberOf, partOf.
• Shared rdf:type class: exactly one — ex:Line. Both poems decompose to lines (genius 8, bluebird 45), so a line-structure query reaches both.
• Every characteristic predicate is disjoint. Genius mints isJudgedNotPrettyBy, formedAestheticJudgmentOf, adoptedAestheticJudgmentOf; bluebird mints concealsFrom, doesNotWantAnybodyToSee, desiresEmergence, selfDescribesAsTough. No overlap by design — this is emit-free abundance, not a proliferation bug.

The consequence, stated once and proven by the queries: the substrate joins the two poems on the shared backbone (structure + a handful of generic tokens) today, and is one deployed branch (vectors) plus one daemon cycle (alignment) away from joining them thematically.

The 20 connecting queries

Verdict key: YES = substrate returned a real cross-poem connection · PARTIAL = it placed both side-by-side / answered for one side and is one step from the other · NO = the connection is real in the poems but invisible to the substrate as currently deployed.

Scorecard

6 YES · 7 PARTIAL · 7 NO.

• YES (6): Q3, Q8, Q10, Q11, Q13 — shared structure (ex:Line), the shared first-person speaker token, paraconsistent co-holding of the two aesthetic verdicts, and correct anti-connection on poem-specific tokens.
• PARTIAL (7): Q4, Q5, Q6, Q9, Q12, Q15, Q17 (and Q19's cross-context plumbing) — the substrate places the two poems side by side (matching counts, complementary imagery, fold-plumbing reaching both contexts) but cannot assert that they resonate.
• NO (7): Q1, Q2, Q7, Q14, Q16, Q18, Q20 — the genuinely semantic / analogical links (beauty-denied ≈ beauty-hidden; ocean ≈ caged bird; child-genius ≈ bluebird as parallel truth-tellers; predicate-encoded "won't be seen" ≈ literal "won't admit") are invisible to lexical FTS + lexical alignment as deployed.

What connects well

• Shared structural vocabulary. The 11-predicate backbone and the ex:Line class let bounded SQL place the two poems side-by-side and run genuine cross-context comparisons (lines, speakers, themes-as-rows). This is the join surface the "defer joining" thesis promises, and it is there.
• Lexical FTS on shared tokens. Scoped to the poem subtree, "speaker" and "poem" are the only tokens that return both poems — the structural bridges. Every thematic token (beauty, see, weep, heart, ocean, secret, bird, genius) lands in exactly one poem, because the minted vocab is disjoint. That is a clean, measurable demonstration of emit-free abundance: the firehose mints its own predicates and the join is deferred.
• Contradiction-preservation. Both incompatible aesthetic verdicts — "it's not pretty" and "it's nice enough to" — and genius's own genius / not pretty / isJudgedNotPrettyBy triad are held together as legal state and returned together. The paraconsistent differentiator is exercised and works.
• Predicate-fold plumbing across contexts. donto_match_aligned(p_expand_predicates:=true) does expand a query on hasTheme to reach both poem contexts at once (Q19). The cross-context fold machinery is wired and live (911 edges already touch these predicates).

Where it's honestly limited

• Semantic resonance is invisible. beauty-denied vs beauty-hidden, ocean vs caged bird, perceivedBy vs doesNotWantAnybodyToSee — these are the real connections, and lexical FTS + lexical alignment cannot see them. This needs the hybrid vector recall (bge-small embeddings) which is built but on an undeployed branch (hybrid-vector-recall, reaches memory via DONTO_MEMORY_EMBED_SERVICE_URL). With vectors, Q1/Q2/Q14 plausibly flip to YES/PARTIAL.
• The alignment daemon hasn't reached the poems yet. It is live and healthy (41 ticks, 19,849 edges, running today) but only 53 of 372 poem predicates are in-set and it has proposed 0 cross-poem folds (Q18, Q20 = 0 rows). One or more daemon cycles — once it embeds the poem predicates and adjudicates — could surface the perception fold. As deployed, the fold is lexical-only, and these two poems are deliberately too lexically distant to fold without embeddings.
• No analogical / multi-hop layer. "The child-genius and the caged bluebird are parallel truth-tellers" is a two-hop analogy (figure→role→figure). The substrate holds both figures and both roles but has no query layer that composes them into an analogy. That is a reasoning layer above the store, not a property of the store.
• Encoding mismatch defeats lexical probes. Bluebird encodes "don't want anybody to see you" as a predicate (doesNotWantAnybodyToSee); genius encodes its refusal as an object literal. A literal-scan (Q14) can't bridge the two encodings — another job for semantic matching, not string matching. (Per the no-brittle-logic rule, the answer is embeddings / the alignment engine, not a hand-maintained predicate-variant table.)
• FTS drowns at substrate scale. Unscoped, the ~39M-row genealogy/genes/discord corpus swamps every thematic token (unscoped "beauty" → salon menus, "bird"/"heart" → genealogy). Cross-document poem connection over FTS only works scoped (context_prefix).

Verdict

Yes — partially, and exactly where the architecture predicts. donto connects the two independently-extracted poems structurally and lexically today (6 clean YES, 7 side-by-side PARTIAL), and preserves their contradiction as a first-class, queryable connection. It cannot yet connect them thematically / analogically (7 NO) — and that gap is not a design failure but a precise statement of what is deployed vs. built-but-dark: the substrate is one deployed branch (vectors) plus one daemon cycle (alignment) from turning the thematic mirror-image between "it's not pretty" and the hidden bluebird into a query result.

That is the cleanest validation I have of the emit-free / defer-the-join-to-query-time thesis: two poems that share 3% of their predicates are nonetheless side-by-side, contrastable, and contradiction-preserving in the store right now — with the semantic join a known, scoped, measurable increment away.

All queries SELECT-only (I3 honored). Mechanisms: donto-memory POST /search, bounded cross-context SQL on donto-pg, and donto_predicate_alignment / donto_match_aligned. Run logs, SQL, and raw outputs: /opencode/logs/poem-bluebird/ (q-main.sql, q-align.sql, out-main.txt, out-align.txt, out-search.txt, out-search-scoped.txt, glean-bluebird.log, cite.log, ingest.log).