@hviana/sema 0.2.1 → 0.2.3

package/dist/src/mind/recognition.js

@@ -41,8 +41,9 @@ function recogniseImpl(ctx, bytes) {
     const sites = [];
     const leaves = [];
     const splits = new Set();
+    const starts = new Set();
     if (bytes.length === 0)
-        return { sites, leaves, splits };
+        return { sites, leaves, splits, starts };
     // Span-resolve memo for THIS call: the structural pass (sub-runs inside
     // leaf-parents) and the canonical pass (leaf-id chains) probe overlapping
     // spans, and each resolve() is a full fold of the sub-span (fresh subarray
@@ -78,7 +79,6 @@ function recogniseImpl(ctx, bytes) {
         }
     };
     // ── structural: the query's own perceived tree ──────────────────────
-    const starts = new Set();
     starts.add(0);
     foldTree(ctx, perceive(ctx, bytes), 0, (n, start, end, node) => {
         if (n.kids === null) {
@@ -105,7 +105,16 @@ function recogniseImpl(ctx, bytes) {
                 leafOffsets.push(off);
                 off += k.leaf?.length ?? 0;
             }
+            // Sub-spans starting at i > 0 begin INSIDE the chunk, at an offset the
+            // query's own fold did not itself choose as a boundary — the same
+            // opportunistic byte-atom-chain risk `tryChain`'s `boundary` gate
+            // guards below (see its comment).  Only the chunk's own left edge
+            // (i === 0, already registered in `starts` above) carries the fold's
+            // evidence; interior sub-starts are exempt from the guard only while
+            // atoms themselves still discriminate at this corpus scale.
             for (let i = 0; i < n.kids.length; i++) {
+                if (i > 0 && atomsAreHubs)
+                    break;
                 const subIds = [];
                 for (let j = i; j < n.kids.length; j++) {
                     const kj = n.kids[j];
@@ -148,7 +157,20 @@ function recogniseImpl(ctx, bytes) {
             chunkEnd[p] = chunkLimit;
         }
     }
-    const tryChain = (p, maxIds) => {
+    // A chain rebuilt from a NON-boundary offset (the query's own perceived
+    // cut, `starts`, never chose to segment here) is opportunistic: the same
+    // byte-atom coincidence the hub guard above already exists for, just
+    // spelled over 2+ leaves instead of 1.  At small corpus scale that's fine
+    // — coincidence is rare and every chain is real evidence (see `atomIsHub`).
+    // Past the scale where atoms themselves stop discriminating, the same
+    // uniform-expectation argument bounds a CHAIN'S commonality too: it is at
+    // least as rare as its rarest atom, so a store where atoms are hubs makes
+    // interior chain reconstructions no more trustworthy than the atoms they
+    // are built from ("hi" resolving out of "W[hi]ch" is exactly this: two
+    // hub-scale atoms, chained at an offset nothing in the query's own fold
+    // selected).  Chains that start ON a boundary carry the fold's own
+    // evidence instead and are exempt.
+    const tryChain = (p, maxIds, boundary) => {
         const first = leafFrom(p);
         if (!first)
             return;
@@ -164,6 +186,8 @@ function recogniseImpl(ctx, bytes) {
             pos = nx.end;
             if (store.findBranch(ids) === null)
                 continue;
+            if (!boundary && atomsAreHubs)
+                continue;
             const id = resolveSpan(p, pos);
             if (id === null || id === prevId)
                 continue;
@@ -173,11 +197,11 @@ function recogniseImpl(ctx, bytes) {
     };
     for (let p = 0; p < bytes.length; p++) {
         if (starts.has(p)) {
-            tryChain(p, chainReach(W)); // boundary start — full reach
+            tryChain(p, chainReach(W), true); // boundary start — full reach
         }
         else {
             const limit = chunkEnd[p] + W;
-            tryChain(p, Math.min(limit - p, chainReach(W)));
+            tryChain(p, Math.min(limit - p, chainReach(W)), false);
         }
     }
     // ── splits: a form boundary that does not fall on a leaf edge ────────
@@ -195,7 +219,7 @@ function recogniseImpl(ctx, bytes) {
         s.end,
     ])), `decompose the query into ${sites.length} learnt form(s) that lead somewhere` +
         ` (over ${leaves.length} perceived leaves)`);
-    return { sites, leaves, splits };
+    return { sites, leaves, splits, starts };
 }
 /** Segment bytes using the geometry's own groupings — leaf-parent
  *  nodes from the perceived tree, with consecutive bare leaves merged

package/dist/src/mind/traverse.js

@@ -6,6 +6,7 @@
 // The PROJECTIONS built on these walks (follow, conceptHop, reverseContext,
 // project) live in match.ts — the elementary match-and-project operation.
 import { cosine } from "../vec.js";
+import { consensusFloor } from "../geometry.js";
 import { gistOf, read } from "./primitives.js";
 const structCaches = new WeakMap();
 function getStructCache(ctx) {
@@ -439,6 +440,20 @@ export function chooseNext(ctx, id, guide) {
             bestMass = mass;
         }
     }
+    // A pick among GENUINELY competing continuations still needs to clear the
+    // same genuine-corroboration floor {@link consensusFloor} draws for every
+    // other consumer that turns distinct-context support into a vote (the
+    // climb's recallByResonance/commitVotes) — below it, "most corroborated"
+    // is only the least-thin echo among several, not real evidence.  Gated to
+    // corpus scale large enough that this echo is even possible (the same
+    // scale {@link atomIsHub} already switches on for the identical reason:
+    // at small N every edge IS the evidence there is).  A hub id has no
+    // meaningful "distinct context" reading at all (id < 0 atoms are excluded
+    // from this path already, since chooseNext only ever sees real edges).
+    const N = corpusN(ctx);
+    if (capped.length > 1 && atomIsHub(ctx, N) && bestSupport < consensusFloor(N)) {
+        return undefined;
+    }
     // Trace is built lazily — the filter + map below only execute when a
     // trace listener is attached, so the common (no-trace) path pays only
     // for the prevCount calls in the loop above, never for extra rItemShort

package/dist/src/mind/types.d.ts

@@ -6,7 +6,25 @@ import type { Alphabet } from "../alphabet.js";
 import type { MindConfig } from "../config.js";
 import type { GraphSearch, Leaf, Seg, Site } from "./graph-search.js";
 import type { Rationale } from "./rationale.js";
-import type { FoldPyramid, Grid } from "../geometry.js";
+import type { FoldPyramid, Grid, StableFold } from "../geometry.js";
+/** One {@link MindContext._depositTrees} entry — see that field's doc. */
+export interface DepositCacheEntry {
+    /** Turn boundaries accumulated over this content's deposit chain —
+     *  strictly increasing proper offsets, each a previously-deposited
+     *  whole-context length.  Empty for a first-seen (single-turn) input. */
+    boundaries: number[];
+    /** Plain-fold pyramid (first-seen inputs only). */
+    pyramid?: FoldPyramid;
+    /** Stable-prefix segment folds (grown-context inputs only). */
+    stable?: StableFold;
+    /** The continuation bytes this ctxInput was paired with in ingestPair, if
+     *  any — the ONLY thing that makes a later, longer ctxInput a genuine next
+     *  TURN of the same conversation rather than an unrelated fact that
+     *  happens to share this one's byte prefix (e.g. "2+2" vs. "2+2=5").  A
+     *  later deposit only takes this entry as its stable-prefix `prev` when
+     *  its own suffix bytes-equal this exactly. */
+    nextBytes?: Uint8Array;
+}
 export type Input = string | Uint8Array | Grid | Grid[];
 /** The host capabilities GraphSearch consults during a cover.  MindContext
  *  extends this so the Mind can pass itself as the host. */
@@ -16,6 +34,7 @@ export interface GraphSearchHost {
         sites: ReadonlyArray<Site>;
         leaves: ReadonlyArray<Leaf>;
         splits: ReadonlySet<number>;
+        starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
 }
@@ -26,6 +45,13 @@ export interface Recognition {
     leaves: Leaf[];
     /** Sub-leaf positions where a form boundary falls between leaf edges. */
     splits: Set<number>;
+    /** Leaf-parent (chunk) start positions from the query's OWN perceived
+     *  fold — the positions the fold itself chose as a grouping boundary, as
+     *  opposed to an offset a byte-level scan merely happens to land on.  The
+     *  one boundary signal opportunistic cross-leaf recovery (recognition's
+     *  own canonical chains, the search's `fuse`) can lean on instead of
+     *  ASCII/word heuristics: see the `boundary` gate in recognition.ts. */
+    starts: Set<number>;
 }
 /** How the consensus climb weights a region's Document-Frequency reach. */
 export type DFMode = "inverse" | "direct" | "combined";
@@ -38,6 +64,16 @@ export interface Attention {
     /** The union of the query byte-spans whose evidence supports this point. */
     start: number;
     end: number;
+    /** SCALE-INVARIANT confidence: the fraction of the query's OWN regions
+     *  whose evidence this point accounts for (Σ RegionVote.absorbed among
+     *  its contributors, over the query's total region count) — read PER-
+     *  ANCHOR, unlike the raw IDF vote (an absolute, ln(N)-scaled quantity
+     *  that means "strong" on a small store and "weak" on a large one for
+     *  the SAME degree of genuine consensus).  A point whose breadth clears
+     *  `dominates` (> half the query's regions corroborate it) is real
+     *  consensus; one that does not is a coincidental single-region echo —
+     *  see test/35-attention-confidence.test.mjs. */
+    breadth: number;
 }
 /** Both read-outs of one consensus climb. */
 export interface AttentionRead {
@@ -71,6 +107,14 @@ export interface RegionVote {
     roots: readonly number[];
     w: number;
     wFocus: number;
+    /** How many of the query's ORIGINAL regions this one vote's evidence
+     *  accounts for.  1 for an ordinary per-region vote (itself); for a
+     *  cross-region junction vote, 1 (itself) plus however many individual
+     *  votes it explained away (see crossRegionVotes) — the junction speaks
+     *  for all of them at once, and breadth accounting must not undercount it
+     *  to "one region" just because it collapsed to one pooled axiom.
+     *  Defaults to 1 when absent. */
+    absorbed?: number;
 }
 /** The edge-bearing contexts reached by climbing from a node, plus saturation info. */
 export interface AncestorReach {
@@ -153,15 +197,19 @@ export interface MindContext extends GraphSearchHost {
      *  never invalidated.  Bounded LRU (byte-sized); a miss only re-perceives,
      *  never a correctness risk. */
     _gistCache: BoundedMap<number, Vec>;
-    /** DEPOSIT-path stable-prefix tree cache: content key (latin1) of a
-     *  deposited input → its plain-fold level PYRAMID, so the NEXT deposit
-     *  whose prefix it is (a conversation's accumulated context) reuses every
-     *  full aligned block and refolds only the right edge of each level —
-     *  O(turn) per deposit instead of O(context), with the tree BIT-IDENTICAL
-     *  to a from-scratch fold (see FoldPyramid).  Purely a performance cache.
-     *  Entry-count bounded (a pyramid is ~KB/byte of content; only the few
-     *  live conversation chains matter). */
-    _depositTrees: BoundedMap<string, FoldPyramid>;
+    /** DEPOSIT-path perception cache: content key (latin1) of a deposited
+     *  input → its accumulated turn BOUNDARIES plus reusable fold state.  A
+     *  deposit whose content extends a cached entry IS a conversation context
+     *  grown by one turn — the cached length is the new boundary — so it
+     *  folds with the SAME stable-prefix fold query-time perception uses
+     *  (structural train/inference agreement, load-bearing for recall),
+     *  reusing every already-folded segment via `stable` (see StableFold) —
+     *  O(turn) per deposit instead of O(context).  A first-seen input keeps
+     *  the plain fold and caches its `pyramid` (see FoldPyramid).  Purely a
+     *  performance cache for the FOLD STATE; the boundaries are semantic but
+     *  derived only from the deposit sequence itself (an evicted chain falls
+     *  back to plain-fold behavior, exactly the pre-boundary shape). */
+    _depositTrees: BoundedMap<string, DepositCacheEntry>;
     /** The byte lengths present in {@link _depositTrees} — the candidate
      *  prefix lengths probed (longest first).  Drifts on eviction (a stale
      *  length only costs a miss); cleared with the map when it outgrows the

package/dist/src/mind/types.js

@@ -26,6 +26,21 @@ export function liftAnswer(segs, queryLen) {
         return null;
     if (recognised.length === 1) {
         const s = segs[recognised[0]];
+        // A COMPUTED span's query-side width is operand digit-count, not
+        // evidence of how much of the query's meaning it accounts for — the
+        // half-dominance check below (built for a genuinely RECOGNISED learned
+        // form) is not a valid framing signal for it (see the `computed` field
+        // doc on Seg/GItem): "1000 - 421" outweighs "what is …?" by width only
+        // because the operands are big, not because the framing matters less.
+        // A LITERAL PREFIX before a computed span is unambiguous framing
+        // regardless of width — an arithmetic expression is never itself
+        // preceded by more literal computed content, so anything literal before
+        // it is question wording ("what is ", "compute ") to lift clear of.
+        // With no prefix (s.i === 0) the span is judged by the ordinary
+        // half-dominance rule below, which already correctly keeps a short
+        // trailing glue byte ("2+2." → "4.", the span dominates a 4-byte query).
+        if (s.computed && s.i > 0)
+            return s.bytes;
         if (dominates(s.j - s.i, queryLen)) {
             return concatBytes(segs.map((x) => x.bytes));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/geometry.ts

@@ -145,7 +145,7 @@ export function coverageBar(_maxGroup: number, D: number): number {
 
 // ---- types ----
 
-interface Folded {
+export interface Folded {
   tree: Sema;
   /** Byte length of the subtree — carried incrementally so the stable-prefix
    *  boundary scan never re-walks subtrees (the old per-level walk was
@@ -383,6 +383,66 @@ function stablePrefixFold(
   return cur.tree;
 }
 
+/** A stable-prefix fold's reusable state: the segment edge offsets and each
+ *  segment's independently-folded root ({@link riverFoldRaw} output).  A
+ *  grown stream whose boundary set EXTENDS a previous fold's reuses every
+ *  matching segment's Folded unchanged (segments fold independently by
+ *  construction, so reuse is bit-identical to refolding) and folds only the
+ *  new right-edge segment — O(turn) per extension, the stable-prefix
+ *  counterpart of {@link FoldPyramid}.  Purely a cache: the produced tree
+ *  never depends on cache state. */
+export interface StableFold {
+  edges: number[];
+  segs: Folded[];
+}
+
+/** {@link stablePrefixFold} with incremental segment reuse — same cuts, same
+ *  segment folds, same left-nested join, same single root normalize; `prev`
+ *  only elides recomputing segments whose [start,end) offsets it already
+ *  folded over a byte-identical prefix (the caller keys the cache by
+ *  content).  Requires a non-empty effective boundary set. */
+export function stablePrefixFoldIncremental(
+  space: Space,
+  alphabet: Alphabet,
+  bytes: Uint8Array,
+  boundaries: readonly number[],
+  prev?: StableFold,
+): { tree: Sema; fold: StableFold } {
+  const cuts: number[] = [];
+  let prevB = 0;
+  for (const b of boundaries) {
+    if (b > prevB && b < bytes.length) {
+      cuts.push(b);
+      prevB = b;
+    }
+  }
+  const edges = [0, ...cuts, bytes.length];
+  const segs: Folded[] = [];
+  for (let i = 0; i + 1 < edges.length; i++) {
+    const hit = prev !== undefined && prev.edges[i] === edges[i] &&
+        prev.edges[i + 1] === edges[i + 1]
+      ? prev.segs[i]
+      : undefined;
+    segs.push(
+      hit ??
+        riverFoldRaw(
+          space,
+          bytesToLeaves(alphabet, bytes.subarray(edges[i], edges[i + 1])),
+        ),
+    );
+  }
+  if (segs.length === 1) {
+    // Degenerate boundary set — the plain fold, as stablePrefixFold does.
+    const tree =
+      riverFold(space, bytesToLeaves(alphabet, bytes), bytes.length).tree;
+    return { tree, fold: { edges, segs } };
+  }
+  let cur = segs[0];
+  for (let i = 1; i < segs.length; i++) cur = fold2(space, cur, segs[i]);
+  normalize(cur.tree.v);
+  return { tree: cur.tree, fold: { edges, segs } };
+}
+
 /** Join two folded items as one 2-kid branch — the top-level join of the
  *  stable-prefix fold, identical FP ops to foldSlice's seat-bound
  *  accumulation over a group of two.  Unnormalized (interior). */

package/src/mind/articulation.ts

@@ -105,6 +105,7 @@ export async function articulate(
     new Map(),
     ans.leaves,
     ans.splits,
+    ans.starts,
     substitutions,
     undefined,
     undefined,

package/src/mind/attention.ts

@@ -417,6 +417,9 @@ export function poolVotes(
   votes: Map<number, number>;
   votesIdf: Map<number, number>;
   support: Map<number, { start: number; end: number; w: number }>;
+  /** Per-anchor SCALE-INVARIANT support: Σ RegionVote.absorbed over the
+   *  distinct contributing regions — see Attention.breadth. */
+  regionSupport: Map<number, number>;
   steps: DerivationStep[];
 } {
   const eligible: number[] = [];
@@ -496,6 +499,7 @@ export function poolVotes(
     number,
     { start: number; end: number; w: number }
   >();
+  const regionSupport = new Map<number, number>();
   const steps: DerivationStep[] = [];
   let order = 0;
   for (const pc of pool.values()) {
@@ -503,13 +507,16 @@ export function poolVotes(
       votes.set(pc.item.id, pc.cost);
       const premises: DerivationItem[] = [];
       const seenRi = new Set<number>();
+      let breadthSum = 0;
       for (const c of pc.contributions) {
         const p0 = c.premises[0].item;
         if (p0.kind !== "region" || seenRi.has(p0.ri)) continue;
         seenRi.add(p0.ri);
         const rv = regionVotes[p0.ri];
+        breadthSum += rv.absorbed ?? 1;
         premises.push({ kind: "form", span: [rv.start, rv.end] });
       }
+      regionSupport.set(pc.item.id, breadthSum);
       steps.push({
         order: order++,
         move: "pool-vote",
@@ -536,7 +543,7 @@ export function poolVotes(
       }
     }
   }
-  return { votes, votesIdf, support, steps };
+  return { votes, votesIdf, support, regionSupport, steps };
 }
 
 export function commitVotes(
@@ -545,6 +552,7 @@ export function commitVotes(
     votes: Map<number, number>;
     votesIdf: Map<number, number>;
     support: Map<number, { start: number; end: number; w: number }>;
+    regionSupport: Map<number, number>;
     steps: DerivationStep[];
   },
   sat: SaturationInfo,
@@ -552,16 +560,27 @@ export function commitVotes(
   regionVoter: ReadonlyArray<{ id: number; score: number; w: number } | null>,
   N: number,
 ): AttentionRead {
-  const { votes, votesIdf, support, steps } = pooled;
+  const { votes, votesIdf, support, regionSupport, steps } = pooled;
   if (votes.size === 0) {
     traceAttention(ctx, regions, regionVoter, [], steps);
     return { roots: [], ranked: [] };
   }
 
+  // SCALE-INVARIANT confidence — see Attention.breadth's doc.  regions.length
+  // is the query's OWN full candidate count (most never vote at all), the
+  // same denominator the "N of M sub-regions voted" rationale text already
+  // reports; regionSupport is that same accounting read PER ANCHOR.
+  const totalRegions = Math.max(1, regions.length);
   const ranked = [...votes.entries()]
     .map(([anchor, vote]) => {
       const s = support.get(anchor)!;
-      return { anchor, vote, start: s.start, end: s.end };
+      return {
+        anchor,
+        vote,
+        start: s.start,
+        end: s.end,
+        breadth: (regionSupport.get(anchor) ?? 0) / totalRegions,
+      };
     })
     .sort((a, b) => b.vote - a.vote);
 
@@ -867,6 +886,28 @@ async function crossRegionVotes(
       const rb = regions[cand[b]];
       if (!strong.has(cand[a]) && !strong.has(cand[b])) continue;
       if (ra.end >= rb.start) continue; // overlap or adjacent — nothing between
+      // Candidates strictly BETWEEN ra and rb (cand is sorted by start, so
+      // that is exactly cand[a+1 .. b-1]) that already cast their OWN vote —
+      // genuine, individually-corroborated evidence about what fills the gap
+      // — gate the container search below: a joint container is binding
+      // evidence only when it is CONSISTENT with that evidence, i.e. its own
+      // bytes actually contain what the between-region says. This is the
+      // n-ary composition's normal shape (a between-attribute's bytes DO
+      // recur inside the joint container, credited as an "extra" below) as
+      // opposed to a container that silently substitutes something else for
+      // it (e.g. bridging past "Italy" to a container whose interior is
+      // "Japan" — a different, contradicting learnt whole).
+      // Only a KNOWN (content-addressed, exact) between-region qualifies —
+      // an approximate region's resonance climbing "somewhere" is ordinary
+      // noise (any ANN query returns SOME nearest neighbour), not evidence
+      // this specific gap already means something specific.
+      const between: number[] = [];
+      for (let m = a + 1; m < b; m++) {
+        if (
+          strong.has(cand[m]) && !consumed.has(cand[m]) &&
+          regions[cand[m]].known
+        ) between.push(cand[m]);
+      }
       // A single KNOWN region covering both: the whole form is already a
       // stored identity that votes directly; its pieces add nothing.
       if (
@@ -932,6 +973,22 @@ async function crossRegionVotes(
           );
           if (indexOf(query, joined, 0) >= 0) continue; // query says it itself
         }
+        // CONTRADICTION GUARD: a between-region already carrying its own
+        // vote must actually recur in this container's bytes — otherwise
+        // the container is a different learnt whole that happens to share
+        // ra/rb, and letting it stand in for the gap would silently
+        // override evidence the query itself already resolved there.
+        if (
+          between.some((bi) =>
+            indexOf(
+              bytes,
+              query.subarray(regions[bi].start, regions[bi].end),
+              0,
+            ) < 0
+          )
+        ) {
+          continue;
+        }
         let cov = left.length + right.length;
         const extras: number[] = [];
         for (const ei of cand) {
@@ -978,14 +1035,6 @@ async function crossRegionVotes(
         spanStart = Math.min(spanStart, regions[ei].start);
         spanEnd = Math.max(spanEnd, regions[ei].end);
       }
-      out.push({
-        start: spanStart,
-        end: spanEnd,
-        canonicalFailed: false, // content-addressed: never saturation-masked
-        roots: reach.roots,
-        w,
-        wFocus: w,
-      });
       consumed.add(cand[a]);
       consumed.add(cand[b]);
       for (const ei of bestExtras) consumed.add(ei);
@@ -995,14 +1044,33 @@ async function crossRegionVotes(
       // vote's bytes are literally part of the learnt whole), and FULL root
       // disjointness is the disagreement test: a vote sharing even one root
       // with the junction corroborates it and keeps its say elsewhere.
+      // Counted BEFORE pushing the junction's own vote below: each ORIGINAL
+      // region this ascent explains away is evidence the junction speaks
+      // for, not evidence lost — `absorbed` (RegionVote's breadth-accounting
+      // field) must credit the junction with all of it, not just the ONE
+      // pooled axiom it collapses to.
       const containerBytes = cachedRead(ctx, cache, best.id, cap);
       const jointRoots = new Set(reach.roots);
+      let explainedAway = 0;
       for (const rv of rvs.votes) {
         if (rv.roots.some((r) => jointRoots.has(r))) continue;
         const bytes = query.subarray(rv.start, rv.end);
-        if (indexOf(containerBytes, bytes, 0) >= 0) superseded.add(rv);
+        if (indexOf(containerBytes, bytes, 0) >= 0 && !superseded.has(rv)) {
+          superseded.add(rv);
+          explainedAway++;
+        }
       }
 
+      out.push({
+        start: spanStart,
+        end: spanEnd,
+        canonicalFailed: false, // content-addressed: never saturation-masked
+        roots: reach.roots,
+        w,
+        wFocus: w,
+        absorbed: 1 + explainedAway,
+      });
+
       const label = [cand[a], cand[b], ...bestExtras]
         .sort((x, y) => regions[x].start - regions[y].start)
         .map((ri) => dec(query.subarray(regions[ri].start, regions[ri].end)))