@hviana/sema 0.2.2 → 0.2.4

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

@@ -63,6 +63,7 @@ function readCover(derivation) {
                 bytes: out.bytes,
                 rec: out.rec,
                 node: out.node,
+                computed: out.computed,
             });
         }
         node = node.premises[0];
@@ -205,7 +206,7 @@ export class GraphSearch {
      *  Any learnt connector between two rewrites is spliced IN by the in-search
      *  connector rule (see {@link outRules}), so the returned spans already carry
      *  it — there is no post-pass. */
-    cover(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults, 
+    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
@@ -221,6 +222,7 @@ export class GraphSearch {
             sites,
             leaves,
             splits,
+            starts,
         }, conceptTarget, substitutions, connectors, computedResults, onDerivation);
     }
     /** Build the deduction system for one span and return its lightest cover's
@@ -237,7 +239,7 @@ export class GraphSearch {
      *  decomposes, two recomposes, any mix — and stops only when it reaches a node
      *  that leads nowhere new, never at an arbitrary count. */
     solve(spanLen, recognition, conceptTarget, substitutions, connectors, computedResults, onDerivation) {
-        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, substitutions, connectors, computedResults);
+        const system = this.buildSearch(spanLen, recognition.sites, conceptTarget, recognition.leaves, recognition.splits, recognition.starts, substitutions, connectors, computedResults);
         const derivation = lightestDerivation(system);
         // When covering under a substitution map (articulation), a form→out rule is
         // the form EMITTING the asker's voice, not grounding to its own answer — so
