# Connecting Two Poems in the Substrate: A Cross-Document Query Test on Bukowski

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

## The premise

donto does not exist to *store* claims — vector DBs and ordinary knowledge graphs already do
that. donto exists to **connect** claims **across sources** that never reference each other.
That is the lens-engine / discovery thesis: emit free, untyped, evidence-anchored claims from
every document independently; **defer typing, alignment, identity-resolution and the *join*
itself to query time**; then surface the relationship later — through shared structure, shared
vocabulary, the alignment engine, and (eventually) semantic recall — **without anyone having
pre-wired a link** between the two documents.

Two short poems are a clean, adversarial test of that thesis. They are extracted *independently*
(neither knows the other exists), they are deliberately chosen to **rhyme thematically while
sharing almost no surface vocabulary**, and the question we ask the substrate is a genuine
cross-document question: *can donto, holding only its extracted claims, connect them?* The
discipline that makes this a real test: **every query is run against the live substrate, never
against the poems.** I already know what the poems say. The point is whether **donto** knows it.

### The two poems and why they pair

Both poems are by **Charles Bukowski (1920–1994)**. The exact text, titles, and provenance of
each were web-verified before extraction; Bukowski's words were not fabricated.

| | Poem 1 | Poem 2 |
|---|---|---|
| **Title** | **"I Met a Genius"** | **"Bluebird"** |
| **Author** | Charles Bukowski | Charles Bukowski |
| **Provenance** | widely anthologised / uncollected; verified against canonical text | *The Last Night of the Earth Poems*, Black Sparrow Press, 1992; line-broken text verified against wordsfortheyear.com |
| **Substrate context** | `ctx:test/poem/bukowski-genius` | `ctx:test/poem/bukowski-bluebird` |
| **Live size** | **415** statements / **176** predicates / 51 subjects / 214 evidence links | **2,974** statements / **207** predicates / **200** subjects / 2,296 evidence links |
| **Core move** | a child on a train looks at the sea and pronounces *"it's not pretty"* — **beauty denied** | the speaker keeps a tender bluebird caged in his heart and *won't let anybody see it* — **beauty hidden** |

They turn on a single axis — **what is real vs. what is shown** — and make the *opposite* move
along it: genius *denies* the beautiful thing's beauty; the bluebird's beauty is *concealed*,
never denied. Both poems hinge on a small, unlikely truth-teller — the unnamed six-year-old in
one, the caged bluebird in the other. That mirror-image relationship (same axis, opposite move,
parallel truth-tellers) is precisely the kind of cross-document link a discovery substrate
should be able to surface from claims alone.

### How both poems entered the substrate

