@hviana/sema 0.7.6 → 0.7.8

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

@@ -73,6 +73,14 @@ 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 DERIVE-THROUGH produced: a produced fact's own contained
+     *  entity (the subject the query never named) combined with the query's tail
+     *  named a learned key, and that key's continuation is this out.  Part of
+     *  {@link key} so the derived reading is a distinct chart item from the plain
+     *  concatenation of the same bytes.  Named for what it does — derive THROUGH
+     *  a produced fact — because `join` is already the confluence mechanism's
+     *  `Provenance`, a different act at a different layer. */
+    throughFact?: boolean;
 };
 export declare const STEP = 1;
 export declare const CONCEPT = 10;
@@ -136,7 +144,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" | "derive-through" | "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. */
@@ -180,11 +188,12 @@ export declare class GraphSearch {
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
     cover(queryLen: number, sites: ReadonlyArray<Site>, conceptTarget: ReadonlyMap<number, number>, leaves: ReadonlyArray<Leaf>, splits: ReadonlySet<number>, starts: ReadonlySet<number>, substitutions?: ReadonlyMap<number, Uint8Array>, connectors?: ReadonlyMap<string, Uint8Array>, computedResults?: ReadonlyArray<ComputedResult>, 
-    /** When given, receives the lightest derivation's rule applications — the
-     *  full adapted A*LD proof tree as classified {@link DerivationStep}s — for the TOP
-     *  cover only (a recursive recompletion solves its own sub-cover and is not
-     *  reported here, to keep the trace one layer per think).  Off by default,
-     *  so the search pays nothing when no one inspects. */
+    /** When given, receives each solved span's lightest derivation — the full
+     *  adapted A*LD proof tree as classified {@link DerivationStep}s — for the
+     *  TOP cover AND every nested completion the sink is threaded into (see
+     *  {@link recompleteNode}), so a produced form's own recompositions reach
+     *  the rationale instead of stopping at the first layer.  Off by default, so
+     *  the search pays nothing when no one inspects. */
     onDerivation?: (steps: DerivationStep[]) => void): {
         segs: Seg[];
         cost: number;
@@ -312,10 +321,30 @@ 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;
+    /** DERIVE-THROUGH — a RULE this module's DeductionSystem was missing.  The
+     *  A*LD library is untouched: this is one more `premises → conclusion + cost`
+     *  rule in the system {@link buildSearch} hands to {@link lightestDerivation},
+     *  the same kind of rule as `fuse`/`recompose` — not an extension of
+     *  `src/derive`, and not a grounding mechanism.  It derives 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
+     *  fact reached through it.  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 `derive-through`), distinct from the
+     *  byte-concatenating `fuse`/`splice` — and named `derive-through` rather than
+     *  `join` so it cannot be read as the confluence mechanism's `Provenance`. */
+    private deriveThrough;
     /** 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 deriveThrough}). */
     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.throughFact ? "derive-through" : "split";
+        }
         return "step";
     }
     if (premises.length === 2) {
@@ -219,11 +222,12 @@ export class GraphSearch {
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
     cover(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults, 
-    /** When given, receives the lightest derivation's rule applications — the
-     *  full adapted A*LD proof tree as classified {@link DerivationStep}s — for the TOP
-     *  cover only (a recursive recompletion solves its own sub-cover and is not
-     *  reported here, to keep the trace one layer per think).  Off by default,
-     *  so the search pays nothing when no one inspects. */
+    /** When given, receives each solved span's lightest derivation — the full
+     *  adapted A*LD proof tree as classified {@link DerivationStep}s — for the
+     *  TOP cover AND every nested completion the sink is threaded into (see
+     *  {@link recompleteNode}), so a produced form's own recompositions reach
+     *  the rationale instead of stopping at the first layer.  Off by default, so
+     *  the search pays nothing when no one inspects. */
     onDerivation) {
         // Top-level entry: reset the per-call recursion state, then run the one
         // {@link solve} routine that both the query and any produced composite go
@@ -325,6 +329,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 +368,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.throughFact ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
             },
             *axioms() {
                 yield { item: { kind: "cover", p: 0 }, cost: 0 };
@@ -465,6 +476,8 @@ export class GraphSearch {
                     findBranchU,
                     linksByLeft,
                     linksByRight,
+                    queryBytes,
+                    queryLen,
                 });
             },
         };
