@hviana/sema 0.7.7 → 0.7.9

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

@@ -73,12 +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 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;
+    /** 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;
@@ -142,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" | "join-fact" | "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. */
@@ -186,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;
@@ -318,25 +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;
-    /** JOIN — the move the substrate was missing: derive the answer THROUGH a
-     *  produced fact, without the intermediate key being named in the query.
+    /** 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
-     *  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 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)), fusing with an adjacent
      *  finalised out, and — for a produced fact — JOINING the entity it contains
-     *  with the query's tail ({@link join}). */
+     *  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

@@ -104,7 +104,7 @@ function classifyMove(premises, conclusion, articulating) {
         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 conclusion.throughFact ? "derive-through" : "split";
         }
         return "step";
     }
@@ -222,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
@@ -367,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.join ? 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 };
@@ -866,20 +867,25 @@ 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.
+    /** 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
-     *  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) {
+     *  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);
@@ -892,8 +898,16 @@ export class GraphSearch {
         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))
+            // The admission predicate has ONE definition — `traverse.ts`'s
+            // `leadsSomewhere` (edge or halo).  The host LENDS it when it can (Mind
+            // does, with the response-scoped struct cache); a bare host falls back to
+            // the raw-store probe, so the search stays host-based.  Same semantics
+            // either way; the hook spares the repeated probe and keeps the predicate
+            // from being redefined here.
+            const leads = this.host.leadsSomewhere !== undefined
+                ? this.host.leadsSomewhere(site.payload)
+                : this.store.hasNext(site.payload) || this.store.hasHalo(site.payload);
+            if (!leads)
                 continue;
             const key = this.host.resolve(concat2(this.store.bytesPrefix(site.payload, ALL), tail));
             if (key === null)
@@ -911,7 +925,7 @@ export class GraphSearch {
                     cover: true,
                     rec: true,
                     node: nx[0],
-                    join: true,
+                    throughFact: true,
                 },
                 cost: STEP,
             };
@@ -921,7 +935,7 @@ export class GraphSearch {
      *  learnt connector (the in-search bridge), splitting (at a sub-leaf form
      *  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}). */
+     *  with the query's tail ({@link deriveThrough}). */
     *outRules(it, ctx) {
         const { splits, coversDone, outsByStart, outsByEnd, coverableByStart } = ctx;
         const outsByNode = ctx.outsByNode;
@@ -1014,16 +1028,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) ───────────────────────────────────────
+        // ── 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 two-fact join, not the
+        // 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.join(it, ctx.queryBytes, ctx.queryLen);
+            yield* this.deriveThrough(it, ctx.queryBytes, ctx.queryLen);
         }
     }
     /** Whether the query span [from, to) is wholly covered by RECOGNISED outs —

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.d.ts

@@ -150,6 +150,11 @@ export declare class Mind implements MindContext {
     private _conversations;
     /** Canonical node id of a byte span.  Required by GraphSearchHost & MindContext. */
     resolve(bytes: Uint8Array): number | null;
