@hviana/sema 0.1.8 → 0.1.9

package/package.json

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

package/src/geometry.ts

@@ -189,8 +189,13 @@ export interface Grid {
 /** Fold `items[start .. start+count)` in groups of `mg` into `out`.
  *
  *  With `force`, the trailing incomplete group (2..mg-1 items) is folded as
- *  well — only a lone singleton passes through — guaranteeing progress when
- *  the caller detected a stall. */
+ *  well — only a lone singleton passes through.  The river always folds with
+ *  force: every level contracts by ~mg, so the tree's DEPTH is a function of
+ *  ceil(log_mg(n)) alone.  Letting leftovers pass through unfolded made depth
+ *  depend on the exact byte count (39 bytes folded in 3 levels, 41 in 4), and
+ *  each extra level applies another seat permutation to the whole gist —
+ *  near-identical inputs straddling such a cliff read as orthogonal
+ *  (measured: 33-byte-identical prefixes at cos ≈ 0). */
 function foldSlice(
   space: Space,
   items: Folded[],
@@ -251,19 +256,12 @@ function riverFold(space: Space, row: Folded[], stableBytes: number): Folded {
     const next: Folded[] = [];
     if (boundary < level.length) {
       // Prefix folds independently of the suffix — structural stability.
-      foldSlice(space, level, 0, boundary, next, false);
-      foldSlice(space, level, boundary, level.length - boundary, next, false);
+      foldSlice(space, level, 0, boundary, next, true);
+      foldSlice(space, level, boundary, level.length - boundary, next, true);
     } else {
-      foldSlice(space, level, 0, level.length, next, false);
-    }
-    if (next.length === level.length) {
-      // Stuck — every group was incomplete.  Force-fold to break the stall.
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      level = forced;
-    } else {
-      level = next;
+      foldSlice(space, level, 0, level.length, next, true);
     }
+    level = next;
   }
   // LINEAR fold — this root normalize is the ONLY normalize of the entire
   // fold; every intermediate gist stays unnormalized (see the folding
@@ -413,14 +411,8 @@ function riverFoldRaw(space: Space, row: Folded[]): Folded {
   let level = row;
   while (level.length > 1) {
     const next: Folded[] = [];
-    foldSlice(space, level, 0, level.length, next, false);
-    if (next.length === level.length) {
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      level = forced;
-    } else {
-      level = next;
-    }
+    foldSlice(space, level, 0, level.length, next, true);
+    level = next;
   }
   return level[0];
 }
@@ -509,16 +501,8 @@ export function bytesToTreePyramid(
       reused * mg,
       level.length - reused * mg,
       next,
-      false,
+      true,
     );
-    if (next.length === level.length) {
-      // Stuck — same force-fold as riverFold (reuse cannot cause it: any
-      // reused block replaces a whole folded group, so reused > 0 implies
-      // progress).
-      const forced: Folded[] = [];
-      foldSlice(space, next, 0, next.length, forced, true);
-      next = forced;
-    }
     levels.push(next);
     level = next;
     L++;

package/src/mind/mechanisms/cast.ts

@@ -368,6 +368,11 @@ export async function counterfactualTransfer(
     /** The point this candidate came from, or null when it is a nextOf
      *  descendant — then seatOfNode supplies the seat. */
     point: Point | null;
+    /** For a nextOf descendant: the aligned point whose continuation edge
+     *  named it.  Its runs ARE the query evidence this analog rests on
+     *  (the hop was reached THROUGH that alignment), so the comparison
+     *  schema accounts them. */
+    src: Point;
   }
   const analogs: AnalogCandidate[] = [];
   for (const p of points) {
@@ -380,7 +385,7 @@ export async function counterfactualTransfer(
       indexOf(p.ctx, dominant.ctx, 0) < 0 &&
       indexOf(query, p.ctx, 0) < 0
     ) {
-      analogs.push({ anchor: p.anchor, point: p });
+      analogs.push({ anchor: p.anchor, point: p, src: p });
     }
     // Reach through to the point's continuation targets regardless
     // of the point's own context length: when the point is a leaf
@@ -399,7 +404,7 @@ export async function counterfactualTransfer(
         indexOf(nctx, dominant.ctx, 0) >= 0 ||
         indexOf(query, nctx, 0) >= 0
       ) continue;
-      analogs.push({ anchor: nid, point: null });
+      analogs.push({ anchor: nid, point: null, src: p });
     }
   }
   let bestAnalog: AnalogCandidate | null = null;
@@ -521,13 +526,13 @@ export async function counterfactualTransfer(
       // A halo-mediated act (the analogy gate) plus two seat projections.
       CONCEPT + STEP + STEP,
       // What comparison READ: the dominant's own aligned runs, plus the
-      // analog's aligned runs when it was itself an aligned point (a nextOf
-      // descendant was never aligned to the query directly, so it
-      // contributes no accounted span — its seat is graph-reached, not
-      // query-matched).
+      // aligned runs of the point that named the analog — the analog itself
+      // when it was an aligned point, else the source point whose
+      // continuation edge reached it (that alignment IS the query evidence
+      // the hop rests on).
       [
         ...runSpans(dominant),
-        ...(bestAnalog.point !== null ? runSpans(bestAnalog.point) : []),
+        ...runSpans(bestAnalog.point ?? bestAnalog.src),
       ],
     );
   }

