@hviana/sema 0.1.0

package/test/16-bridge.test.mjs

@@ -0,0 +1,250 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+// =========================================================================
+// THE BRIDGE — synthesising the connector between rewritten parts
+// =========================================================================
+//
+// When `think` rewrites several parts of a query at once, it must decide how to
+// JOIN the results. The connector between two rewrites is NOT simply the bytes
+// the query had between the originals: after a rewrite, the asker's connector
+// may no longer make sense, may be missing entirely, or may need to become
+// something the asker never wrote.
+//
+// The bridge is the heart of the algorithm, not a special case. Whenever parts
+// are rewritten, the graph is consulted for how the RESULTS cohere. Three
+// outcomes, all decided by the graph, never assumed:
+//
+//   • nothing      — the results stand adjacent with no connector;
+//   • the input's  — the query's own connector still coheres, so it is kept;
+//   • a synthesised one — the graph learned a connector between the results
+//                    (a space, a ".", or a whole phrase), so it is inserted
+//                    even though the asker never wrote it.
+//
+// The synthesised case is what these tests pin down. A previous refactor, with
+// no test guarding it, silently dropped synthesis — "icefire" answered
+// "coldhot" with the two rewrites run together, even when the store had learned
+// how "cold" and "hot" connect. That is the regression these tests forbid.
+//
+// The graph signal: resonate the bare concatenation of the two result spans;
+// if a learned form both BEGINS WITH the left result and ENDS WITH the right,
+// the bytes in between are the learned connector. No learned form ⇒ no
+// connector invented (strangers do not get a spurious phrase).
+
+const mk = () => new Mind({ seed: 7 });
+
+// ── 1. Synthesise a word connector the asker never wrote ─────────────────
+// "ice"→"cold", "fire"→"hot" are independent facts; the store SEPARATELY
+// learned the experience "cold or hot". Asking the two together — with no
+// usable connector between them ("icefire") — must reconstruct the learned
+// join, answering "cold or hot", not "coldhot".
+test("bridge synthesises a learned word connector between rewrites", async () => {
+  const m = mk();
+  await m.ingest([["ice", "cold"], ["fire", "hot"]]);
+  await m.ingest("cold or hot"); // the graph learns how the answers connect
+  const r = await m.respondText("icefire");
+  assert.equal(r, "cold or hot");
+  await m.store.close();
+});
+
+// ── 2. Synthesise a whole-phrase connector ───────────────────────────────
+// The connector can be anything the graph learned, not just punctuation.
+test("bridge synthesises a learned phrase connector", async () => {
+  const m = mk();
+  await m.ingest([["sky", "blue"], ["grass", "green"]]);
+  await m.ingest("blue is the opposite of green");
+  const r = await m.respondText("skygrass");
+  assert.equal(r, "blue is the opposite of green");
+  await m.store.close();
+});
+
+// ── 3. No learned connection ⇒ no connector invented ─────────────────────
+// Synthesis is graph-evidenced, never guessed. Without a learned join the two
+// rewrites simply abut — the bridge must not hallucinate a phrase.
+test("bridge invents nothing when the graph learned no connection", async () => {
+  const m = mk();
+  await m.ingest([["ice", "cold"], ["fire", "hot"]]);
+  const r = await m.respondText("icefire");
+  // Both answers present, adjacent, with no fabricated linking text.
+  assert.ok(r.includes("cold") && r.includes("hot"));
+  assert.ok(
+    !r.includes(" or ") && !r.includes(" is "),
+    `no connector should be invented, got ${JSON.stringify(r)}`,
+  );
+  await m.store.close();
+});
+
+// ── 4. The asker's own connector is kept when it still coheres ───────────
+// Synthesis must not override a perfectly good input connector. "ice, fire"
+// with the comma intact stays "cold, hot".
+test("bridge keeps the asker's connector when it coheres", async () => {
+  const m = mk();
+  await m.ingest([["ice", "cold"], ["fire", "hot"]]);
+  const r = await m.respondText("ice, fire");
+  assert.ok(
+    r.includes("cold") && r.includes("hot") && r.includes(","),
+    `the asker's comma should survive, got ${JSON.stringify(r)}`,
+  );
+  await m.store.close();
+});
+
+// ── 4b. Learning a connector phrase must NOT corrupt the parts ───────────
+// THE PREREQUISITE THE BRIDGE STANDS ON. Multi-part rewriting works on its own
+// ("ice fire" → "cold hot"). The moment the store ALSO learns a phrase that
+// happens to contain those answers ("cold or hot"), the cover search must still
+// rewrite each part cleanly — it must not let the phrase's chunks bleed into a
+// part and turn "cold" into "or hot". (Before the fix, this regressed "ice fire"
+// from "cold hot" to "or hothot": the fuse/resolve rules absorbed a completed
+// rewrite into an unrelated learned phrase chunk.)
+test("learning a connector phrase does not corrupt the rewrites", async () => {
+  const base = mk();
+  await base.ingest([["ice", "cold"], ["fire", "hot"]]);
+  const before = await base.respondText("ice fire");
+  await base.store.close();
+  assert.equal(before, "cold hot");
+
+  const m = mk();
+  await m.ingest([["ice", "cold"], ["fire", "hot"]]);
+  await m.ingest("cold or hot"); // a phrase containing both answers
+  const after = await m.respondText("ice fire");
+  // The two parts still rewrite cleanly; no chunk of the phrase bleeds in.
+  assert.equal(
+    after.replace(/[^a-z ]/g, "").replace(/ +/g, " ").trim(),
+    "cold hot",
+    `parts must stay clean, got ${JSON.stringify(after)}`,
+  );
+  await m.store.close();
+});
+
+// =========================================================================
+// THE BRIDGE IS IN THE SEARCH, NOT A POST-PASS
+// =========================================================================
+//
+// The connector must be chosen DURING the cover search — a weighted rule in the
+// same deduction system as the rewrites — not stitched on afterwards. A post-hoc
+// pass that joins finished parts pairwise, left to right, has two fatal faults
+// these tests forbid:
+//
+//   • it cannot see a connector that spans MORE THAN TWO parts (a learned
+//     "X then Y then Z" is invisible to pairwise bridge(X,Y), bridge(Y,Z));
+//   • joining already-rewritten parts one pair at a time lets small mismatches
+//     ACCUMULATE into near-dedup gaps (a dropped or doubled fragment), because no
+//     single decision ever sees the whole join.
+//
+// Pricing the connector inside the search makes the cover globally optimal: the
+// derivation that yields the most coherent whole wins, connectors included.
+
+// ── 5. A connector spanning three parts is found as one whole ────────────
+// The graph learned "X then Y then Z" linking three answers. Asking a, b, c
+// together must reconstruct that whole linked form — a pairwise post-pass,
+// knowing only two-part forms, would miss it and emit a bare "XYZ".
+test("bridge spans three rewritten parts at once", async () => {
+  const m = mk();
+  await m.ingest([["a", "X"], ["b", "Y"], ["c", "Z"]]);
+  await m.ingest("X then Y then Z"); // the three answers cohere as one phrase
+  const r = await m.respondText("abc");
+  assert.equal(r, "X then Y then Z");
+  await m.store.close();
+});
+
+// ── 6. No accumulated gaps across several junctions ──────────────────────
+// Joining many rewrites must never drop or double a fragment. Every recognised
+// answer appears exactly once, in order, with no garbage between.
+test("bridge accumulates no gaps across many parts", async () => {
+  const m = mk();
+  await m.ingest([["a", "X"], ["b", "Y"], ["c", "Z"]]);
+  await m.ingest("X then Y then Z");
+  const r = await m.respondText("a b c");
+  // Each answer once, in order; no doubled or dropped letter.
+  assert.equal(r.replace(/[^XYZ]/g, ""), "XYZ");
+  await m.store.close();
+});
+
+// =========================================================================
+// N-ARY CONNECTORS — the whole interior, not pairwise scraps
+// =========================================================================
+//
+// A learned whole that runs three or more answers together (e.g.
+// "cold, hot, and windy") carries DIFFERENT material between different pairs:
+// between the first two it is ", ", but between the first and the LAST it is
+// ", hot, and " — the interior answer plus both separators. Pairwise bridging,
+// stitched greedily left-to-right, takes the first pairwise connector (", ") and
+// then cannot place the rest, emitting "cold, hot" + "windy" → "cold, hotwindy".
+//
+// The N-ary connector resolves the single learned whole that runs ALL the
+// recognised answers in order and records, for the first answer paired with each
+// later one, the EXACT interior between them. The cover then jumps from the first
+// answer straight to the last across the (recognised) interior, voicing the whole
+// coherent phrase. These tests pass only with that mechanism.
+
+// ── 7. Three answers cohere with the full interior between them ──────────
+test("n-ary connector voices a three-answer whole", async () => {
+  const m = mk();
+  await m.ingest([["ice", "cold"], ["fire", "hot"], ["wind", "windy"]]);
+  await m.ingest("cold, hot, and windy"); // the three cohere as one phrase
+  const r = await m.respondText("icefirewind");
+  assert.equal(r, "cold, hot, and windy");
+  await m.store.close();
+});
+
+// ── 8. Four answers — the interior grows, still found as one whole ───────
+test("n-ary connector voices a four-answer whole", async () => {
+  const m = mk();
+  await m.ingest([["a", "W"], ["b", "X"], ["c", "Y"], ["d", "Z"]]);
+  await m.ingest("W, X, Y, and Z");
+  const r = await m.respondText("abcd");
+  assert.equal(r, "W, X, Y, and Z");
+  await m.store.close();
+});
+
+// ── 9. The asker's own separator is never crossed by an N-ary jump ───────
+// The N-ary jump fires only across a span that is ITSELF wholly recognised
+// (interior answers). When the asker wrote their own separator between parts,
+// that gap is unrecognised, so the jump must NOT fire and the separator must
+// survive — "ice fire" stays "cold hot", never the learned "cold, hot, and …".
+test("n-ary jump does not swallow the asker's separator", async () => {
+  const m = mk();
+  await m.ingest([["ice", "cold"], ["fire", "hot"], ["wind", "windy"]]);
+  await m.ingest("cold, hot, and windy");
+  const r = await m.respondText("ice fire wind");
+  // The asker ran them apart; their own spacing is kept, parts cleanly rewritten.
+  assert.equal(
+    r.replace(/[^a-z ]/g, "").replace(/ +/g, " ").trim(),
+    "cold hot windy",
+  );
+  await m.store.close();
+});
+
+// =========================================================================
+// SYNONYM JUNCTIONS — bridging through a halo sibling
+// =========================================================================
+//
+// When two answers lack a direct learnt container linking them, but a HALO
+// SIBLING of one answer participates in a learnt whole with the other (e.g.
+// "chilly or hot" where "chilly" is a distributional synonym of "cold"), the
+// bridge must find that junction through the sibling and extract the connector.
+// This is the halo-sibling tier between the exact edge junctions (tier 2)
+// and the approximate resonance fallback (tier 3): the container evidence is
+// exact (content-addressed DAG ascent, same as tier 1), but one side is
+// relaxed from the exact answer to a distributional sibling.
+
+// ── 10. Connector found through a halo sibling of the left answer ──────────
+// "ice"→"cold", "fire"→"hot" are the base facts.  "chilly" shares
+// distributional company with "cold" (both follow "freeze"), so they are halo
+// siblings.  The store separately learned "chilly or hot".  The bridge must
+// find "chilly or hot" through the halo-sibling relationship and extract
+// " or " as the connector between "cold" and "hot".
+test("bridge finds a connector via a halo-sibling synonym", async () => {
+  const m = mk();
+  await m.ingest([["ice", "cold"], ["fire", "hot"]]);
+  // Make "chilly" a halo sibling of "cold" — both appear after "freeze".
+  await m.ingest([["freeze", "cold"], ["freeze", "chilly"]]);
+  // Learn the junction phrase — the connector " or " lives between
+  // "chilly" and "hot", but NOT between "cold" and "hot" directly.
+  await m.ingest("chilly or hot");
+  const r = await m.respondText("icefire");
+  assert.equal(r, "cold or hot");
+  await m.store.close();
+});

