@hviana/sema 0.7.5 → 0.7.7

package/dist/src/mind/graph-search.d.ts

@@ -73,6 +73,12 @@ export type GItem = {
      *  derivation actually CHOSE.  Part of {@link key}, because it decides
      *  whether the span's final bytes may still change. */
     fix?: boolean;
+    /** Set on the out a JOIN produced: a produced fact's own contained entity
+     *  (the subject the query never named) combined with the query's adjacent
+     *  relation span named a learned key, and that key's continuation is this
+     *  out.  Part of {@link key} so the joined reading is a distinct chart item
+     *  from the plain concatenation of the same bytes. */
+    join?: boolean;
 };
 export declare const STEP = 1;
 export declare const CONCEPT = 10;
@@ -136,7 +142,7 @@ export interface DerivationItem {
  *  {@link GraphSearch}'s rules fired, recovered from the rule's premise/
  *  conclusion shape (the rules carry no label, so this classifies by structure,
  *  the single place that maps rule geometry to a name). */
-export type DerivationMove = "axiom" | "follow-edge" | "concept-hop" | "voice" | "ground" | "splice-connector" | "split" | "fuse" | "recompose" | "bridge" | "pool-vote" | "step";
+export type DerivationMove = "axiom" | "follow-edge" | "concept-hop" | "voice" | "ground" | "splice-connector" | "split" | "fuse" | "recompose" | "join-fact" | "bridge" | "pool-vote" | "step";
 /** The lightest-derivation search over the Sema graph.  One instance binds the
  *  store, `maxGroup` (the fusible span ceiling), and the canonical
  *  {@link resolve} callback; {@link cover} then solves one query. */
@@ -270,42 +276,67 @@ export declare class GraphSearch {
      *  and recompose into a deeper learnt form (→ FINAL).  This is why a single
      *  edge-target needs no bespoke logic — it routes back through {@link solve}.
      *
-     *  Re-recognition (not the node's tree children) is what surfaces the learnt
-     *  parts: content-defined chunking may cut "p1 p2" as "p1 p"|"2", so only
-     *  recognising the bytes recovers p1 and p2 as the forms the graph knows.
+     *  The produced bytes are decomposed by the machinery that owns their shape:
+     *  the span's LEAVES and SPLITS drive the split rule, which resolves each half
+     *  through findLeaf — so a part that straddles a content-defined cut is still
+     *  recovered even though the node's tree children need not align with the
+     *  learnt parts (the fold cuts "p1 p2" as "p1 p"|"2").  Recognised SITES are
+     *  filtered to the node's own kids: a produced form is completed out of what
+     *  it was built from, never by re-recognising arbitrary forms inside it.  That
+     *  filter is load-bearing — a 37-byte dialogue sentence carries seven hub
+     *  openers, and re-covering them chained through the corpus's whole
+     *  continuation population: 2.5 GB and OOM for `respond("hi.")`.
      *
      *  The recovered answer is accepted only when it MOVED and names a LEARNT node
      *  ({@link resolve}) — the graph itself gates against re-expanding a contained
-     *  form ("ice is cold" ⊅→ "ice is cold is cold").
+     *  form ("ice is cold" ⊅→ "ice is cold is cold").  An ACCEPTED completion is
+     *  then re-covered in turn, so a chain runs as deep as the graph licenses; a
+     *  rejected one ends its branch, so no work is spent past it.
      *
-     *  Termination is STRUCTURAL: a produced node is re-covered once, never inside
-     *  another re-cover (see the guard below), so one cover pays at most one
-     *  nested {@link solve} per distinct produced node it actually reaches, and
-     *  {@link recompleteMemo} collapses a repeat to nothing.
-     *
-     *  This comment used to argue termination from "distinct node ids are finite
-     *  and each finished completion is memoised".  That is a bound of N — the one
-     *  AGENTS §2.8 forbids — and it was load-bearing, not pedantic: nested, the
-     *  recursion reached depth 331 and 9.1 GB on an 18.9M-node store for a 2-byte
-     *  query and did not terminate, which is what killed a 5 h training run at its
-     *  checkpoint recall.  Guard: test/89-completion-recursion.test.mjs. */
+     *  Termination and cost are STRUCTURAL: {@link recompleteOpen} is the chain's
+     *  stack (membership is the cycle guard), {@link recompleteMemo} re-covers each
+     *  node at most once, only accepted completions recurse, and every level
+     *  deepens only the top derivation — so a cover pays for the chain it finds,
+     *  not for how densely the corpus interconnects the forms it passes through.
+     *  Guard: test/89-completion-recursion.test.mjs. */
     private recompleteNode;
     /** Per-cover memo of each produced node's completion (so the many terminal
      *  outs of a long query re-cover each distinct node at most once); reset at the
      *  top of {@link cover}. */
     private recompleteMemo;
-    /** The node currently being re-completed — the recursion stack, and so also
-     *  the nesting depth.  {@link recompleteNode} refuses to start while it is
-     *  non-empty (one re-cover per produced node, never one inside another), which
-     *  is what keeps a query's cost proportional to its answer rather than to the
-     *  corpus; it therefore holds at most one id.  A Set, not a flag, because it
-     *  states WHICH node is open — the invariant a reader needs to check the
-     *  guard, and what makes the old cycle-guard reading still hold. */
+    /** The derivation sink of the TOP cover, threaded into every nested
+     *  completion so a produced form's own recompositions are reported in the
+     *  same trace instead of vanishing after the first layer.  Undefined when
+     *  nothing is inspecting, so an uninspected response pays nothing. */
+    private derivationSink?;
+    /** The chain of nodes currently being re-completed — the recursion STACK.
+     *  MEMBERSHIP is the cycle guard ({@link recompleteNode} refuses a node
+     *  already open on this chain), which is what lets a completion recurse as
+     *  deep as the graph licenses while the work stays the answer's: the
+     *  recursion only advances through an ACCEPTED completion, every produced
+     *  form is decomposed into its own kids, and the memo re-covers each node at
+     *  most once per cover.  A Set, not a flag, because it states WHICH node is
+     *  open — the invariant a reader needs to check the guard. */
     private recompleteOpen;
+    /** JOIN — the move the substrate was missing: derive the answer THROUGH a
+     *  produced fact, without the intermediate key being named in the query.
+     *
+     *  A produced fact (`fact.node`) carries the subject the query reached but
+     *  never wrote; the query's remaining tail names the relation to follow from
+     *  it.  The pair IS a learned key — `"<entity><tail>"` — so the rule asks the
+     *  store for that key's continuation and, when it exists, concludes with the
+     *  joined fact.  On the ladder it is one STEP: a direct edge, exactly as
+     *  following a literal continuation is.  Deterministic and point-probed
+     *  (`resolve` + `nextFirst`, no scan), so it adds no read that grows with the
+     *  corpus.  The move is visible in the rationale as its own act
+     *  (`classifyMove` reports `join-fact`), distinct from the byte-concatenating
+     *  `fuse`/`splice`. */
+    private join;
     /** out(i,j,bytes,…): index it for the binary rules, then offer splicing a
      *  learnt connector (the in-search bridge), splitting (at a sub-leaf form
-     *  boundary), bridging (cover(i) ∧ this → cover(j)), and fusing with an
-     *  adjacent finalised out. */
+     *  boundary), bridging (cover(i) ∧ this → cover(j)), fusing with an adjacent
+     *  finalised out, and — for a produced fact — JOINING the entity it contains
+     *  with the query's tail ({@link join}). */
     private outRules;
     /** Whether the query span [from, to) is wholly covered by RECOGNISED outs —
      *  the test that lets a connector jump across INTERIOR answers (an N-ary whole)

package/dist/src/mind/graph-search.js

@@ -101,8 +101,11 @@ function classifyMove(premises, conclusion, articulating) {
                 return "step";
             return articulating ? "voice" : "ground";
         }
-        if (p.kind === "out" && conclusion.kind === "out")
-            return "split";
+        if (p.kind === "out" && conclusion.kind === "out") {
+            // A JOIN derives through a produced fact's own contained subject; a plain
+            // single-premise out→out is the byte-level split.
+            return conclusion.join ? "join-fact" : "split";
+        }
         return "step";
     }
     if (premises.length === 2) {
@@ -230,12 +233,26 @@ export class GraphSearch {
         // through (completion is cover, recursively — see {@link recompleteNode}).
         this.recompleteOpen.clear();
         this.recompleteMemo = new Map();
-        return this.solve(queryLen, {
+        // The top cover's derivation sink is threaded into every nested completion
+        // so the recompositions a produced form needs are reported in the same
+        // trace instead of vanishing after the first layer.
+        this.derivationSink = onDerivation;
+        const solved = this.solve(queryLen, {
             sites,
             leaves,
             splits,
             starts,
         }, conceptTarget, substitutions, connectors, computedResults, onDerivation);
+        // Deepening runs HERE, once, on the derivation the top cover CHOSE — never
+        // inside the nested solve a completion runs.  Nesting the deepening is what
+        // made per-query cost track how densely the corpus interconnects the forms
+        // passed through: every re-cover fanned out into the whole corpus's
+        // continuations instead of following the chain the answer itself licensed.
+        // With deepening only at the top, `recompleteNode` walks the accepted chain
+        // one link at a time (its own memo and stack), so the work is the answer's.
+        return solved === null
+            ? null
+            : { segs: this.deepen(solved.segs), cost: solved.cost };
     }
     /** Build the deduction system for one span and return its lightest cover's
      *  chosen spans — the SINGLE routine the query and every produced composite
@@ -270,7 +287,7 @@ export class GraphSearch {
             onDerivation(readDerivation(derivation, substitutions !== undefined));
         }
         return derivation
-            ? { segs: this.deepen(readCover(derivation)), cost: derivation.cost }
+            ? { segs: readCover(derivation), cost: derivation.cost }
             : null;
     }
     /** Re-cover the CHOSEN fixpoint spans, in place.
@@ -311,6 +328,13 @@ export class GraphSearch {
         // states the formula itself instead of importing it.
         const atomsAreHubs = Math.max(1, Math.ceil((this.store.edgeSourceCount() * W) / 256)) > this.hubBound();
         const nodeBytes = (n) => this.store.bytesPrefix(n, ALL);
+        // The query's own bytes, tiled from its perceived leaves.  A JOIN reads the
+        // tail a produced fact's contained entity has to combine with, and `buildSearch`
+        // otherwise only ever sees positions, never the bytes behind them.
+        const queryBytes = new Uint8Array(queryLen);
+        for (const lf of leaves) {
+            queryBytes.set(lf.bytes.subarray(0, lf.end - lf.start), lf.start);
+        }
         // Content-addressed probes over the store's hash-cons maps — the same keys
         // training filled.  No byte-by-byte trie walk.
         const findLeafU = (b) => this.store.findLeaf(b) ?? undefined;
@@ -343,7 +367,7 @@ export class GraphSearch {
                 if (it.kind === "form") {
                     return `f${it.i}.${it.j}.${it.node}.${it.via ? 1 : 0}.${it.rcmp ? 1 : 0}`;
                 }
-                return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${it.fix ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
+                return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${it.fix ? 1 : 0}.${it.join ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
             },
             *axioms() {
                 yield { item: { kind: "cover", p: 0 }, cost: 0 };
@@ -451,6 +475,8 @@ export class GraphSearch {
                     findBranchU,
                     linksByLeft,
                     linksByRight,
+                    queryBytes,
+                    queryLen,
                 });
             },
         };
@@ -722,55 +748,51 @@ export class GraphSearch {
      *  and recompose into a deeper learnt form (→ FINAL).  This is why a single
      *  edge-target needs no bespoke logic — it routes back through {@link solve}.
      *
-     *  Re-recognition (not the node's tree children) is what surfaces the learnt
-     *  parts: content-defined chunking may cut "p1 p2" as "p1 p"|"2", so only
-     *  recognising the bytes recovers p1 and p2 as the forms the graph knows.
+     *  The produced bytes are decomposed by the machinery that owns their shape:
+     *  the span's LEAVES and SPLITS drive the split rule, which resolves each half
+     *  through findLeaf — so a part that straddles a content-defined cut is still
+     *  recovered even though the node's tree children need not align with the
+     *  learnt parts (the fold cuts "p1 p2" as "p1 p"|"2").  Recognised SITES are
+     *  filtered to the node's own kids: a produced form is completed out of what
+     *  it was built from, never by re-recognising arbitrary forms inside it.  That
+     *  filter is load-bearing — a 37-byte dialogue sentence carries seven hub
+     *  openers, and re-covering them chained through the corpus's whole
+     *  continuation population: 2.5 GB and OOM for `respond("hi.")`.
      *
      *  The recovered answer is accepted only when it MOVED and names a LEARNT node
      *  ({@link resolve}) — the graph itself gates against re-expanding a contained
-     *  form ("ice is cold" ⊅→ "ice is cold is cold").
-     *
-     *  Termination is STRUCTURAL: a produced node is re-covered once, never inside
-     *  another re-cover (see the guard below), so one cover pays at most one
-     *  nested {@link solve} per distinct produced node it actually reaches, and
-     *  {@link recompleteMemo} collapses a repeat to nothing.
+     *  form ("ice is cold" ⊅→ "ice is cold is cold").  An ACCEPTED completion is
+     *  then re-covered in turn, so a chain runs as deep as the graph licenses; a
+     *  rejected one ends its branch, so no work is spent past it.
      *
-     *  This comment used to argue termination from "distinct node ids are finite
-     *  and each finished completion is memoised".  That is a bound of N — the one
-     *  AGENTS §2.8 forbids — and it was load-bearing, not pedantic: nested, the
-     *  recursion reached depth 331 and 9.1 GB on an 18.9M-node store for a 2-byte
-     *  query and did not terminate, which is what killed a 5 h training run at its
-     *  checkpoint recall.  Guard: test/89-completion-recursion.test.mjs. */
+     *  Termination and cost are STRUCTURAL: {@link recompleteOpen} is the chain's
+     *  stack (membership is the cycle guard), {@link recompleteMemo} re-covers each
+     *  node at most once, only accepted completions recurse, and every level
+     *  deepens only the top derivation — so a cover pays for the chain it finds,
+     *  not for how densely the corpus interconnects the forms it passes through.
+     *  Guard: test/89-completion-recursion.test.mjs. */
     recompleteNode(node) {
         if (!this.host.recogniseSpan)
             return null;
         const memo = this.recompleteMemo;
         if (memo.has(node))
             return memo.get(node) ?? null;
-        // ONE re-cover per produced node — never a re-cover inside a re-cover.
-        //
         // Re-covering is how a PRODUCED node's bytes enter the search at all: the
-        // cover machinery otherwise only ever sees the QUERY's spans.  That is
-        // needed once.  The alternation of decomposition and recomposition that
-        // follows — parts rewriting several times, siblings fusing, a recomposition
-        // feeding another — is the main search's own fuse/`rcmp` work, not this
-        // recursion's: 15-decomposition-gap §9–§12 all pass with this method
-        // disabled outright, and only §6 (the produced composite "p1 p2", whose
-        // bytes nothing else brings in) needs it.
-        //
-        // Nesting it was the defect.  Each level is a full {@link solve} with its
-        // own agenda and chart, exploring from a node the answer never asked about,
-        // so per-query cost tracked how densely the corpus interconnects the forms
-        // passed through — the growth AGENTS §2.8 forbids.  Measured on an
-        // 18.9M-node store: depth 331 and 9.1 GB for a 2-byte query, not
-        // terminating; and on the guard corpus every one of 125 nested re-covers
-        // was REJECTED by the resolve() gate below, expanding a 70-byte node into a
-        // 374-byte concatenation that names nothing.  All of it was waste.
+        // cover machinery otherwise only ever sees the QUERY's spans.  The recursion
+        // is allowed to nest — a chain IS nested completions — but it is bounded so
+        // the work stays the ANSWER's (AGENTS §2.8): the stack below is the cycle
+        // guard, only ACCEPTED completions recurse, and the nested solve decomposes
+        // the form by its own shape instead of re-recognising the corpus's hub forms
+        // inside it.
         //
-        // `recompleteOpen` is that stack, so a non-empty stack means we are already
-        // inside one.  This subsumes the old cycle guard: a node cannot recurse
-        // back into itself when nothing recurses at all.
-        if (this.recompleteOpen.size > 0)
+        // `recompleteOpen` IS the stack of the chain being built, so MEMBERSHIP is
+        // the cycle guard: a node already open on this chain cannot re-enter it.
+        // Testing the NODE — not the stack's size — is what lets a completion
+        // recurse as deep as the graph licenses, exactly the intrinsic convergence
+        // {@link solve}'s contract states.  Work stays the answer's because the
+        // recursion only ever advances through an ACCEPTED completion (below) and
+        // {@link cover} deepens only the top derivation.
+        if (this.recompleteOpen.has(node))
             return null;
         // A leaf or single-child node has no parts to recompose; skip before the
         // costly recognition so a plain terminal answer pays nothing.
@@ -782,16 +804,43 @@ export class GraphSearch {
         const bytes = this.store.bytesPrefix(node, ALL);
         this.recompleteOpen.add(node);
         try {
-            // Completion is cover: re-cover the produced bytes through the SAME solve
-            // routine, recognising them afresh.  No concepts/connectors (those need the
-            // caller's async pre-resolution) — the recursion explores edges and fusion,
-            // which is what a deeper rewrite chain is made of.
-            const solved = this.solve(bytes.length, this.host.recogniseSpan(bytes), new Map());
+            // Completion is cover, but the produced form is decomposed by its own
+            // shape.  The LEAVES and SPLITS are kept whole, so the split rule still
+            // recovers a part that straddles a content-defined cut (the fold cuts
+            // "p1 p2" as "p1 p"|"2", and findLeaf still resolves p1 and p2).  The
+            // recognised SITES are filtered to the node's own kids, because
+            // re-recognising arbitrary forms inside the bytes is what let a hub-heavy
+            // utterance explode: a 37-byte dialogue sentence carries seven hub
+            // openers, and re-covering them chained through the corpus's whole
+            // continuation population (2.5 GB and OOM for `"hi."`).  No
+            // concepts/connectors either (those need the caller's async
+            // pre-resolution) — the recursion follows edges and fusion, which is what
+            // a deeper rewrite chain is made of.
+            const rec = this.host.recogniseSpan(bytes);
+            const kids = new Set(nrec.kids);
+            const solved = this.solve(bytes.length, {
+                sites: rec.sites.filter((s) => kids.has(s.payload)),
+                leaves: rec.leaves,
+                splits: rec.splits,
+                starts: rec.starts,
+            }, new Map(), undefined, undefined, undefined, this.derivationSink);
             const answer = solved && concatBytes(solved.segs.map((s) => s.bytes));
-            const out = (answer !== null && !bytesEqual(answer, bytes) &&
-                this.host.resolve(answer) !== null)
-                ? answer
+            // ACCEPT, then CONTINUE THE CHAIN — but only along an accepted
+            // completion.  A re-cover whose result is not itself a learnt node (the
+            // 70→374-byte concatenations that name nothing) ends its branch here
+            // instead of recursing into work the answer never asked for, and an
+            // accepted one names a node that is re-covered in turn.  That is what
+            // keeps a deep chain possible while the work stays proportional to the
+            // chain rather than to the corpus's interconnections.
+            const composed = answer !== null && !bytesEqual(answer, bytes)
+                ? this.host.resolve(answer)
                 : null;
+            if (composed === null) {
+                memo.set(node, null);
+                return null;
+            }
+            const deeper = this.recompleteNode(composed);
+            const out = deeper ?? answer;
             memo.set(node, out);
             return out;
         }
@@ -803,18 +852,76 @@ export class GraphSearch {
      *  outs of a long query re-cover each distinct node at most once); reset at the
      *  top of {@link cover}. */
     recompleteMemo = new Map();
-    /** The node currently being re-completed — the recursion stack, and so also
-     *  the nesting depth.  {@link recompleteNode} refuses to start while it is
-     *  non-empty (one re-cover per produced node, never one inside another), which
-     *  is what keeps a query's cost proportional to its answer rather than to the
-     *  corpus; it therefore holds at most one id.  A Set, not a flag, because it
-     *  states WHICH node is open — the invariant a reader needs to check the
-     *  guard, and what makes the old cycle-guard reading still hold. */
+    /** The derivation sink of the TOP cover, threaded into every nested
+     *  completion so a produced form's own recompositions are reported in the
+     *  same trace instead of vanishing after the first layer.  Undefined when
+     *  nothing is inspecting, so an uninspected response pays nothing. */
+    derivationSink;
+    /** The chain of nodes currently being re-completed — the recursion STACK.
+     *  MEMBERSHIP is the cycle guard ({@link recompleteNode} refuses a node
+     *  already open on this chain), which is what lets a completion recurse as
+     *  deep as the graph licenses while the work stays the answer's: the
+     *  recursion only advances through an ACCEPTED completion, every produced
+     *  form is decomposed into its own kids, and the memo re-covers each node at
+     *  most once per cover.  A Set, not a flag, because it states WHICH node is
+     *  open — the invariant a reader needs to check the guard. */
     recompleteOpen = new Set();
+    /** JOIN — the move the substrate was missing: derive the answer THROUGH a
+     *  produced fact, without the intermediate key being named in the query.
+     *
+     *  A produced fact (`fact.node`) carries the subject the query reached but
+     *  never wrote; the query's remaining tail names the relation to follow from
+     *  it.  The pair IS a learned key — `"<entity><tail>"` — so the rule asks the
+     *  store for that key's continuation and, when it exists, concludes with the
+     *  joined fact.  On the ladder it is one STEP: a direct edge, exactly as
+     *  following a literal continuation is.  Deterministic and point-probed
+     *  (`resolve` + `nextFirst`, no scan), so it adds no read that grows with the
+     *  corpus.  The move is visible in the rationale as its own act
+     *  (`classifyMove` reports `join-fact`), distinct from the byte-concatenating
+     *  `fuse`/`splice`. */
+    *join(fact, queryBytes, queryLen) {
+        if (!this.host.recogniseSpan)
+            return;
+        const tail = queryBytes.subarray(fact.j, queryLen);
+        if (tail.length === 0)
+            return;
+        // The entity candidates are the forms the fact's own bytes CONTAIN — the
+        // same recogniser the query went through, so the evidence standard is the
+        // query's.  A byte atom is never a subject; the fact's own node is the span
+        // itself, not an entity inside it.
+        for (const site of this.host.recogniseSpan(fact.bytes).sites) {
+            if (site.payload < 0 || site.payload === fact.node)
+                continue;
+            if (!this.store.hasNext(site.payload) &&
+                !this.store.hasHalo(site.payload))
+                continue;
+            const key = this.host.resolve(concat2(this.store.bytesPrefix(site.payload, ALL), tail));
+            if (key === null)
+                continue;
+            const nx = this.store.nextFirst(key, 1);
+            if (nx.length === 0)
+                continue;
+            yield {
+                premises: [fact],
+                conclusion: {
+                    kind: "out",
+                    i: fact.i,
+                    j: queryLen,
+                    bytes: this.store.bytesPrefix(nx[0], ALL),
+                    cover: true,
+                    rec: true,
+                    node: nx[0],
+                    join: true,
+                },
+                cost: STEP,
+            };
+        }
+    }
     /** out(i,j,bytes,…): index it for the binary rules, then offer splicing a
      *  learnt connector (the in-search bridge), splitting (at a sub-leaf form
-     *  boundary), bridging (cover(i) ∧ this → cover(j)), and fusing with an
-     *  adjacent finalised out. */
+     *  boundary), bridging (cover(i) ∧ this → cover(j)), fusing with an adjacent
+     *  finalised out, and — for a produced fact — JOINING the entity it contains
+     *  with the query's tail ({@link join}). */
     *outRules(it, ctx) {
         const { splits, coversDone, outsByStart, outsByEnd, coverableByStart } = ctx;
         const outsByNode = ctx.outsByNode;
@@ -907,6 +1014,17 @@ export class GraphSearch {
             yield* this.fuse(it, r, ctx);
         for (const l of outsByEnd.get(it.i) ?? [])
             yield* this.fuse(l, it, ctx);
+        // ── JOIN (the A*LD extension) ───────────────────────────────────────
+        // A produced fact may CONTAIN the subject the query never named; the query's
+        // remaining tail then names the relation to follow FROM that subject.  The
+        // pair (contained entity, tail) is itself a learned key, and its
+        // continuation is the derived answer — a genuine two-fact join, not the
+        // juxtaposition the cover produces when the intermediate key IS named.
+        // Fired per finalized out with a node, so it is the search's own rule, on
+        // the ladder, memoised by {@link key}, and bounded by the fact's own length.
+        if (it.node !== undefined) {
+            yield* this.join(it, ctx.queryBytes, ctx.queryLen);
+        }
     }
     /** Whether the query span [from, to) is wholly covered by RECOGNISED outs —
      *  the test that lets a connector jump across INTERIOR answers (an N-ary whole)

package/dist/src/mind/recognition.js

@@ -501,7 +501,21 @@ function recogniseImpl(ctx, bytes) {
             // embedded differently-cased form needed 64x the budget to be found,
             // while the exact route it was competing with needed none of it.
             const probe = (start, end, canonBudget) => {
-                if (end - start < W || end - start <= chainReach(W))
+                // Any span at least one river window wide is worth a probe.  This used
+                // to stop at `chainReach(W)` — "the chain already covers anything that
+                // short" — and that premise is false for a NESTED form: the chain grows
+                // single-byte leaf ids and gates each step on `findBranch(ids)`, which
+                // is null for a form the write side chunked (measured: "Gustaf
+                // Molander" embedded in "The director of Eva is Gustaf Molander." gains
+                // no branch at any prefix, so `resolveSpan` is never reached), and its
+                // INTERIOR reach is one chunk plus W, which can be shorter than the
+                // form.  The result was a dead zone: a form shorter than `chainReach`
+                // that neither starts on a fold cut nor ends on a node edge was
+                // unreachable by either tier — the exact site whose loss `tryChain`'s
+                // own note records as "the pivot dies with the site and multi-hop goes
+                // silent".  The interior pass below spends the same budget on those
+                // pairs.
+                if (end - start < W)
                     return;
                 if (flatProbe(start, end) === null) {
                     if (!canonBudget)
@@ -565,6 +579,26 @@ function recogniseImpl(ctx, bytes) {
                 if (i < suffixes.length && !spend(suffixes[i], bytes.length))
                     break;
             }
+            // INTERIOR pairs, bounded by the same `chainReach(W)` the chain trusts —
+            // the dead zone the gate above used to leave: a form that neither starts
+            // on a fold cut nor ends on a node edge is exactly the one neither the
+            // chain (nested, `findBranch` misses) nor the two edge scans reach.  The
+            // pair count is `|endpoints| · chainReach(W)`, i.e. LINEAR in the query —
+            // the W² span bound is what keeps this from being the quadratic scan the
+            // budget note above describes (that one had no span bound at all).
+            {
+                const reach = chainReach(W);
+                for (const end of ordered) {
+                    for (const start of ordered) {
+                        if (start >= end)
+                            continue;
+                        const span = end - start;
+                        if (span < W || span > reach)
+                            continue;
+                        spend(start, end);
+                    }
+                }
+            }
         }
     }
     const chunkEnd = new Uint32Array(bytes.length);

package/dist/src/mind/trace.js

@@ -50,6 +50,7 @@ export const MOVE_NOTE = {
     "split": "cut a span at a sub-leaf form boundary so a form can be reached",
     "fuse": "fuse adjacent fragments toward a deeper learned form",
     "recompose": "recompose fused parts into a learned whole that leads on",
+    "join-fact": "join a produced fact's own subject with the query's tail — derive through the fact, not alongside it",
     "bridge": "advance the cover frontier across this span",
     "pool-vote": "pool independent regions' evidence for a shared anchor (sum, not shortest path)",
     "axiom": "a seed: a perceived leaf, recognised form, or computed result",

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/mind/graph-search.ts

@@ -115,6 +115,12 @@ export type GItem =
      *  derivation actually CHOSE.  Part of {@link key}, because it decides
      *  whether the span's final bytes may still change. */
     fix?: boolean;
+    /** Set on the out a JOIN produced: a produced fact's own contained entity
+     *  (the subject the query never named) combined with the query's adjacent
+     *  relation span named a learned key, and that key's continuation is this
+     *  out.  Part of {@link key} so the joined reading is a distinct chart item
+     *  from the plain concatenation of the same bytes. */
+    join?: boolean;
   };
 type OutItem = Extract<GItem, { kind: "out" }>;
 
@@ -240,6 +246,7 @@ export type DerivationMove =
   | "split" // out→out cut at a sub-leaf form boundary
   | "fuse" // out+out→out: adjacent fragments recomposed toward a learned form
   | "recompose" // out+out→form: a fused pair that names an edge-bearing node
+  | "join-fact" // out→out: a produced fact's own contained subject + the query's tail names a learned key (the join)
   | "bridge" // cover+out→cover: the cover frontier advanced across a span
   | "pool-vote" // N premises→conclusion, evidence pooled (combine:"sum" — see derive)
   | "step"; // any other single-premise move (fallback)
@@ -276,7 +283,11 @@ function classifyMove(
       if (!conclusion.rec) return "step";
       return articulating ? "voice" : "ground";
     }
-    if (p.kind === "out" && conclusion.kind === "out") return "split";
+    if (p.kind === "out" && conclusion.kind === "out") {
+      // A JOIN derives through a produced fact's own contained subject; a plain
+      // single-premise out→out is the byte-level split.
+      return conclusion.join ? "join-fact" : "split";
+    }
     return "step";
   }
   if (premises.length === 2) {
@@ -412,7 +423,11 @@ export class GraphSearch {
     // through (completion is cover, recursively — see {@link recompleteNode}).
     this.recompleteOpen.clear();
     this.recompleteMemo = new Map<number, Uint8Array | null>();
-    return this.solve(
+    // The top cover's derivation sink is threaded into every nested completion
+    // so the recompositions a produced form needs are reported in the same
+    // trace instead of vanishing after the first layer.
+    this.derivationSink = onDerivation;
+    const solved = this.solve(
       queryLen,
       {
         sites,
@@ -426,8 +441,17 @@ export class GraphSearch {
       computedResults,
       onDerivation,
     );
+    // Deepening runs HERE, once, on the derivation the top cover CHOSE — never
+    // inside the nested solve a completion runs.  Nesting the deepening is what
+    // made per-query cost track how densely the corpus interconnects the forms
+    // passed through: every re-cover fanned out into the whole corpus's
+    // continuations instead of following the chain the answer itself licensed.
+    // With deepening only at the top, `recompleteNode` walks the accepted chain
+    // one link at a time (its own memo and stack), so the work is the answer's.
+    return solved === null
+      ? null
+      : { segs: this.deepen(solved.segs), cost: solved.cost };
   }
-
   /** Build the deduction system for one span and return its lightest cover's
    *  chosen spans — the SINGLE routine the query and every produced composite
    *  run through.  `recognition` carries the span's recognised forms; the query
@@ -484,7 +508,7 @@ export class GraphSearch {
       onDerivation(readDerivation(derivation, substitutions !== undefined));
     }
     return derivation
-      ? { segs: this.deepen(readCover(derivation)), cost: derivation.cost }
+      ? { segs: readCover(derivation), cost: derivation.cost }
       : null;
   }
 
@@ -538,6 +562,13 @@ export class GraphSearch {
       Math.ceil((this.store.edgeSourceCount() * W) / 256),
     ) > this.hubBound();
     const nodeBytes = (n: number) => this.store.bytesPrefix(n, ALL);
+    // The query's own bytes, tiled from its perceived leaves.  A JOIN reads the
+    // tail a produced fact's contained entity has to combine with, and `buildSearch`
+    // otherwise only ever sees positions, never the bytes behind them.
+    const queryBytes = new Uint8Array(queryLen);
+    for (const lf of leaves) {
+      queryBytes.set(lf.bytes.subarray(0, lf.end - lf.start), lf.start);
+    }
     // Content-addressed probes over the store's hash-cons maps — the same keys
     // training filled.  No byte-by-byte trie walk.
     const findLeafU = (b: Uint8Array) => this.store.findLeaf(b) ?? undefined;
@@ -576,7 +607,7 @@ export class GraphSearch {
         }
         return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${
           it.fix ? 1 : 0
-        }.${it.node ?? -1}.${latin1(it.bytes)}`;
+        }.${it.join ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
       },
       *axioms() {
         yield { item: { kind: "cover", p: 0 }, cost: 0 };
@@ -684,6 +715,8 @@ export class GraphSearch {
           findBranchU,
           linksByLeft,
           linksByRight,
+          queryBytes,
+          queryLen,
         });
       },
     };
@@ -974,53 +1007,49 @@ export class GraphSearch {
    *  and recompose into a deeper learnt form (→ FINAL).  This is why a single
    *  edge-target needs no bespoke logic — it routes back through {@link solve}.
    *
-   *  Re-recognition (not the node's tree children) is what surfaces the learnt
-   *  parts: content-defined chunking may cut "p1 p2" as "p1 p"|"2", so only
-   *  recognising the bytes recovers p1 and p2 as the forms the graph knows.
+   *  The produced bytes are decomposed by the machinery that owns their shape:
+   *  the span's LEAVES and SPLITS drive the split rule, which resolves each half
+   *  through findLeaf — so a part that straddles a content-defined cut is still
+   *  recovered even though the node's tree children need not align with the
+   *  learnt parts (the fold cuts "p1 p2" as "p1 p"|"2").  Recognised SITES are
+   *  filtered to the node's own kids: a produced form is completed out of what
+   *  it was built from, never by re-recognising arbitrary forms inside it.  That
+   *  filter is load-bearing — a 37-byte dialogue sentence carries seven hub
+   *  openers, and re-covering them chained through the corpus's whole
+   *  continuation population: 2.5 GB and OOM for `respond("hi.")`.
    *
    *  The recovered answer is accepted only when it MOVED and names a LEARNT node
    *  ({@link resolve}) — the graph itself gates against re-expanding a contained
-   *  form ("ice is cold" ⊅→ "ice is cold is cold").
+   *  form ("ice is cold" ⊅→ "ice is cold is cold").  An ACCEPTED completion is
+   *  then re-covered in turn, so a chain runs as deep as the graph licenses; a
+   *  rejected one ends its branch, so no work is spent past it.
    *
-   *  Termination is STRUCTURAL: a produced node is re-covered once, never inside
-   *  another re-cover (see the guard below), so one cover pays at most one
-   *  nested {@link solve} per distinct produced node it actually reaches, and
-   *  {@link recompleteMemo} collapses a repeat to nothing.
-   *
-   *  This comment used to argue termination from "distinct node ids are finite
-   *  and each finished completion is memoised".  That is a bound of N — the one
-   *  AGENTS §2.8 forbids — and it was load-bearing, not pedantic: nested, the
-   *  recursion reached depth 331 and 9.1 GB on an 18.9M-node store for a 2-byte
-   *  query and did not terminate, which is what killed a 5 h training run at its
-   *  checkpoint recall.  Guard: test/89-completion-recursion.test.mjs. */
+   *  Termination and cost are STRUCTURAL: {@link recompleteOpen} is the chain's
+   *  stack (membership is the cycle guard), {@link recompleteMemo} re-covers each
+   *  node at most once, only accepted completions recurse, and every level
+   *  deepens only the top derivation — so a cover pays for the chain it finds,
+   *  not for how densely the corpus interconnects the forms it passes through.
+   *  Guard: test/89-completion-recursion.test.mjs. */
   private recompleteNode(node: number): Uint8Array | null {
     if (!this.host.recogniseSpan) return null;
     const memo = this.recompleteMemo;
     if (memo.has(node)) return memo.get(node) ?? null;
-    // ONE re-cover per produced node — never a re-cover inside a re-cover.
-    //
     // Re-covering is how a PRODUCED node's bytes enter the search at all: the
-    // cover machinery otherwise only ever sees the QUERY's spans.  That is
-    // needed once.  The alternation of decomposition and recomposition that
-    // follows — parts rewriting several times, siblings fusing, a recomposition
-    // feeding another — is the main search's own fuse/`rcmp` work, not this
-    // recursion's: 15-decomposition-gap §9–§12 all pass with this method
-    // disabled outright, and only §6 (the produced composite "p1 p2", whose
-    // bytes nothing else brings in) needs it.
-    //
-    // Nesting it was the defect.  Each level is a full {@link solve} with its
-    // own agenda and chart, exploring from a node the answer never asked about,
-    // so per-query cost tracked how densely the corpus interconnects the forms
-    // passed through — the growth AGENTS §2.8 forbids.  Measured on an
-    // 18.9M-node store: depth 331 and 9.1 GB for a 2-byte query, not
-    // terminating; and on the guard corpus every one of 125 nested re-covers
-    // was REJECTED by the resolve() gate below, expanding a 70-byte node into a
-    // 374-byte concatenation that names nothing.  All of it was waste.
+    // cover machinery otherwise only ever sees the QUERY's spans.  The recursion
+    // is allowed to nest — a chain IS nested completions — but it is bounded so
+    // the work stays the ANSWER's (AGENTS §2.8): the stack below is the cycle
+    // guard, only ACCEPTED completions recurse, and the nested solve decomposes
+    // the form by its own shape instead of re-recognising the corpus's hub forms
+    // inside it.
     //
-    // `recompleteOpen` is that stack, so a non-empty stack means we are already
-    // inside one.  This subsumes the old cycle guard: a node cannot recurse
-    // back into itself when nothing recurses at all.
-    if (this.recompleteOpen.size > 0) return null;
+    // `recompleteOpen` IS the stack of the chain being built, so MEMBERSHIP is
+    // the cycle guard: a node already open on this chain cannot re-enter it.
+    // Testing the NODE — not the stack's size — is what lets a completion
+    // recurse as deep as the graph licenses, exactly the intrinsic convergence
+    // {@link solve}'s contract states.  Work stays the answer's because the
+    // recursion only ever advances through an ACCEPTED completion (below) and
+    // {@link cover} deepens only the top derivation.
+    if (this.recompleteOpen.has(node)) return null;
 
     // A leaf or single-child node has no parts to recompose; skip before the
     // costly recognition so a plain terminal answer pays nothing.
@@ -1033,20 +1062,51 @@ export class GraphSearch {
     const bytes = this.store.bytesPrefix(node, ALL);
     this.recompleteOpen.add(node);
     try {
-      // Completion is cover: re-cover the produced bytes through the SAME solve
-      // routine, recognising them afresh.  No concepts/connectors (those need the
-      // caller's async pre-resolution) — the recursion explores edges and fusion,
-      // which is what a deeper rewrite chain is made of.
+      // Completion is cover, but the produced form is decomposed by its own
+      // shape.  The LEAVES and SPLITS are kept whole, so the split rule still
+      // recovers a part that straddles a content-defined cut (the fold cuts
+      // "p1 p2" as "p1 p"|"2", and findLeaf still resolves p1 and p2).  The
+      // recognised SITES are filtered to the node's own kids, because
+      // re-recognising arbitrary forms inside the bytes is what let a hub-heavy
+      // utterance explode: a 37-byte dialogue sentence carries seven hub
+      // openers, and re-covering them chained through the corpus's whole
+      // continuation population (2.5 GB and OOM for `"hi."`).  No
+      // concepts/connectors either (those need the caller's async
+      // pre-resolution) — the recursion follows edges and fusion, which is what
+      // a deeper rewrite chain is made of.
+      const rec = this.host.recogniseSpan(bytes);
+      const kids = new Set(nrec.kids);
       const solved = this.solve(
         bytes.length,
-        this.host.recogniseSpan(bytes),
+        {
+          sites: rec.sites.filter((s) => kids.has(s.payload)),
+          leaves: rec.leaves,
+          splits: rec.splits,
+          starts: rec.starts,
+        },
         new Map(),
+        undefined,
+        undefined,
+        undefined,
+        this.derivationSink,
       );
       const answer = solved && concatBytes(solved.segs.map((s) => s.bytes));
-      const out = (answer !== null && !bytesEqual(answer, bytes) &&
-          this.host.resolve(answer) !== null)
-        ? answer
+      // ACCEPT, then CONTINUE THE CHAIN — but only along an accepted
+      // completion.  A re-cover whose result is not itself a learnt node (the
+      // 70→374-byte concatenations that name nothing) ends its branch here
+      // instead of recursing into work the answer never asked for, and an
+      // accepted one names a node that is re-covered in turn.  That is what
+      // keeps a deep chain possible while the work stays proportional to the
+      // chain rather than to the corpus's interconnections.
+      const composed = answer !== null && !bytesEqual(answer, bytes)
+        ? this.host.resolve(answer)
         : null;
+      if (composed === null) {
+        memo.set(node, null);
+        return null;
+      }
+      const deeper = this.recompleteNode(composed);
+      const out = deeper ?? answer!;
       memo.set(node, out);
       return out;
     } finally {
@@ -1058,19 +1118,80 @@ export class GraphSearch {
    *  outs of a long query re-cover each distinct node at most once); reset at the
    *  top of {@link cover}. */
   private recompleteMemo = new Map<number, Uint8Array | null>();
-  /** The node currently being re-completed — the recursion stack, and so also
-   *  the nesting depth.  {@link recompleteNode} refuses to start while it is
-   *  non-empty (one re-cover per produced node, never one inside another), which
-   *  is what keeps a query's cost proportional to its answer rather than to the
-   *  corpus; it therefore holds at most one id.  A Set, not a flag, because it
-   *  states WHICH node is open — the invariant a reader needs to check the
-   *  guard, and what makes the old cycle-guard reading still hold. */
+  /** The derivation sink of the TOP cover, threaded into every nested
+   *  completion so a produced form's own recompositions are reported in the
+   *  same trace instead of vanishing after the first layer.  Undefined when
+   *  nothing is inspecting, so an uninspected response pays nothing. */
+  private derivationSink?: (steps: DerivationStep[]) => void;
+  /** The chain of nodes currently being re-completed — the recursion STACK.
+   *  MEMBERSHIP is the cycle guard ({@link recompleteNode} refuses a node
+   *  already open on this chain), which is what lets a completion recurse as
+   *  deep as the graph licenses while the work stays the answer's: the
+   *  recursion only advances through an ACCEPTED completion, every produced
+   *  form is decomposed into its own kids, and the memo re-covers each node at
+   *  most once per cover.  A Set, not a flag, because it states WHICH node is
+   *  open — the invariant a reader needs to check the guard. */
   private recompleteOpen = new Set<number>();
 
+  /** JOIN — the move the substrate was missing: derive the answer THROUGH a
+   *  produced fact, without the intermediate key being named in the query.
+   *
+   *  A produced fact (`fact.node`) carries the subject the query reached but
+   *  never wrote; the query's remaining tail names the relation to follow from
+   *  it.  The pair IS a learned key — `"<entity><tail>"` — so the rule asks the
+   *  store for that key's continuation and, when it exists, concludes with the
+   *  joined fact.  On the ladder it is one STEP: a direct edge, exactly as
+   *  following a literal continuation is.  Deterministic and point-probed
+   *  (`resolve` + `nextFirst`, no scan), so it adds no read that grows with the
+   *  corpus.  The move is visible in the rationale as its own act
+   *  (`classifyMove` reports `join-fact`), distinct from the byte-concatenating
+   *  `fuse`/`splice`. */
+  private *join(
+    fact: OutItem,
+    queryBytes: Uint8Array,
+    queryLen: number,
+  ): Iterable<Rule<GItem>> {
+    if (!this.host.recogniseSpan) return;
+    const tail = queryBytes.subarray(fact.j, queryLen);
+    if (tail.length === 0) return;
+    // The entity candidates are the forms the fact's own bytes CONTAIN — the
+    // same recogniser the query went through, so the evidence standard is the
+    // query's.  A byte atom is never a subject; the fact's own node is the span
+    // itself, not an entity inside it.
+    for (const site of this.host.recogniseSpan(fact.bytes).sites) {
+      if (site.payload < 0 || site.payload === fact.node) continue;
+      if (
+        !this.store.hasNext(site.payload) &&
+        !this.store.hasHalo(site.payload)
+      ) continue;
+      const key = this.host.resolve(
+        concat2(this.store.bytesPrefix(site.payload, ALL), tail),
+      );
+      if (key === null) continue;
+      const nx = this.store.nextFirst(key, 1);
+      if (nx.length === 0) continue;
+      yield {
+        premises: [fact],
+        conclusion: {
+          kind: "out",
+          i: fact.i,
+          j: queryLen,
+          bytes: this.store.bytesPrefix(nx[0], ALL),
+          cover: true,
+          rec: true,
+          node: nx[0],
+          join: true,
+        },
+        cost: STEP,
+      };
+    }
+  }
+
   /** out(i,j,bytes,…): index it for the binary rules, then offer splicing a
    *  learnt connector (the in-search bridge), splitting (at a sub-leaf form
-   *  boundary), bridging (cover(i) ∧ this → cover(j)), and fusing with an
-   *  adjacent finalised out. */
+   *  boundary), bridging (cover(i) ∧ this → cover(j)), fusing with an adjacent
+   *  finalised out, and — for a produced fact — JOINING the entity it contains
+   *  with the query's tail ({@link join}). */
   private *outRules(
     it: OutItem,
     ctx: {
@@ -1087,6 +1208,8 @@ export class GraphSearch {
       findBranchU: (k: number[]) => number | undefined;
       linksByLeft?: ReadonlyMap<number, Array<[number, Uint8Array]>>;
       linksByRight?: ReadonlyMap<number, Array<[number, Uint8Array]>>;
+      queryBytes: Uint8Array;
+      queryLen: number;
     },
   ): Iterable<Rule<GItem>> {
     const { splits, coversDone, outsByStart, outsByEnd, coverableByStart } =
@@ -1179,6 +1302,18 @@ export class GraphSearch {
 
     for (const r of outsByStart.get(it.j) ?? []) yield* this.fuse(it, r, ctx);
     for (const l of outsByEnd.get(it.i) ?? []) yield* this.fuse(l, it, ctx);
+
+    // ── JOIN (the A*LD extension) ───────────────────────────────────────
+    // A produced fact may CONTAIN the subject the query never named; the query's
+    // remaining tail then names the relation to follow FROM that subject.  The
+    // pair (contained entity, tail) is itself a learned key, and its
+    // continuation is the derived answer — a genuine two-fact join, not the
+    // juxtaposition the cover produces when the intermediate key IS named.
+    // Fired per finalized out with a node, so it is the search's own rule, on
+    // the ladder, memoised by {@link key}, and bounded by the fact's own length.
+    if (it.node !== undefined) {
+      yield* this.join(it, ctx.queryBytes, ctx.queryLen);
+    }
   }
 
   /** Whether the query span [from, to) is wholly covered by RECOGNISED outs —

package/src/mind/recognition.ts

@@ -518,7 +518,21 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         end: number,
         canonBudget: boolean,
       ): void => {
-        if (end - start < W || end - start <= chainReach(W)) return;
+        // Any span at least one river window wide is worth a probe.  This used
+        // to stop at `chainReach(W)` — "the chain already covers anything that
+        // short" — and that premise is false for a NESTED form: the chain grows
+        // single-byte leaf ids and gates each step on `findBranch(ids)`, which
+        // is null for a form the write side chunked (measured: "Gustaf
+        // Molander" embedded in "The director of Eva is Gustaf Molander." gains
+        // no branch at any prefix, so `resolveSpan` is never reached), and its
+        // INTERIOR reach is one chunk plus W, which can be shorter than the
+        // form.  The result was a dead zone: a form shorter than `chainReach`
+        // that neither starts on a fold cut nor ends on a node edge was
+        // unreachable by either tier — the exact site whose loss `tryChain`'s
+        // own note records as "the pivot dies with the site and multi-hop goes
+        // silent".  The interior pass below spends the same budget on those
+        // pairs.
+        if (end - start < W) return;
         if (flatProbe(start, end) === null) {
           if (!canonBudget) return;
           if (!canonAdmits(start, end)) return;
@@ -575,6 +589,24 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         if (i < prefixes.length && !spend(0, prefixes[i])) break;
         if (i < suffixes.length && !spend(suffixes[i], bytes.length)) break;
       }
+      // INTERIOR pairs, bounded by the same `chainReach(W)` the chain trusts —
+      // the dead zone the gate above used to leave: a form that neither starts
+      // on a fold cut nor ends on a node edge is exactly the one neither the
+      // chain (nested, `findBranch` misses) nor the two edge scans reach.  The
+      // pair count is `|endpoints| · chainReach(W)`, i.e. LINEAR in the query —
+      // the W² span bound is what keeps this from being the quadratic scan the
+      // budget note above describes (that one had no span bound at all).
+      {
+        const reach = chainReach(W);
+        for (const end of ordered) {
+          for (const start of ordered) {
+            if (start >= end) continue;
+            const span = end - start;
+            if (span < W || span > reach) continue;
+            spend(start, end);
+          }
+        }
+      }
     }
   }
 

package/src/mind/trace.ts

@@ -75,6 +75,8 @@ export const MOVE_NOTE: Record<string, string> = {
   "split": "cut a span at a sub-leaf form boundary so a form can be reached",
   "fuse": "fuse adjacent fragments toward a deeper learned form",
   "recompose": "recompose fused parts into a learned whole that leads on",
+  "join-fact":
+    "join a produced fact's own subject with the query's tail — derive through the fact, not alongside it",
   "bridge": "advance the cover frontier across this span",
   "pool-vote":
     "pool independent regions' evidence for a shared anchor (sum, not shortest path)",

package/test/46-recognise-multibyte-edge.test.mjs

@@ -83,3 +83,33 @@ test("recognise(): a wide edge trim does not corrupt an unrelated short-form ans
   const r = await m.respond("2+2 は何ですか");
   assert.equal(dec(r.bytes), "4");
 });
+
+test("recognise(): an INTERIOR form at a non-cut offset is recovered, not only an edge one", async () => {
+  // The edge tier used to probe only prefixes of 0 and suffixes to bytes.length,
+  // and the flat-leaf chain cannot rebuild a write-side-chunked form (its
+  // `findBranch(ids)` pre-check misses at every prefix, so `resolveSpan` is
+  // never reached) while its interior reach is one chunk plus W.  A form that
+  // neither starts on a fold cut nor ends on a node edge therefore fell in a
+  // dead zone — exactly the object inside a produced fact ("…is Gustaf
+  // Molander."), which is the site the pivot would need to chain on.
+  // MEASURED on the pre-change tree: no site for the entity.  With the bounded
+  // interior pass (spans W..chainReach(W), linear in the query), it is found at
+  // its true span.
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["x", "The director of Eva is Gustaf Molander."],
+    ["Gustaf Molander", "The father of Gustaf Molander is Harald Molander."],
+  ]);
+  const expected = resolve(m, enc("Gustaf Molander"));
+  assert.ok(expected !== null, "sanity: the entity must resolve standalone");
+
+  const rec = recognise(m, enc("The director of Eva is Gustaf Molander."));
+  const hit = rec.sites.find((s) => s.payload === expected);
+  assert.ok(
+    hit,
+    `expected an interior site for the entity, got: ` +
+      JSON.stringify(rec.sites.map((s) => [s.start, s.end, s.payload])),
+  );
+  assert.deepEqual([hit.start, hit.end], [23, 38]);
+  await m.store.close();
+});

package/test/98-completion-chaining.test.mjs

@@ -0,0 +1,140 @@
+// 98-completion-chaining.test.mjs — the completion recursion NESTS, and the
+// two properties that make that reachable are pinned here.
+//
+// `graph-search.ts`'s `recompleteNode` used to refuse any re-cover inside a
+// re-cover (`recompleteOpen.size > 0`), so a chain through a PRODUCED composite
+// stopped after a single recomposition: the depth the A*LD substrate licenses
+// was unreachable.  The recursion now nests, but only through ACCEPTED
+// completions and only along the produced form's own parts — and with per-query
+// work that stays the answer's (test/89 pins the cost).
+//
+// WHY THESE AND NOT test/15's §9–§12: those exercise chains whose parts all live
+// INSIDE the query's own span ("a e", "x y", "p q r"); they pass even with
+// `recompleteNode` disabled outright.  §6 reaches a produced composite, but only
+// one recomposition deep.  The cases here fail on the pre-change tree:
+//   1. the chain stops at the intermediate composite ("m n", not "z"), and
+//   2. the nested derivation never reaches the rationale.
+//
+// MEASURED on the pre-change tree (this file's fixtures):
+//   respondText("seed") === "m n"   (one recomposition)
+//   rationale moves      = no `fuse`, no `recompose`
+// After the change: "z", and both moves present.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+
+/** seed → "p q" → (p→r, q→s) → "r s" → "m n" → (m→x, n→y) → "x y" → z
+ *
+ *  The query names only `seed`.  Every form after the first hop is PRODUCED by
+ *  an edge, so reaching `z` requires TWO nested completions: "p q" recomposes to
+ *  "m n", and "m n" recomposes again to "x y" → z.  A single-level completion
+ *  stops one composite short, at "m n". */
+async function deepChain() {
+  const m = new Mind({ seed: 7 });
+  await m.ingest([
+    ["seed", "p q"],
+    ["p", "r"],
+    ["q", "s"],
+    ["r s", "m n"],
+    ["m", "x"],
+    ["n", "y"],
+    ["x y", "z"],
+  ]);
+  return m;
+}
+
+test("a produced composite completes through two nested recompositions", async () => {
+  const m = await deepChain();
+  assert.equal(
+    (await m.respondText("seed")).replace(/\0+/g, ""),
+    "z",
+  );
+  await m.store.close();
+});
+
+test("nested completions reach the rationale", async () => {
+  const m = await deepChain();
+  const steps = [];
+  await m.respondText("seed", (s) => steps.push(s));
+  const moves = new Set(steps.map((s) => s.mechanism.at(-1)));
+  // The top cover cannot fabricate these on its own: recomposition happens
+  // inside the nested solves, and they were invisible before the sink was
+  // threaded through.
+  assert.ok(
+    moves.has("recompose"),
+    `expected a recompose move in the rationale, got: ${[...moves].join(", ")}`,
+  );
+  assert.ok(
+    moves.has("fuse"),
+    `expected a fuse move in the rationale, got: ${[...moves].join(", ")}`,
+  );
+  await m.store.close();
+});
+
+test("a produced composite is completed by its own parts, not by a learned form inside it", async () => {
+  // The produced bytes are "hi there"; `hi` is a learned context that is NOT one
+  // of their parts.  Re-recognising arbitrary forms inside the bytes is what
+  // let a hub-heavy utterance explode on the trained store (`respond("hi.")`:
+  // 37 bytes, seven hub openers, 2.5 GB, OOM) — the produced form is decomposed
+  // instead by the machinery that owns its shape (leaves/splits), with the
+  // recognised SITES filtered to the node's own kids.
+  //
+  // MEASURED on the pre-change tree: no `recompose` move here at all — the
+  // unrelated `hi` site was taken instead of decomposing the form.
+  const m = new Mind({ seed: 7 });
+  await m.ingest([
+    ["seed", "hi there"],
+    ["hi", "KLX"],
+  ]);
+  const steps = [];
+  const answer = (await m.respondText("seed", (s) => steps.push(s)))
+    .replace(/\0+/g, "")
+    .trim();
+  assert.equal(answer, "hi there");
+  const moves = new Set(steps.map((s) => s.mechanism.at(-1)));
+  assert.ok(
+    moves.has("recompose"),
+    `expected the completion to decompose the form by its parts, got: ${
+      [...moves].join(", ")
+    }`,
+  );
+  await m.store.close();
+});
+
+test("the chain runs as deep as the graph licenses (four nested completions)", async () => {
+  const m = new Mind({ seed: 7 });
+  await m.ingest([
+    ["seed", "p1 q1"],
+    ["p1", "a1"],
+    ["q1", "b1"],
+    ["a1 b1", "p2 q2"],
+    ["p2", "a2"],
+    ["q2", "b2"],
+    ["a2 b2", "p3 q3"],
+    ["p3", "a3"],
+    ["q3", "b3"],
+    ["a3 b3", "FIM"],
+  ]);
+  assert.equal((await m.respondText("seed")).replace(/\0+/g, ""), "FIM");
+  await m.store.close();
+});
+
+test("a completion cycle terminates deterministically (the stack is the guard)", async () => {
+  // The recomposition of "x y" leads back to "x y" itself.  Membership in
+  // `recompleteOpen` refuses the re-entry, so the recursion terminates on the
+  // form it already holds instead of re-covering it forever — and it answers
+  // the same bytes twice.
+  const m = new Mind({ seed: 7 });
+  await m.ingest([
+    ["seed", "x y"],
+    ["x", "A"],
+    ["y", "B"],
+    ["A B", "x y"],
+  ]);
+  const first = (await m.respondText("seed")).replace(/\0+/g, "").trim();
+  const second = (await m.respondText("seed")).replace(/\0+/g, "").trim();
+  assert.equal(first, second);
+  assert.equal(first, "x y");
+  await m.store.close();
+});

package/test/99-fact-join.test.mjs

@@ -0,0 +1,97 @@
+// 99-fact-join.test.mjs — the JOIN: derive the answer THROUGH a produced fact
+// whose subject the query never names.
+//
+// THE MOVE THIS PINS.  A query like "Eiffel Tower country capital" names hop 1's
+// key ("Eiffel Tower country") and hop 2's relation (" capital"), but never the
+// intermediate subject ("France").  The cover alone can only juxtapose the two
+// facts; the pivot needs the subject to surface as an unconsumed site inside the
+// produced fact.  The `join` rule in graph-search.ts closes the gap: it takes the
+// entity the produced fact CONTAINS, combines it with the query's remaining tail,
+// and asks the store for that key's continuation — a direct STEP on the ladder,
+// reported as `join-fact` in the rationale.
+//
+// WHY THE FIXTURE CROSSES N=4096.  Below the atomIsHub flip the interior subject
+// surfaces anyway (small-store recognition) and the PIVOT alone reaches the
+// chain, so a small fixture passes under the pre-change tree too — measured on a
+// 3-deposit store, which answered "The father of Gustaf Molander is Harald
+// Molander." with no join.  The join is what carries the chain at corpus scale,
+// so the fixture must sit past the flip, exactly as test/78 does.  The filler is
+// lexically varied for the same reason test/78's is: a templated corpus folds to
+// shared chunks and leaves the query uncontested.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+const CHAIN = [
+  ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+  ["France capital", "The capital of France is Paris."],
+  // The pivot fact: the intermediate subject as a context of its own.
+  ["France", "The capital of France is Paris."],
+];
+
+const WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet " +
+    "kilo lima mike november oscar papa quebec romeo sierra tango uniform " +
+    "victor whiskey xray yankee zulu amber bronze copper dahlia ember fjord " +
+    "gossamer harbour indigo jasmine kestrel lantern marigold nectar opal " +
+    "pewter quartz ripple saffron thistle umber violet willow xenon yarrow")
+    .split(" ");
+const filler = (i) => {
+  const w = (n) => WORDS[(i * 7 + n * 13) % WORDS.length];
+  return [
+    `${w(1)} ${w(2)} ${w(3)} ${i}`,
+    `${w(4)} ${w(5)} ${w(6)} ${w(7)} ${i}`,
+  ];
+};
+
+/** One store, ingested past the atomIsHub flip. */
+async function pastTheFlip() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(CHAIN);
+  await mind.ingest(Array.from({ length: 4300 }, (_, i) => filler(i)));
+  return { store, mind };
+}
+
+test("a join derives through a produced fact whose subject the query never names", async () => {
+  const { store, mind } = await pastTheFlip();
+  const query = "Eiffel Tower country capital";
+  assert.ok(
+    !query.includes("France") && !query.includes("capital of France"),
+    "sanity: the intermediate subject must NOT be named in the query",
+  );
+
+  const moves = [];
+  const out = await mind.respondText(
+    query,
+    (s) => moves.push(s.mechanism[s.mechanism.length - 1]),
+  );
+
+  assert.equal(out.trim(), "The capital of France is Paris.");
+  assert.ok(
+    moves.includes("join-fact"),
+    `expected the join to be the move that reached the answer, got: ${
+      [...new Set(moves)].join(", ")
+    }`,
+  );
+  await store.close();
+});
+
+test("naming the intermediate does not need the join — the cover reads it directly", async () => {
+  // The contrast that keeps the move honest: when the subject IS written, the
+  // cover already reaches the chain, so no join is claimed.
+  const { store, mind } = await pastTheFlip();
+  const moves = [];
+  const out = await mind.respondText(
+    "Eiffel Tower country France capital",
+    (s) => moves.push(s.mechanism[s.mechanism.length - 1]),
+  );
+  assert.ok(out.includes("The capital of France is Paris."));
+  assert.ok(
+    !moves.includes("join-fact"),
+    "a named intermediate must not be reported as a join",
+  );
+  await store.close();
+});