package/dist/example/demo.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/example/demo.js

@@ -1,39 +0,0 @@
-// demo.ts — one short session that drives the WHOLE pipeline from one memory.
-//
-// We give Sema a handful of plain notes, then ask things that no single note
-// answers. The headline query is the third one: from three worked examples Sema
-// learns the shape of "X was painted by Y", lifts the painter out of a sentence
-// it has NEVER seen, and then — in the same pass — reasons forward to a separate
-// fact about that painter. The reply contains no word from the question. That is
-// retrieval, generalization, and reasoning composing as a single act, with every
-// step traceable back to the notes behind it.
-import { Mind } from "../src/index.js";
-import { SQliteStore } from "../src/store-sqlite.js";
-async function main() {
-    const mind = new Mind({ store: new SQliteStore({ path: ":memory:" }) });
-    const ask = async (q) => (await mind.respondText(q)).trim();
-    // ── Jot down what we know. Each line is just (context → what follows). ──
-    await mind.ingest([
-        // One relation, shown three times — a pattern taught purely by example:
-        ["The Mona Lisa was painted by Leonardo da Vinci.", "Leonardo da Vinci"],
-        ["The Starry Night was painted by Vincent van Gogh.", "Vincent van Gogh"],
-        [
-            "The Night Watch was painted by Rembrandt van Rijn.",
-            "Rembrandt van Rijn",
-        ],
-        // One stray fact, keyed on a name none of the examples mention:
-        ["Pablo Picasso", "Pablo Picasso co-founded the Cubist movement"],
-    ]);
-    // 1) GENERALIZE — apply the learned pattern to an unseen sentence and read out
-    //    the painter. "Pablo Picasso" was never given as an answer; Sema locates it
-    //    by analogy to the three examples.
-    console.log(await ask("The Weeping Woman was painted by Pablo Picasso."));
-    // → "Pablo Picasso co-founded the Cubist movement"
-    //   …and, having found the painter, it KEEPS GOING: the name bridges into the
-    //   one fact it holds about him. The answer appears in no word of the question.
-    // 2) COMPUTE — exact arithmetic, grounded right where the notes go silent.
-    console.log(await ask("a museum charges 12*4 for a family ticket"));
-    // → "48"
-    await mind.store.close();
-}
-main();

package/dist/example/train_base.d.ts