Poem 1 ("I Met a Genius") was already live: **415** statements in `ctx:test/poem/bukowski-genius`
(the clean run; not the cancelled `-deep` context). Poem 2 ("Bluebird") was extracted for this
test with **codex `gpt-5.4`, reasoning effort `xhigh`**, a **6-pass gleaning loop** (`xhigh`
honored on all six 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`
behind a real source document + revision so every fact anchors to a retrievable span (STATED →
anchored; INTERPRETED → hypothesis). A scratch staging context `…-bluebird-stage` (2,737 stmts)
was created by the glean auto-ingest and **left in place** (I3 — never delete); it is **excluded
from every query below**. Run logs and artifacts: `/opencode/logs/poem-bluebird/`.

---

## The method: query the store, not the poems

Every one of the 20 connecting queries 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), scoped with
   `context_prefix: ctx:test/poem` so the genealogy/genes/discord corpus does not drown the
   poems.
2. **Bounded cross-context SQL** — `SELECT`-only across **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)`, testing whether the two poems'
   *freely-minted* predicates **fold** (e.g. genius's `perceivedBy` ↔ bluebird's `concealsFrom`,
   or `hasTheme` across both contexts).

The alignment **daemon is live and healthy** (`donto_align_daemon_status`: ticking today, last
tick this session). **I3 honored throughout — every query is read-only; nothing was retracted or
overwritten.** Live re-verification at report time: bluebird **2,974** stmts / 207 preds / 200
subjects; genius **415** stmts / 176 preds; scoped FTS `"speaker"` returns **both** poems (60
bluebird + 53 genius rows, the staging context separately excluded).

### The structural backbone — the join surface

Before the 20 queries, the *shape* of the overlap, because it **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`** (genius 8, bluebird 45). Both poems
  decompose to lines, 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 20 connecting queries

**Verdict key:** **YES** = the 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.

| # | Query (cross-poem relationship probed) | Mechanism | Result | Verdict | Why |
|---|---|---|---|---|---|
| 1 | Do the two poems share any **theme** (`hasTheme`/`about` objects)? | cross-context SQL intersect on theme objects | **0** shared theme objects. Genius: "beauty versus ugliness", "perception versus convention", "the anti-sublime", `ex:ocean`. Bluebird: `ex:bluebird`, `ex:secret-pact`. Fully disjoint. | **NO** | Theme objects are freely minted per-poem; no exact overlap and no semantic fold to equate them. |
| 2 | Is **beauty / "pretty"** a shared concern? | cross-context SQL token scan (`ILIKE pretty\|beaut`) | **47** hits in genius only; **0** in bluebird (bluebird never lexicalises beauty/pretty). | **NO** | Bluebird carries beauty as a *hidden/tender* concept, not the literal token; a lexical scan can't bridge denied-beauty vs hidden-beauty. |
| 3 | Are the two **aesthetic verdicts** co-held and contrastable? | cross-context SQL on aesthetic/verdict literals | Both returned together: genius *"it's not pretty."* (×11) **and** bluebird *"it's nice enough to"*. Two incompatible verdicts held side-by-side as legal state. | **YES** | The paraconsistent store holds both aesthetic verdicts; SQL returns them together and contrastable. |
| 4 | Is there a **seeing / perception** motif in both? | cross-context SQL regex on perception predicates + literals | genius **13**, bluebird **10** perception-bearing rows. | **PARTIAL** | Both poems carry perception, but in disjoint minted vocab; the substrate shows symmetric presence but no edge equating `perceivedBy` vs `concealsFrom`. |
| 5 | **Hiding / concealment / showing** motif present and contrastable? | cross-context SQL regex `conceal\|hide\|secret\|reveal\|admit` | bluebird **15**, genius **2**. Asymmetry visible (concealment is bluebird's engine). | **PARTIAL** | The count asymmetry surfaces the contrast, but no link *asserts* the relationship. |
| 6 | **Nature imagery** — ocean (genius) vs bird/cage (bluebird)? | cross-context SQL FILTER counts over concatenated row text | genius ocean **53** / bird **0**; bluebird ocean **0** / bird **126**. Perfectly complementary. | **PARTIAL** | The substrate shows the clean complementary contrast but cannot assert that ocean and caged-bird *rhyme* as images. |
| 7 | **Truth-teller figures** — shared person/figure class? | cross-context SQL intersect on `rdf:type` classes | Only shared class is `ex:Line`. Genius: `ex:Child`/`ex:YoungChild`/`ex:FirstPersonSpeaker`; bluebird: `ex:Bird`/`ex:Heart`/`ex:Speaker`. No shared figure. | **NO** | The parallel-truth-teller link is analogical (child-genius vs caged-bird); no shared figure type and no analogy layer. |
| 8 | Is **the speaker** a shared entity across both poems? | cross-context SQL + scoped FTS `/search "speaker"` | genius **57**, bluebird **90** speaker-bearing rows. Scoped FTS returns **both** (53 genius + 60 bluebird, staging excluded). | **YES** | First-person speaker is a genuine shared anchor; FTS bridges both poems on this backbone token. |
| 9 | **Weeping / tears / grief** emotional register across both? | cross-context SQL regex + FTS `/search "weep"` | bluebird **17**, genius **0**. FTS "weep" → bluebird only. | **PARTIAL** | A real contrast surfaces (dry/ironic genius vs weeping bluebird) but one-sided; no bridge. |
| 10 | **Contradiction-preservation** — incompatible verdicts as paraconsistent state? | cross-context SQL on `describedAs`/judgment predicates | Genius holds `describedAs "genius"` **and** `describedAs "not pretty"` **and** `isJudgedNotPrettyBy ex:child`; bluebird holds `selfDescribesAsTough "too tough"`. All co-held, none invalidated. | **YES** | The paraconsistent differentiator is exercised: incompatible self-/other-descriptions held together and queryable. |
| 11 | **"genius"** token — present in one poem, absent in the other? | cross-context SQL + FTS `"genius"` | genius **12**, bluebird **0**. The substrate correctly knows the token is poem-1-only. | **YES** (as a *distinguisher*) | Correct *anti*-connection: the store cleanly separates poem-specific vocabulary. |
| 12 | **"heart"** motif — bluebird's core vs genius? | cross-context SQL + FTS `"heart"` | bluebird **48**, genius **0**. FTS "heart" scoped → bluebird only. | **PARTIAL** | One-sided; no bridge to genius's ocean-as-heart-substitute (a semantic, not lexical, link). |
| 13 | **Line-level structure** — do both decompose to `ex:Line`? | cross-context SQL count `rdf:type = ex:Line` | genius **8**, bluebird **45**. The one shared `rdf:type` class. | **YES** | `ex:Line` is a real structural join; a query for the lines of both poems works. |
| 14 | **The unspoken** — "nobody to see" (bluebird) vs "what genius won't admit" (genius)? | cross-context SQL regex on object literals `nobody\|will not\|admit\|refus` | Only genius's *"refusal of the Romantic-sublime sea"* matched; bluebird's idea is encoded as the *predicate* `doesNotWantAnybodyToSee`, invisible to a literal scan. | **NO** | Encoding mismatch (predicate vs literal) plus semantic distance defeats the lexical probe; needs embeddings. |
| 15 | **Shared subject IRIs** verbatim (entity overlap)? | cross-context SQL intersect on subject | **7** shared: `ex:line-1 … ex:line-11`. Pure structural collision (both mint `ex:line-N`). | **PARTIAL** | Structural collision only; no semantic entity is genuinely shared between the poems. |
| 16 | **Shared object-literal phrasing** verbatim (>4 chars)? | cross-context SQL intersect on lowered object literals | **0** shared phrases. Vocab fully disjoint at the literal level. | **NO** | The two poems share no exact phrasing; abundance signature, no lexical bridge. |
| 17 | **Tone / mood** register across both? | cross-context SQL regex `tone\|mood\|ironic\|tender\|bitter` | genius **5**, bluebird **5**. Both carry tone claims (ironic/defiant vs tender/resigned). | **PARTIAL** | Symmetric presence of tone claims, but no edge equates or contrasts the specific tones. |
| 18 | **Cross-poem predicate fold** — does alignment link a genius-only pred to a bluebird-only pred? | `donto_predicate_alignment` (19,849 edges), cross-poem filter | **0** cross-poem fold edges. **911** alignment edges touch the poems' predicates; **53 of 372** poem predicates known to the engine (daemon mid-backlog, live, last tick today). | **NO** | The daemon is live and processing the poems but has proposed no genius↔bluebird fold yet; the fold as deployed is lexical-only. |
| 19 | **`hasTheme` fold** — does expanding `hasTheme` reach both poems' themes as one query? | `donto_match_aligned(p_predicate:=hasTheme, p_expand_predicates:=true)` | Returns **both** poems' theme rows (bluebird `ex:bluebird`, genius `ex:train`) under one query; does **not** fold the objects (`ex:bluebird` vs `ex:ocean` stay distinct). | **PARTIAL** | Cross-context predicate-fold plumbing works and reaches both poems, but object-level semantic fold is absent. |
| 20 | **Perception fold** — do `perceives/sees/observes`-family predicates align across the poems? | `donto_predicate_alignment` regex on perception-family endpoints | Existing perception-family fold edges are all **lexical** (`viewedAs`↔`ex:viewedas`, `containsNotices`↔`containsNotice`) and all from the **genealogy** corpus. None bridge genius's `perceivedBy`/`isJudgedNotPrettyBy` to bluebird's `concealsFrom`/`doesNotWantAnybodyToSee`. | **NO** | Lexical alignment cannot fold lexically-distant perception predicates; needs semantic (embedding) alignment. |

### Tally

**6 YES · 7 PARTIAL · 7 NO.**

- **YES (6):** Q3, Q8, Q10, Q11, Q13 — shared structure (`ex:Line`), the shared first-person
  speaker anchor, paraconsistent co-holding of the two aesthetic verdicts, and the correct
  *anti*-connection on poem-specific tokens.
- **PARTIAL (7):** Q4, Q5, Q6, Q9, Q12, Q15, Q17 (with 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.

---

## Honest capability assessment

### What donto connects well — today, deployed

- **Shared structural vocabulary (`/search` + SQL).** 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.
- **Shared predicates / contexts.** Cross-context SQL is a first-class connector: the 14-family
  model means both poems live in one store, addressable together, and the backbone predicates
  give SQL a real comparison surface (not a coincidence of vocabulary).
- **Alignment-closure predicate folding.** `donto_match_aligned(p_expand_predicates:=true)` on
  `hasTheme` *does* expand a single query to reach **both** poem contexts at once (Q19). The
  cross-context fold machinery is wired and live (911 edges already touch these predicates).
- **Contradiction-preservation as a *connection*.** 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. donto's
  differentiator is that the *contrast itself is the cross-document link*, queryable and never
  invalidated.

### Where donto is honestly limited — built-but-dark or unbuilt

- **Semantic resonance is invisible (awaits the deployed hybrid vector recall).** 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. They need 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* (19,849 edges,
  ticking 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 query 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`).