@@ -854,10 +867,67 @@ 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();
+    /** DERIVE-THROUGH — a RULE this module's DeductionSystem was missing.  The
+     *  A*LD library is untouched: this is one more `premises → conclusion + cost`
+     *  rule in the system {@link buildSearch} hands to {@link lightestDerivation},
+     *  the same kind of rule as `fuse`/`recompose` — not an extension of
+     *  `src/derive`, and not a grounding mechanism.  It derives 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
+     *  fact reached through it.  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 `derive-through`), distinct from the
+     *  byte-concatenating `fuse`/`splice` — and named `derive-through` rather than
+     *  `join` so it cannot be read as the confluence mechanism's `Provenance`. */
+    *deriveThrough(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],
+                    throughFact: 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 deriveThrough}). */
     *outRules(it, ctx) {
         const { splits, coversDone, outsByStart, outsByEnd, coverableByStart } = ctx;
         const outsByNode = ctx.outsByNode;
@@ -950,6 +1020,18 @@ export class GraphSearch {
             yield* this.fuse(it, r, ctx);
         for (const l of outsByEnd.get(it.i) ?? [])
             yield* this.fuse(l, it, ctx);
+        // ── DERIVE-THROUGH (one more rule of the DeductionSystem this module builds)
+        // 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 relational join, distinct
+        // from the confluence mechanism's `join` PROVENANCE — and 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.deriveThrough(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/mechanisms/alu.js

@@ -12,14 +12,16 @@ import { unexplainedLabel } from "../rationale.js";
 export function aluToMechanism(alu) {
     return {
         name: "alu",
-        // Not a cover derivation: cover.ts composes an answer by walking
-        // recognised query STRUCTURE; the ALU evaluates a recognised expression
-        // to its authoritative result and hands the bytes back untouched. It
-        // shares cover's near-zero floor (computation always wins, masked into
-        // cover's own search — see mechanisms/cover.ts), but the candidate this
-        // produces is not one of cover's derivations, so it carries its own
-        // honest label, the same way extract/cast/recall each carry theirs.
-        provenance: "alu",
+        // The computation is GROUNDED BY COVER: this adapter's `parse` puts the
+        // authoritative span into `pre.computed`, cover masks it, and cover's
+        // derivation is what carries the answer out — measured, every computed
+        // probe reports provenance `cover`. So the adapter declares the core
+        // provenance the answer actually has. The ALU's own act is named where it
+        // belongs, in the TRACE (`evalComputation`, emitted by its `parse`), not in
+        // the provenance: a mechanism may not invent a label outside the pipeline's
+        // `Provenance` vocabulary, because post-grounding gates on that vocabulary
+        // (see the `provenance` contract in pipeline-mechanism.ts).
+        provenance: "cover",
         parse: (query) => alu.parse(query),
         async floor(_ctx, _query, pre, _worthRunning) {
             return pre.computed.length > 0 ? 0 : null;

package/dist/src/mind/mind.js

@@ -155,8 +155,9 @@ export class Mind {
             // `makeKeyring`, `Space.rand` and the `Alphabet` below, so folding a
             // query under config.ts's default (42) against a store trained with
             // another seed (e.g. 7) lands in a DIFFERENT vector space than the one
-            // the artifact's nodes were folded into: recognition and resonance then
-            // read the wrong space and every answer degrades silently.  An explicit
+            // the artifact's nodes were folded into: recognition and resonance read
+            // the wrong space, and answers silently diverge — pinned by test/97,
+            // where only adoption reproduces the artifact's own answer.  An explicit
             // caller seed still wins — this only replaces the unconfigured default.
             if (explicitSeed === undefined && this.store.trainSeed !== null) {
                 this.cfg.seed = this.store.trainSeed;

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -185,7 +185,13 @@ export interface MechanismResult {
 export interface PipelineMechanism {
     /** Stable identifier for trace/debug. */
     readonly name: string;
-    /** Which provenance tag the pipeline attaches to this mechanism's answers. */
+    /** Which provenance tag the pipeline attaches to this mechanism's answers.
+     *  DECLARED, not free-form: the pipeline narrows it to its own `Provenance`
+     *  vocabulary (pipeline.ts), because post-grounding gates on that vocabulary
+     *  — so an adapter declares one of those values, never a label of its own.
+     *  The type is `string` only because a mechanism imports nothing from
+     *  `pipeline.ts` (constraint 1, decoupling); the contract is semantic, and
+     *  every shipped adapter honours it (see mechanisms/alu.ts). */
     readonly provenance: string;
     /** Parse authoritative spans BEFORE the grounding loop.
      *  Only needed by computational mechanisms (e.g. ALU).  Results from ALL

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 does not hold for every embedded form: the
+                // chain grows single-byte leaf ids and SKIPS a prefix whose
+                // `findBranch(ids)` is null, so a form the write side stored as a nested
+                // tree rather than as a flat leaf-id branch is never `resolveSpan`ned
+                // (measured: "Gustaf Molander" embedded in "The director of Eva is
+                // Gustaf Molander." gains no branch at any prefix), 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,28 @@ function recogniseImpl(ctx, bytes) {
                 if (i < suffixes.length && !spend(suffixes[i], bytes.length))
                     break;
             }
+            // INTERIOR pairs within the same `chainReach(W)` span bound 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.
+            // Only pairs whose span lies in [W, chainReach(W)] are PROBED, which is
+            // the O(n · W²) work that matters; the enumeration itself is the all-pairs
+            // scan, each pair a constant-time span check — and the span bound is what
+            // keeps this off the quadratic path 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",
+    "derive-through": "derive the answer through a produced fact's own subject and the query's tail, 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/docs/mechanisms/alu.md

@@ -66,8 +66,14 @@ forms need no host; meaning-based paths do.
 
 ## Provenance
 
-Grounded ALU answers carry `alu`; `computeExtensions`/`evalComputation` trace
-the expression and result.
+`cover`. A computation is grounded by cover: this adapter's `parse` puts the
+authoritative span into `pre.computed`, cover masks it, and cover's derivation
+carries the answer out (measured: 9 of 9 computed probes report `cover` —
+`137*24`, `1000 - 421`, `15 * 7`, `3+3`, `5*5`). The adapter therefore declares
+`cover` — a mechanism may not invent a label outside the pipeline's `Provenance`
+vocabulary, because post-grounding gates on it (see `pipeline-mechanism.ts`).
+The ALU's own act is named in the TRACE (`evalComputation`/`computeExtensions`),
+not in the provenance.
 
 ## Pins
 

package/docs/mechanisms/cast.md

@@ -58,6 +58,11 @@ Floor is `2·STEP`. Before touching the shared expensive analyses
 return the uninvested bound when it already loses. Never compute a shared
 analysis just to discard it.
 
+## Provenance
+
+`cast` — the answer came from counterfactual transfer (substitution,
+redirection, or analogical comparison), not from a literal continuation.
+
 ## Pins
 
 - **test/17 intelligence** — reordered single-fact must not trigger

package/docs/mechanisms/confluence.md

@@ -30,6 +30,13 @@ One currency (`mind/graph-search.ts`): `STEP=1`, `CONCEPT=10`, `PASS=1000`/byte.
 `moves = STEP·slots + CONCEPT` (floor `3·STEP`: two constraints + meet). Weight
 `moves + PASS·unaccounted` compared at `STEP` grade (`pipeline.ts:think`).
 
+## Provenance
+
+`join` — confluence is the mechanism that OWNS this provenance
+(`src/mind/mechanisms/confluence.ts` sets it when the independent evidence
+streams meet at one anchor). It is not cover's: cover reports `cover` for every
+derivation it wins (see `docs/mechanisms/cover.md`).
+
 ## Pins
 
 `test/32-confluence.test.mjs` — two-constraint intersection, order invariance,

package/docs/mechanisms/cover.md

@@ -45,8 +45,11 @@ by node pair. Bridges (`bridge`) splice connectors between rewrites.
 
 ## Provenance
 
-`cover` for the query's own cover; `join` when fusing fragments into a deeper
-learned form.
+`cover` for every cover derivation — including the fusion/recomposition steps
+(`fuse`/`recompose`) that name a deeper learned form. (`join` is NOT cover's:
+that provenance belongs to the CONFLUENCE mechanism, which reports it when
+independent evidence streams meet at one anchor — see
+`docs/mechanisms/confluence.md`.)
 
 ## Pins
 

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.8",
   "exports": "./src/index.ts"
 }

package/package.json

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

package/src/mind/graph-search.ts

@@ -115,6 +115,14 @@ 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 DERIVE-THROUGH produced: a produced fact's own contained
+     *  entity (the subject the query never named) combined with the query's tail
+     *  named a learned key, and that key's continuation is this out.  Part of
+     *  {@link key} so the derived reading is a distinct chart item from the plain
+     *  concatenation of the same bytes.  Named for what it does — derive THROUGH
+     *  a produced fact — because `join` is already the confluence mechanism's
+     *  `Provenance`, a different act at a different layer. */
+    throughFact?: boolean;
   };
 type OutItem = Extract<GItem, { kind: "out" }>;
 
@@ -240,6 +248,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
+  | "derive-through" // out→out: a produced fact's own contained subject + the query's tail names a learned key (derive the answer through the fact)
   | "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 +285,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.throughFact ? "derive-through" : "split";
+    }
     return "step";
   }
   if (premises.length === 2) {
@@ -400,11 +413,12 @@ export class GraphSearch {
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
-    /** When given, receives the lightest derivation's rule applications — the
-     *  full adapted A*LD proof tree as classified {@link DerivationStep}s — for the TOP
-     *  cover only (a recursive recompletion solves its own sub-cover and is not
-     *  reported here, to keep the trace one layer per think).  Off by default,
-     *  so the search pays nothing when no one inspects. */
+    /** When given, receives each solved span's lightest derivation — the full
+     *  adapted A*LD proof tree as classified {@link DerivationStep}s — for the
+     *  TOP cover AND every nested completion the sink is threaded into (see
+     *  {@link recompleteNode}), so a produced form's own recompositions reach
+     *  the rationale instead of stopping at the first layer.  Off by default, so
+     *  the search pays nothing when no one inspects. */
     onDerivation?: (steps: DerivationStep[]) => void,
   ): { segs: Seg[]; cost: number } | null {
     // Top-level entry: reset the per-call recursion state, then run the one
@@ -551,6 +565,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 +610,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.throughFact ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
       },
       *axioms() {
         yield { item: { kind: "cover", p: 0 }, cost: 0 };
@@ -697,6 +718,8 @@ export class GraphSearch {
           findBranchU,
           linksByLeft,
           linksByRight,
+          queryBytes,
+          queryLen,
         });
       },
     };
@@ -1113,10 +1136,70 @@ export class GraphSearch {
    *  open — the invariant a reader needs to check the guard. */
   private recompleteOpen = new Set<number>();
 
+  /** DERIVE-THROUGH — a RULE this module's DeductionSystem was missing.  The
+   *  A*LD library is untouched: this is one more `premises → conclusion + cost`
+   *  rule in the system {@link buildSearch} hands to {@link lightestDerivation},
+   *  the same kind of rule as `fuse`/`recompose` — not an extension of
+   *  `src/derive`, and not a grounding mechanism.  It derives 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
+   *  fact reached through it.  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 `derive-through`), distinct from the
+   *  byte-concatenating `fuse`/`splice` — and named `derive-through` rather than
+   *  `join` so it cannot be read as the confluence mechanism's `Provenance`. */
+  private *deriveThrough(
+    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],
+          throughFact: 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 deriveThrough}). */
   private *outRules(
     it: OutItem,
     ctx: {
@@ -1133,6 +1216,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 +1310,19 @@ 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);
+
+    // ── DERIVE-THROUGH (one more rule of the DeductionSystem this module builds)
+    // 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 relational join, distinct
+    // from the confluence mechanism's `join` PROVENANCE — and 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.deriveThrough(it, ctx.queryBytes, ctx.queryLen);
+    }
   }
 
   /** Whether the query span [from, to) is wholly covered by RECOGNISED outs —

package/src/mind/mechanisms/alu.ts

@@ -16,14 +16,16 @@ import type { PipelineMechanism } from "../pipeline-mechanism.js";
 export function aluToMechanism(alu: Alu): PipelineMechanism {
   return {
     name: "alu",
-    // Not a cover derivation: cover.ts composes an answer by walking
-    // recognised query STRUCTURE; the ALU evaluates a recognised expression
-    // to its authoritative result and hands the bytes back untouched. It
-    // shares cover's near-zero floor (computation always wins, masked into
-    // cover's own search — see mechanisms/cover.ts), but the candidate this
-    // produces is not one of cover's derivations, so it carries its own
-    // honest label, the same way extract/cast/recall each carry theirs.
-    provenance: "alu",
+    // The computation is GROUNDED BY COVER: this adapter's `parse` puts the
+    // authoritative span into `pre.computed`, cover masks it, and cover's
+    // derivation is what carries the answer out — measured, every computed
+    // probe reports provenance `cover`. So the adapter declares the core
+    // provenance the answer actually has. The ALU's own act is named where it
+    // belongs, in the TRACE (`evalComputation`, emitted by its `parse`), not in
+    // the provenance: a mechanism may not invent a label outside the pipeline's
+    // `Provenance` vocabulary, because post-grounding gates on that vocabulary
+    // (see the `provenance` contract in pipeline-mechanism.ts).
+    provenance: "cover",
     parse: (query) => alu.parse(query),
     async floor(_ctx, _query, pre, _worthRunning) {
       return pre.computed.length > 0 ? 0 : null;

package/src/mind/mind.ts

@@ -410,8 +410,9 @@ export class Mind implements MindContext {
       // `makeKeyring`, `Space.rand` and the `Alphabet` below, so folding a
       // query under config.ts's default (42) against a store trained with
       // another seed (e.g. 7) lands in a DIFFERENT vector space than the one
-      // the artifact's nodes were folded into: recognition and resonance then
-      // read the wrong space and every answer degrades silently.  An explicit
+      // the artifact's nodes were folded into: recognition and resonance read
+      // the wrong space, and answers silently diverge — pinned by test/97,
+      // where only adoption reproduces the artifact's own answer.  An explicit
       // caller seed still wins — this only replaces the unconfigured default.
       if (explicitSeed === undefined && this.store.trainSeed !== null) {
         this.cfg.seed = this.store.trainSeed;

package/src/mind/pipeline-mechanism.ts

@@ -712,7 +712,13 @@ export interface PipelineMechanism {
   /** Stable identifier for trace/debug. */
   readonly name: string;
 
-  /** Which provenance tag the pipeline attaches to this mechanism's answers. */
+  /** Which provenance tag the pipeline attaches to this mechanism's answers.
+   *  DECLARED, not free-form: the pipeline narrows it to its own `Provenance`
+   *  vocabulary (pipeline.ts), because post-grounding gates on that vocabulary
+   *  — so an adapter declares one of those values, never a label of its own.
+   *  The type is `string` only because a mechanism imports nothing from
+   *  `pipeline.ts` (constraint 1, decoupling); the contract is semantic, and
+   *  every shipped adapter honours it (see mechanisms/alu.ts). */
   readonly provenance: string;
 
   /** Parse authoritative spans BEFORE the grounding loop.

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 does not hold for every embedded form: the
+        // chain grows single-byte leaf ids and SKIPS a prefix whose
+        // `findBranch(ids)` is null, so a form the write side stored as a nested
+        // tree rather than as a flat leaf-id branch is never `resolveSpan`ned
+        // (measured: "Gustaf Molander" embedded in "The director of Eva is
+        // Gustaf Molander." gains no branch at any prefix), 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,26 @@ 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 within the same `chainReach(W)` span bound 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.
+      // Only pairs whose span lies in [W, chainReach(W)] are PROBED, which is
+      // the O(n · W²) work that matters; the enumeration itself is the all-pairs
+      // scan, each pair a constant-time span check — and the span bound is what
+      // keeps this off the quadratic path 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",
+  "derive-through":
+    "derive the answer through a produced fact's own subject and the query's tail, 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/97-store-seed.test.mjs

@@ -6,8 +6,9 @@
 // authoritative for the artifact.  The seed feeds `makeKeyring`, `Space.rand`
 // and the `Alphabet` in the Mind constructor: folding a query under any other
 // seed lands in a DIFFERENT vector space than the one the artifact's nodes were
-// folded into, so recognition and resonance read the wrong space and every
-// answer degrades silently.
+// folded into, so recognition and resonance read the wrong space and answers
+// silently diverge — this file pins that only adoption reproduces the
+// artifact's own answer.
 //
 // The store recovers `train.D` and `geometry.maxGroup` from its own metadata at
 // open; `train.seed` must be recovered the same way, and a Mind that did not

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

@@ -0,0 +1,99 @@
+// 99-fact-join.test.mjs — DERIVE-THROUGH: 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 `deriveThrough` 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 `derive-through` in the rationale.  (The operation
+// is a relational join; the MOVE is named `derive-through` so it cannot be read
+// as the confluence mechanism's `join` PROVENANCE.)
+//
+// 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 derive-through move.  That rule 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("derive-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("derive-through"),
+    `expected derive-through to be the move that reached the answer, got: ${
+      [...new Set(moves)].join(", ")
+    }`,
+  );
+  await store.close();
+});
+
+test("naming the intermediate does not need derive-through — 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 derive-through 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("derive-through"),
+    "a named intermediate must not be reported as derive-through",
+  );
+  await store.close();
+});