@@ -1,87 +0,0 @@
-export interface Episode {
-    context: string;
-    continuation: string;
-}
-export type TrainingItem = string | Episode;
-/** Dedup + trim a concept's items: drop empty/degenerate pairs and exact
- *  repeats so a concept never deposits the same form twice. */
-export declare function refineItems(items: TrainingItem[]): TrainingItem[];
-/** One normalized SmolSent row. */
-export interface SmolSentRow {
-    src: string;
-    trg: string;
-    sl: string;
-    tl: string;
-}
-/** Normalize a raw datasets-server row into a SmolSentRow, or null when it lacks
- *  both sides or a side is implausibly large (a dump, not a sentence). */
-export declare function toSmolSentRow(row: unknown): SmolSentRow | null;
-/** Translate ONE SmolSent pair into SEMA facts: the two sentences are one
- *  meaning in two languages, so bind them BOTH ways. refineItems drops the
- *  degenerate case where src === trg. */
-export declare function smolSentRowToItems(row: SmolSentRow): TrainingItem[];
-/** One normalized Aya row. */
-export interface AyaRow {
-    inputs: string;
-    targets: string;
-    language: string;
-}
-/** Normalize a raw datasets-server row object into an AyaRow, or null when it
- *  lacks a usable prompt/answer or a field is implausibly large (a dump, not a
- *  cognitive example). Trims surrounding whitespace; keeps inner text verbatim
- *  (human prose, possibly multi-paragraph). */
-export declare function toAyaRow(row: unknown): AyaRow | null;
-/** Translate ONE Aya row into SEMA training items. A row is a single human
- *  (question → answer) exchange — exactly one FACT, the (inputs → targets) edge.
- *  No standalone-answer experience and no one-exchange "cumulative" walk: a lone
- *  Q→A is not multi-turn, and both would only replicate the same edge. */
-export declare function ayaRowToItems(row: AyaRow): TrainingItem[];
-/** A single oasst2 message node (the fields we use; the tree nests via replies). */
-interface OasstNode {
-    role?: string;
-    text?: string;
-    rank?: number | null;
-    deleted?: boolean;
-    replies?: OasstNode[];
-}
-/** One conversational turn extracted from a tree. */
-export interface OasstTurn {
-    role: string;
-    text: string;
-}
-/** Collapse a conversation tree to ONE linear path: at each node, descend into
- *  its best-ranked, non-deleted reply (rank 0 preferred; unranked sorts last).
- *  Returns the ordered turns (already strictly alternating in this corpus). */
-export declare function bestOasstPath(root: OasstNode): OasstTurn[];
-/** Translate ONE multi-turn oasst2 conversation into SEMA training items.
- *
- *  This is the ONE stage where cumulative continuous context is truly necessary:
- *  the data is a real multi-turn dialogue, and what must be learned is how each
- *  turn follows from the WHOLE conversation so far — not from the previous turn
- *  alone. The conversation is emitted ONLY as the accumulated walk; standalone
- *  turn experiences and local adjacent-pair facts are NOT emitted (they are
- *  subsumed by it and would merely replicate the content).
- *
- *  The walk is byte-for-byte the pattern proven in test/13-conversation.test.mjs
- *  ("teachConversation"): each turn is the continuation of all prior turns joined
- *  by "\n", with BARE turn text — NO "User:/Assistant:" labels. Roles already
- *  alternate by position in an oasst2 best-path (the root is a prompter), so a
- *  label adds nothing the position does not, while a clean continuation matches
- *  the test's recall (predictNext queries bare prior turns) and lets a turn share
- *  its gist with the same text elsewhere (e.g. an Aya question stored bare).
- *
- *  Returns [] for a conversation below the multi-turn threshold, so callers can
- *  simply skip empties. */
-export declare function oasstConversationToItems(turns: OasstTurn[]): TrainingItem[];
-/** One normalized General-Knowledge row. */
-export interface GenKnowRow {
-    question: string;
-    answer: string;
-}
-/** Normalize a raw datasets-server row into a GenKnowRow, or null when it lacks
- *  a usable question/answer or a side is implausibly large (corruption). */
-export declare function toGenKnowRow(row: unknown): GenKnowRow | null;
-/** Translate ONE General-Knowledge row into SEMA items: exactly one
- *  (question → answer) FACT. refineItems drops a degenerate question === answer. */
-export declare function genKnowRowToItems(row: GenKnowRow): TrainingItem[];
-export {};