---

## What this demonstrates about donto as a cross-document substrate

**Yes — partially, and exactly where the architecture predicts.** donto connects 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 available of the **emit-free / defer-the-join-to-query-time**
thesis. Two poems that share **~3% of their predicates** (Jaccard ≈ 0.03) — minted independently,
with no pre-wired link — are nonetheless **side-by-side, contrastable, and
contradiction-preserving** in the store right now, with the semantic join a known, scoped,
*measurable* increment away. The discovery vision is not refuted by the 7 NO verdicts; it is
*located*: the structural and contradiction-preserving connectors are real and deployed, and the
semantic / analogical connectors are a concrete, named, in-progress next step rather than a
research mystery. A cross-document connection substrate that gets the structure, the vocabulary,
and the *contradiction* right today — and has the semantic layer built and waiting — is doing
exactly the job it was designed for.

---

*All queries `SELECT`-only (I3 honored; nothing retracted or overwritten). Mechanisms:
donto-memory `POST /search` (substrate-wide FTS), bounded cross-context SQL on `donto-pg`, and
`donto_predicate_alignment` / `donto_match_aligned`. The scratch staging context
`ctx:test/poem/bukowski-bluebird-stage` (2,737 stmts) was kept in place and excluded from every
query. 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`, `query-results.txt`,
`consolidated-connection-data.txt`).*