+    /** Whether a node leads somewhere — the admission predicate, delegating to
+     *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
+     *  cache).  The search holds a bare Store and cannot reach that cache itself,
+     *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    leadsSomewhere(id: number): boolean;
     recogniseSpan(bytes: Uint8Array): {
         sites: ReadonlyArray<Site>;
         leaves: ReadonlyArray<Leaf>;

package/dist/src/mind/mind.js

@@ -20,7 +20,7 @@ import { GraphSearch, } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import { decodeText, Rationale, } from "./rationale.js";
 import { gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";
-import { chooseNext, edgeAncestors as edgeAncestorsFn, invalidateStructuralCaches, } from "./traverse.js";
+import { chooseNext, edgeAncestors as edgeAncestorsFn, invalidateStructuralCaches, leadsSomewhere, } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
 import { recognise, segment } from "./recognition.js";
@@ -112,6 +112,13 @@ export class Mind {
     resolve(bytes) {
         return resolveImpl(this, bytes);
     }
+    /** Whether a node leads somewhere — the admission predicate, delegating to
+     *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
+     *  cache).  The search holds a bare Store and cannot reach that cache itself,
+     *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    leadsSomewhere(id) {
+        return leadsSomewhere(this, id);
+    }
     // recogniseSpan wraps recognise
     recogniseSpan(bytes) {
         const r = recognise(this, bytes);
@@ -155,8 +162,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

@@ -503,18 +503,18 @@ function recogniseImpl(ctx, bytes) {
             const probe = (start, end, canonBudget) => {
                 // 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.
+                // 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) {
@@ -579,13 +579,15 @@ 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).
+            // 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) {

package/dist/src/mind/trace.js

@@ -50,7 +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",
+    "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/dist/src/mind/types.d.ts

@@ -35,6 +35,12 @@ export interface GraphSearchHost {
         starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
+    /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
+     *  definition: does this node bear an edge or a halo?  Optional, so a bare
+     *  host (a raw Store and nothing else) still works; when present, the search
+     *  uses it rather than re-probing the store, which keeps the predicate
+     *  single-defined AND memoised on the response-scoped struct cache. */
+    leadsSomewhere?(id: number): boolean;
 }
 export interface Recognition {
     /** Forms that can lead somewhere — they have an edge or a halo. */

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

package/package.json

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

package/src/mind/graph-search.ts

@@ -115,12 +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 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;
+    /** 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" }>;
 
@@ -246,7 +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
-  | "join-fact" // out→out: a produced fact's own contained subject + the query's tail names a learned key (the join)
+  | "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)
@@ -286,7 +288,7 @@ function classifyMove(
     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 conclusion.throughFact ? "derive-through" : "split";
     }
     return "step";
   }
@@ -411,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
@@ -607,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.join ? 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 };
@@ -1133,20 +1136,25 @@ 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.
+  /** 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
-   *  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 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,
@@ -1160,10 +1168,16 @@ export class GraphSearch {
     // 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;
+      // The admission predicate has ONE definition — `traverse.ts`'s
+      // `leadsSomewhere` (edge or halo).  The host LENDS it when it can (Mind
+      // does, with the response-scoped struct cache); a bare host falls back to
+      // the raw-store probe, so the search stays host-based.  Same semantics
+      // either way; the hook spares the repeated probe and keeps the predicate
+      // from being redefined here.
+      const leads = this.host.leadsSomewhere !== undefined
+        ? this.host.leadsSomewhere(site.payload)
+        : this.store.hasNext(site.payload) || this.store.hasHalo(site.payload);
+      if (!leads) continue;
       const key = this.host.resolve(
         concat2(this.store.bytesPrefix(site.payload, ALL), tail),
       );
@@ -1180,7 +1194,7 @@ export class GraphSearch {
           cover: true,
           rec: true,
           node: nx[0],
-          join: true,
+          throughFact: true,
         },
         cost: STEP,
       };
@@ -1191,7 +1205,7 @@ export class GraphSearch {
    *  learnt connector (the in-search bridge), splitting (at a sub-leaf form
    *  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}). */
+   *  with the query's tail ({@link deriveThrough}). */
   private *outRules(
     it: OutItem,
     ctx: {
@@ -1303,16 +1317,17 @@ 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) ───────────────────────────────────────
+    // ── 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 two-fact join, not the
+    // 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.join(it, ctx.queryBytes, ctx.queryLen);
+      yield* this.deriveThrough(it, ctx.queryBytes, ctx.queryLen);
     }
   }
 

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

@@ -159,6 +159,7 @@ import {
   chooseNext,
   edgeAncestors as edgeAncestorsFn,
   invalidateStructuralCaches,
+  leadsSomewhere,
 } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
@@ -343,6 +344,14 @@ export class Mind implements MindContext {
     return resolveImpl(this, bytes);
   }
 
+  /** Whether a node leads somewhere — the admission predicate, delegating to
+   *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
+   *  cache).  The search holds a bare Store and cannot reach that cache itself,
+   *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+  leadsSomewhere(id: number): boolean {
+    return leadsSomewhere(this, id);
+  }
+
   // recogniseSpan wraps recognise
   recogniseSpan(bytes: Uint8Array): {
     sites: ReadonlyArray<Site>;
@@ -410,8 +419,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

@@ -520,18 +520,18 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       ): void => {
         // 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.
+        // 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;
@@ -589,13 +589,15 @@ 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).
+      // 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) {

package/src/mind/trace.ts

@@ -75,8 +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",
+  "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/src/mind/types.ts

@@ -65,6 +65,12 @@ export interface GraphSearchHost {
     starts: ReadonlySet<number>;
   };
   chooseNext?(node: number): number | undefined;
+  /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
+   *  definition: does this node bear an edge or a halo?  Optional, so a bare
+   *  host (a raw Store and nothing else) still works; when present, the search
+   *  uses it rather than re-probing the store, which keeps the predicate
+   *  single-defined AND memoised on the response-scoped struct cache. */
+  leadsSomewhere?(id: number): boolean;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -1,20 +1,22 @@
-// 99-fact-join.test.mjs — the JOIN: derive the answer THROUGH a produced fact
-// whose subject the query never names.
+// 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 `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.
+// 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 join.  The join is what carries the chain at corpus scale,
+// 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.
@@ -55,7 +57,7 @@ async function pastTheFlip() {
   return { store, mind };
 }
 
-test("a join derives through a produced fact whose subject the query never names", async () => {
+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(
@@ -71,17 +73,17 @@ test("a join derives through a produced fact whose subject the query never names
 
   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: ${
+    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 the join — the cover reads it directly", async () => {
+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 join is claimed.
+  // cover already reaches the chain, so no derive-through is claimed.
   const { store, mind } = await pastTheFlip();
   const moves = [];
   const out = await mind.respondText(
@@ -90,8 +92,8 @@ test("naming the intermediate does not need the join — the cover reads it dire
   );
   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",
+    !moves.includes("derive-through"),
+    "a named intermediate must not be reported as derive-through",
   );
   await store.close();
 });