@hviana/sema 0.2.2 → 0.2.4

package/src/mind/graph-search.ts

@@ -96,6 +96,18 @@ export type GItem =
     cover: boolean;
     rec: boolean;
     node?: number;
+    /** Set only for a {@link ComputedResult} axiom (an extension's derived
+     *  value, e.g. ALU arithmetic) — as opposed to a genuinely RECOGNISED
+     *  learned form.  Both set `rec: true` (a computation bridges the cover
+     *  exactly like a learned terminal answer), but they mean different
+     *  things for `i..j`'s WIDTH: a recognised form's query-span width is
+     *  real evidence of how much of the query's meaning it accounts for
+     *  (liftAnswer's half-dominance framing decision); a computed span's
+     *  width is operand digit-count, uncorrelated with meaning ("1000 - 421"
+     *  is wider than "15 * 7" only because the numbers are bigger, not
+     *  because subtraction is more "the point" of its query).  See
+     *  {@link liftAnswer}. */
+    computed?: boolean;
   };
 type OutItem = Extract<GItem, { kind: "out" }>;
 
@@ -138,6 +150,9 @@ export interface Seg {
   bytes: Uint8Array;
   rec: boolean;
   node?: number;
+  /** See the `computed` field of the "out" {@link GItem} — set only for an
+   *  extension's derived value, never a genuinely recognised learned form. */
+  computed?: boolean;
 }
 
 /** Read the chosen spans back off a derivation: the goal is a chain of bridge
@@ -155,6 +170,7 @@ function readCover(derivation: Derivation<GItem>): Seg[] {
         bytes: out.bytes,
         rec: out.rec,
         node: out.node,
+        computed: out.computed,
       });
     }
     node = node.premises[0];
@@ -356,6 +372,7 @@ export class GraphSearch {
     conceptTarget: ReadonlyMap<number, number>,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
+    starts: ReadonlySet<number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
@@ -377,6 +394,7 @@ export class GraphSearch {
         sites,
         leaves,
         splits,
+        starts,
       },
       conceptTarget,
       substitutions,
@@ -405,6 +423,7 @@ export class GraphSearch {
       sites: ReadonlyArray<Site>;
       leaves: ReadonlyArray<Leaf>;
       splits: ReadonlySet<number>;
+      starts: ReadonlySet<number>;
     },
     conceptTarget: ReadonlyMap<number, number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
@@ -418,6 +437,7 @@ export class GraphSearch {
       conceptTarget,
       recognition.leaves,
       recognition.splits,
+      recognition.starts,
       substitutions,
       connectors,
       computedResults,
@@ -448,11 +468,22 @@ export class GraphSearch {
     conceptTarget: ReadonlyMap<number, number>,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
+    starts: ReadonlySet<number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
     connectors?: ReadonlyMap<string, Uint8Array>,
     computedResults?: ReadonlyArray<ComputedResult>,
   ): DeductionSystem<GItem> {
     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: number) => 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.
@@ -550,6 +581,7 @@ export class GraphSearch {
               cover: true,
               rec: true,
               node: u.node,
+              computed: true,
             },
             cost: STEP,
           };
@@ -588,6 +620,8 @@ export class GraphSearch {
         return this.outRules(it, {
           W,
           splits,
+          starts,
+          atomsAreHubs,
           coversDone,
           outsByStart,
           outsByEnd,
@@ -949,6 +983,8 @@ export class GraphSearch {
     ctx: {
       W: number;
       splits: ReadonlySet<number>;
+      starts: ReadonlySet<number>;
+      atomsAreHubs: boolean;
       coversDone: Set<number>;
       outsByStart: Map<number, OutItem[]>;
       outsByEnd: Map<number, OutItem[]>;
@@ -1095,12 +1131,30 @@ export class GraphSearch {
     r: OutItem,
     ctx: {
       W: number;
+      starts: ReadonlySet<number>;
+      atomsAreHubs: boolean;
       findLeafU: (b: Uint8Array) => number | undefined;
       findBranchU: (k: number[]) => number | undefined;
     },
   ): Iterable<Rule<GItem>> {
     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
@@ -1108,7 +1162,10 @@ 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/src/mind/match.ts

@@ -325,18 +325,32 @@ export async function haloSiblings(
  *  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). */
+ *  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 async function analogyStrength(
   ctx: MindContext,
   a: number,
   b: number,
-): Promise<number> {
+): Promise<AnalogyEvidence> {
   const ha = ctx.store.halo(a);
   const hb = ctx.store.halo(b);
   if (ha && hb) {
     const bar = significanceBar(ctx.store.D);
     const direct = cosine(ha, hb);
-    if (direct >= bar) return direct;
+    if (direct >= bar) return { score: direct, halo: true };
     const sibsA = await haloSiblings(ctx, a, ha, bar);
     const sibsB = await haloSiblings(ctx, b, hb, bar);
     let best = 0;
@@ -347,9 +361,9 @@ export async function analogyStrength(
         best = Math.max(best, Math.min(x.score, y.score));
       }
     }
-    if (best > 0) return best;
+    if (best > 0) 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

package/src/mind/mechanisms/alu.ts

@@ -16,7 +16,14 @@ import type { PipelineMechanism } from "../pipeline-mechanism.js";
 export function aluToMechanism(alu: Alu): PipelineMechanism {
   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;