@@ -257,8 +259,15 @@ export class GraphSearch {
      *  adjacent fragments toward a known leaf (findLeaf) or branch (findBranch);
      *  a completion fused with its neighbour may spell a deeper learned form the
      *  flat probes can't name, recovered canonically by {@link resolve}. */
-    buildSearch(queryLen, sites, conceptTarget, leaves, splits, substitutions, connectors, computedResults) {
+    buildSearch(queryLen, sites, conceptTarget, leaves, splits, starts, substitutions, connectors, computedResults) {
         const W = this.maxGroup; // fusible span ceiling (shortest composite bound)
+        // Same corpus-scale hub floor {@link atomIsHub}/{@link atomReach} (traverse.ts)
+        // derive for byte atoms — duplicated here rather than imported because this
+        // module is deliberately host-based (no MindContext), and both inputs
+        // (maxGroup, edgeSourceCount) are already in scope with no ctx needed.  If
+        // the formula ever changes, it must change in BOTH places (see canonical.ts's
+        // header for the same write/read-side duplication convention).
+        const atomsAreHubs = Math.max(1, Math.ceil((this.store.edgeSourceCount() * W) / 256)) > Math.ceil(Math.sqrt(Math.max(2, this.store.edgeSourceCount())));
         const nodeBytes = (n) => this.store.bytesPrefix(n, ALL);
         // Content-addressed probes over the store's hash-cons maps — the same keys
         // training filled.  No byte-by-byte trie walk.
@@ -350,6 +359,7 @@ export class GraphSearch {
                             cover: true,
                             rec: true,
                             node: u.node,
+                            computed: true,
                         },
                         cost: STEP,
                     };
@@ -388,6 +398,8 @@ export class GraphSearch {
                 return this.outRules(it, {
                     W,
                     splits,
+                    starts,
+                    atomsAreHubs,
                     coversDone,
                     outsByStart,
                     outsByEnd,
@@ -845,7 +857,23 @@ export class GraphSearch {
      *  enters the graph as a form the moment it names a node. */
     *fuse(l, r, ctx) {
         const bytes = concat2(l.bytes, r.bytes);
-        let node = bytes.length <= ctx.W ? ctx.findLeafU(bytes) : undefined;
+        // A PURE leaf-leaf fuse (neither side already a recognised completion)
+        // is opportunistic cross-leaf recovery exactly like recognition.ts's own
+        // canonical chain — findLeaf/findBranch here have no idea WHY these two
+        // leaves are adjacent, only that their concatenation happens to spell a
+        // trained form ("hi" recovered from "W[hi]ch").  The same corpus-scale
+        // caution recognition.ts's `boundary` gate applies: trust it fully when
+        // `l.i` is a position the query's OWN fold chose as a boundary (real
+        // structural evidence); past the scale where atoms themselves stop
+        // discriminating, an interior offset's opportunistic match is noise, not
+        // a genuine cross-leaf recovery.  A completion-involved fuse (l.rec ||
+        // r.rec) is a different, legitimate case — a rewrite growing into its
+        // neighbour — and is exempt, same as recognition.ts's rec-derived sites.
+        const trusted = l.rec || r.rec || ctx.starts.has(l.i) ||
+            !ctx.atomsAreHubs;
+        let node = (trusted && bytes.length <= ctx.W)
+            ? ctx.findLeafU(bytes)
+            : undefined;
         // Whether this pair ACTUALLY forms a 2-child branch — the hard evidence
         // that the fused bytes are a learned form worth keeping alive.  Derived
         // from the same findBranchU probe that sets `node`; when false, the pair
@@ -853,7 +881,8 @@ export class GraphSearch {
         // node cannot contribute to any further fusion (findBranch needs two
         // nodes, resolve needs a completion, and findLeaf already had its chance).
         let pairFormsBranch = false;
-        if (node === undefined && l.node !== undefined && r.node !== undefined) {
+        if (trusted && node === undefined && l.node !== undefined &&
+            r.node !== undefined) {
             node = ctx.findBranchU([l.node, r.node]);
             pairFormsBranch = node !== undefined;
         }

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

@@ -64,8 +64,21 @@ export declare function haloSiblings(ctx: MindContext, id: number, halo?: Vec |
  *  strength, not a pick.  Returns the direct halo cosine, or failing that the
  *  highest mutual-halo-sibling min-score (second-order analogy), or failing
  *  that the SHARED-FRAME strength (below) — the gate CAST's comparison
- *  schema validates genuine analogs with (bar: significanceBar). */
-export declare function analogyStrength(ctx: MindContext, a: number, b: number): Promise<number>;
+ *  schema validates genuine analogs with (bar: significanceBar).
+ *
+ *  The result names its TIER alongside the score: `halo: true` means the
+ *  score cleared a significanceBar-gated HALO tier (direct company cosine
+ *  or mutual-sibling) — genuine distributional evidence; `halo: false`
+ *  means only the structural shared-frame fallback matched, a coverage
+ *  fraction with no bar of its own.  CAST's comparison gate treats the two
+ *  differently (see cast.ts): halo evidence stands alone, frame evidence
+ *  needs the query to have named the analog or the climb root to be
+ *  trusted. */
+export interface AnalogyEvidence {
+    score: number;
+    halo: boolean;
+}
+export declare function analogyStrength(ctx: MindContext, a: number, b: number): Promise<AnalogyEvidence>;
 /** The STRUCTURAL analogy tier: two nodes are analogs when their byte
  *  streams share a LEARNT frame — a content-addressed flat form of at least
  *  one full river window (W bytes, the perception quantum) that occurs in

package/dist/src/mind/match.js

@@ -257,11 +257,6 @@ export async function haloSiblings(ctx, id, halo, bar = conceptThreshold(ctx.sto
         memo.set(id, out);
     return out;
 }
-/** The DISTRIBUTIONAL matcher between two nodes: mutual-nearest-neighbour
- *  strength, not a pick.  Returns the direct halo cosine, or failing that the
- *  highest mutual-halo-sibling min-score (second-order analogy), or failing
- *  that the SHARED-FRAME strength (below) — the gate CAST's comparison
- *  schema validates genuine analogs with (bar: significanceBar). */
 export async function analogyStrength(ctx, a, b) {
     const ha = ctx.store.halo(a);
     const hb = ctx.store.halo(b);
@@ -269,7 +264,7 @@ export async function analogyStrength(ctx, a, b) {
         const bar = significanceBar(ctx.store.D);
         const direct = cosine(ha, hb);
         if (direct >= bar)
-            return direct;
+            return { score: direct, halo: true };
         const sibsA = await haloSiblings(ctx, a, ha, bar);
         const sibsB = await haloSiblings(ctx, b, hb, bar);
         let best = 0;
@@ -282,9 +277,9 @@ export async function analogyStrength(ctx, a, b) {
             }
         }
         if (best > 0)
-            return best;
+            return { score: best, halo: true };
     }
-    return sharedFrameStrength(ctx, a, b);
+    return { score: sharedFrameStrength(ctx, a, b), halo: false };
 }
 /** The STRUCTURAL analogy tier: two nodes are analogs when their byte
  *  streams share a LEARNT frame — a content-addressed flat form of at least

package/dist/src/mind/mechanisms/alu.js

@@ -12,7 +12,14 @@ import { unexplainedLabel } from "../rationale.js";
 export function aluToMechanism(alu) {
     return {
         name: "alu",
-        provenance: "cover",
+        // 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",
         parse: (query) => alu.parse(query),
         async floor(_ctx, _query, pre, _worthRunning) {
             return pre.computed.length > 0 ? 0 : null;

package/dist/src/mind/mechanisms/cast.d.ts

@@ -1,4 +1,5 @@
 import type { MindContext } from "../types.js";
+import type { Vec } from "../../vec.js";
 /** A CAST answer plus its elementary evidence for think's grounding decider:
  *  `accounted` — the query spans the weave's aligned runs explain; `moves` —
  *  the ladder cost of the acts the taken branch performed (STEP per
@@ -13,6 +14,59 @@ export interface CastResult {
      *  Task 2 note in pipeline.ts's Candidate interface). */
     unexplained: string;
 }
+/** The seat that establishes a node's role in an analogical comparison:
+ *  the REVERSE context (what leads to it) when a predecessor genuinely
+ *  ESTABLISHES id — introduces or describes it by name — else the FORWARD
+ *  continuation (what it leads to), else `fallback`.
+ *
+ *  An earlier version gated this purely on `prevCount(id) > 0`: any
+ *  predecessor at all was treated as proof of a genuine named ENTITY
+ *  (seat it by what established it), while no predecessor meant a bare
+ *  learnt CONTEXT (seat it by what it leads to, since voicing it verbatim
+ *  would answer a question with a question).  That test measured the wrong
+ *  thing — a broad sample of this store's own question-shaped nodes showed
+ *  the large majority (≈71%) have at least one predecessor, most of them a
+ *  handful of generic, high-fan-out sentences that recur as an INCIDENTAL
+ *  neighbour to dozens of otherwise-unrelated destinations (a SmolSent-
+ *  style sentence-adjacency artifact, never naming or describing what
+ *  follows).  Traced live: "What is the capital of France?" — whose own
+ *  forward edge unambiguously resolves to "The capital of France is
+ *  Paris." — has exactly one such incidental predecessor ("Create an
+ *  example of a types of questions a GPT model can answer.?"), wrongly
+ *  read as disqualifying proof of "genuine entity."
+ *
+ *  A plain forward-first swap (matching {@link project}'s universal
+ *  priority) over-corrected: test/29's C2/C3 pin that a genuine entity
+ *  analog (e.g. "Leonardo da Vinci", established by "The Mona Lisa was
+ *  painted by Leonardo da Vinci.") must be seated by that establishing
+ *  sentence, NOT by its own biography fact — voicing the bio leaks exactly
+ *  what a comparison must keep out, and loses the embedded "Mona Lisa"
+ *  term C3 relies on for a further hop.
+ *
+ *  The distinguishing signal is content-addressed, not a count: a genuine
+ *  establishing predecessor's bytes CONTAIN id's own bytes — it names or
+ *  describes id ("...painted by Leonardo da Vinci." contains "Leonardo da
+ *  Vinci").  An incidental adjacency predecessor never does — it merely
+ *  preceded id in some unrelated document without ever mentioning it.  No
+ *  new tuned constant: containment is the same primitive `restatesQuery`
+ *  and `dominates`-style checks already use throughout this codebase.
+ *
+ *  `allowForward` (default true) gates the FORWARD branch specifically —
+ *  see the call sites below: the DOMINANT is what the query is actually
+ *  ASKING, so completing it forward is the whole point; an ANALOG is only
+ *  being CITED for comparison; the query never asked about IT, so chasing
+ *  its own further continuation drifts onto whatever coincidentally
+ *  follows it in the corpus.  Traced live: the analog "What is the capital
+ *  of Japan?\nTokyo is the capital of Japan." is ALREADY a complete,
+ *  self-answering unit (prevCount 0, so no establishing predecessor
+ *  either) — its sole forward edge is "And what is the capital of the
+ *  Moon?", an unrelated quiz question sharing nothing but corpus
+ *  adjacency.  With forward disallowed, an analog like this falls through
+ *  to `fallback` — its own bytes, exactly the complete fact that made it a
+ *  genuine analog in the first place.  See
+ *  test/41-seatofnode-direction.test.mjs and
+ *  test/43-cast-analog-seat.test.mjs. */
+export declare function seatOfNode(ctx: MindContext, id: number, guide: Vec | null | undefined, fallback: Uint8Array, allowForward?: boolean): Promise<Uint8Array>;
 /** CAST's own entry gates, checked once here and reused by
 /** The main CAST entry point.  Given a query and its pre-computed pre.rec.sites,
  *  determine whether the query weaves together multiple independent learnt