package/test/17-intelligence.test.mjs

@@ -0,0 +1,240 @@
+// 17-intelligence.test.mjs — the intelligence regression bed.
+//
+// A corpus that mirrors the trained model's hardest pathology: every record is a
+// shared instruction FRAME ("You are a helpful and harmless assistant…") plus a
+// distinctive instruction → an answer. The shared scaffolding is the overwhelming majority of
+// every context's bytes, so whole-query gist resonance is pulled toward the
+// shared preamble and cannot, by itself, tell the records apart. Answering a
+// reworded or partial query therefore demands the graph's CONNECTIVITY —
+// consensus-climbing the structural parents-DAG to the context the query's
+// distinctive sub-regions agree on — not mere whole-query similarity.
+//
+// These assertions pin down that capability so it cannot silently regress:
+//   • exact and distractor-framed queries must always resolve (the floor);
+//   • the aggregate score across query STYLES (exact, partial, paraphrase,
+//     reorder, distractor) must stay at or above a bar that only the
+//     connectivity-driven search clears — pure whole-query resonance scores far
+//     below it (it answers only near-verbatim queries);
+//   • a hard paraphrase that shares distinctive content resolves to its own
+//     answer, not a scaffolding-neighbour's.
+//
+// The bar is deliberately below the current pass count so ordinary codec/ANN
+// jitter never flakes it, while a real loss of the climb (e.g. reverting to
+// whole-query resonance) drops well beneath it and fails.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+const SYS =
+  "You are a helpful and harmless assistant.\n\nYou are not allowed to use any tools.\n";
+
+const FACTS = [
+  [
+    "Describe the importance of gender equality in the workplace to a high school student in exactly 4 sentences.",
+    "Gender equality in the workplace means everyone has the same chance to be hired, paid, and promoted fairly.",
+  ],
+  [
+    "Provide a summary of the 1992 Men's Olympic Basketball Team, the Dream Team, in 8 sentences.",
+    "The 1992 Dream Team was the greatest basketball roster ever assembled, winning gold in Barcelona.",
+  ],
+  [
+    "Write a short story in JSON format about a street-art vendor who helps a young artist.",
+    '{"title":"First Mural","vendor":"Slick","artist":"Maya","scene":"a dawn alley of spray cans"}',
+  ],
+  [
+    "Explain the importance of age discrimination laws to a high school student in 4 sentences.",
+    "Age discrimination laws stop employers from treating people unfairly because of how old they are.",
+  ],
+  [
+    "Write an essay analyzing the cinematography of a classic film with the title in double brackets.",
+    "<<Light and Shadow>> Citizen Kane uses deep focus to layer meaning in every single frame.",
+  ],
+  [
+    "Create a weekly basketball practice plan with drills for a high school team.",
+    "Monday is dribbling and layup drills; Wednesday defense; Friday scrimmage and free throws.",
+  ],
+  [
+    "Summarize the plot of a science fiction novel about time travel in three sentences.",
+    "A physicist builds a machine that loops her through one fatal afternoon until she rewrites it.",
+  ],
+  [
+    "Give tips for managing time as a returning college student with a family.",
+    "Block your study hours like appointments, batch errands, and protect one evening a week to rest.",
+  ],
+  [
+    "Explain how neighborhood watch programs improve community safety.",
+    "Neighborhood watch programs deter crime by organizing residents to notice and report what is unusual.",
+  ],
+  [
+    "Write a guided meditation script for managing anxiety before an exam.",
+    "Breathe in for four counts, hold, release slowly, and let the worry drain from your shoulders.",
+  ],
+  [
+    "Describe how social media platforms change interpersonal communication.",
+    "Social media speeds contact but flattens nuance, so tone is read from emoji more than from words.",
+  ],
+  [
+    "Summarize the rules of beach volleyball for a first-time spectator.",
+    "Beach volleyball pairs two players a side who rally a ball over a net on sand, best of three sets.",
+  ],
+  [
+    "Explain the water cycle to a curious eight-year-old in simple terms.",
+    "The sun warms water into vapor, clouds gather it, and rain returns it to rivers and the sea again.",
+  ],
+  [
+    "Write a cover letter for a junior data analyst position at a fintech startup.",
+    "Dear Hiring Team, I turn messy financial data into clear decisions, and your startup excites me.",
+  ],
+  [
+    "Describe the health benefits of a Mediterranean diet for older adults.",
+    "A Mediterranean diet of olive oil, fish, and vegetables protects the heart and steadies the mind.",
+  ],
+  [
+    "Explain how photosynthesis converts sunlight into chemical energy.",
+    "Photosynthesis captures sunlight in chlorophyll to bind carbon dioxide and water into sugar.",
+  ],
+  [
+    "Give advice for a beginner learning to play acoustic guitar.",
+    "Start with clean open chords, keep your wrist loose, and practice short daily rather than long rarely.",
+  ],
+  [
+    "Summarize the causes of the fall of the Western Roman Empire.",
+    "The Western Roman Empire fell from overreach, currency decay, and waves of migrating peoples.",
+  ],
+  [
+    "Describe best practices for securing a home wireless network.",
+    "Secure a home network with WPA3, a long unique passphrase, and firmware kept promptly updated.",
+  ],
+  [
+    "Write a haiku about the first snowfall in a quiet city.",
+    "First snow on lamplight / the city holds its breath once / footprints fill with white.",
+  ],
+];
+
+// [style, query (shared opening prepended at ask time), index of the expected FACT]
+const PROBES = [
+  ["exact", FACTS[0][0], 0],
+  ["exact", FACTS[17][0], 17],
+  [
+    "partial",
+    "Describe the importance of gender equality in the workplace.",
+    0,
+  ],
+  ["partial", "Write a short story in JSON about a street-art vendor.", 2],
+  [
+    "partial",
+    "Provide a summary of the 1992 Men's Olympic Basketball Team.",
+    1,
+  ],
+  ["partial", "Create a weekly basketball practice plan with drills.", 5],
+  ["partial", "Explain how photosynthesis works.", 15],
+  [
+    "paraphrase",
+    "Tell a high schooler why gender equality at work matters.",
+    0,
+  ],
+  [
+    "paraphrase",
+    "Give me an overview of the 1992 Dream Team basketball squad.",
+    1,
+  ],
+  ["paraphrase", "Why do age discrimination laws matter, explained simply?", 3],
+  ["paraphrase", "What does the Mediterranean diet do for the elderly?", 14],
+  ["paraphrase", "What happened to the Western Roman Empire and why?", 17],
+  [
+    "reorder",
+    "In the workplace, the importance of gender equality, describe it.",
+    0,
+  ],
+  [
+    "distractor",
+    "I was chatting with a friend and wondered, how does photosynthesis convert sunlight into energy?",
+    15,
+  ],
+  [
+    "distractor",
+    "Quick question before lunch — the health benefits of a Mediterranean diet for older adults?",
+    14,
+  ],
+];
+
+// A distinctive interior slice of the expected answer (lossy-first-byte tolerant).
+const marker = (a) => a.replace(/\s+/g, " ").slice(1, 16);
+const hits = (got, want) => got.replace(/\s+/g, " ").includes(marker(want));
+
+async function build() {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(FACTS.map(([q, a]) => [SYS + q, a]));
+  return { store, mind };
+}
+
+test("scaffolding-dominated corpus: connectivity answers across query styles", async () => {
+  const { store, mind } = await build();
+  const got = [];
+  for (const [style, q, idx] of PROBES) {
+    const ans = (await mind.respondText(SYS + q)).replace(/\s+/g, " ").trim();
+    got.push({ style, ok: hits(ans, FACTS[idx][1]), ans });
+  }
+  await store.close();
+
+  const by = (s) => got.filter((g) => g.style === s);
+  const rate = (s) => by(s).filter((g) => g.ok).length;
+
+  // Floor: exact reproduction and distractor-framed (distinctive content intact)
+  // must ALWAYS resolve — these need no rewording intelligence, only that the
+  // search finds present content.
+  assert.equal(
+    rate("exact"),
+    by("exact").length,
+    "every exact query must resolve",
+  );
+  assert.equal(
+    rate("distractor"),
+    by("distractor").length,
+    "distinctive content buried in framing must still resolve",
+  );
+
+  // Aggregate: the climb must clear a bar that whole-query resonance cannot.
+  // The bar of 15 absorbs codec/ANN jitter while a reversion to plain whole-
+  // query resonance (which answers only near-verbatim queries) scores far
+  // lower and fails.
+  const total = got.filter((g) => g.ok).length;
+  assert.ok(
+    total >= 15,
+    `intelligence score ${total}/${PROBES.length} — expected ≥ 15 ` +
+      `(connectivity-driven climb; pure whole-query resonance scores far less)\n` +
+      got.filter((g) => !g.ok).map((g) =>
+        `  ✗ [${g.style}] ${g.ans.slice(0, 40)}`
+      ).join("\n"),
+  );
+
+  // At least one genuine paraphrase must resolve to its OWN answer — the
+  // signature of the consensus climb, impossible for scaffolding-pulled whole-query
+  // resonance.
+  assert.ok(
+    rate("paraphrase") >= 2,
+    `only ${rate("paraphrase")}/${
+      by("paraphrase").length
+    } paraphrases resolved — ` +
+      `expected ≥ 2 (the climb's distinctive-region consensus)`,
+  );
+});
+
+// A reworded query whose distinctive content clearly names one record must not
+// be captured by a scaffolding-sharing neighbour — the precise win consensus-climbing
+// delivers over whole-query gist.
+test("a distinctive paraphrase resolves to its own record, not a frame neighbour", async () => {
+  const { store, mind } = await build();
+  const ans = (await mind.respondText(
+    SYS + "Tell a high schooler why gender equality at work matters.",
+  )).replace(/\s+/g, " ").trim();
+  await store.close();
+  assert.ok(
+    hits(ans, FACTS[0][1]),
+    `gender-equality paraphrase resolved to "${ans.slice(0, 48)}" — ` +
+      `expected the gender-equality record`,
+  );
+});