@hviana/sema 0.7.6 → 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. */
@@ -312,10 +318,25 @@ export declare class GraphSearch {
      *  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) {
@@ -325,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;
@@ -357,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 };
@@ -465,6 +475,8 @@ export class GraphSearch {
                     findBranchU,
                     linksByLeft,
                     linksByRight,
+                    queryBytes,
+                    queryLen,
                 });
             },
         };
@@ -854,10 +866,62 @@ export class GraphSearch {
      *  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;
@@ -950,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.6",
+  "version": "0.7.7",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.7.6",
+  "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) {
@@ -551,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;
@@ -589,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 };
@@ -697,6 +715,8 @@ export class GraphSearch {
           findBranchU,
           linksByLeft,
           linksByRight,
+          queryBytes,
+          queryLen,
         });
       },
     };
@@ -1113,10 +1133,65 @@ export class GraphSearch {
    *  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: {
@@ -1133,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 } =
@@ -1225,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/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();
+});