@hviana/sema 0.1.6 → 0.1.8

package/test/13-conversation.test.mjs

@@ -14,14 +14,10 @@
 // The assertions describe BEHAVIOUR only — they never mention how context is
 // represented — so they stay valid for any implementation.
 //
-// Note: Sema trains on the accumulated context string ("turn0\nturn1\nturn2")
-// and queries the same accumulated string at inference. This is not a
-// weakness — LLMs work the same way: a chat model receives the full
-// conversation history as its prompt, and that same history must be
-// provided at inference to produce the next turn. The difference is in
-// how the answer is produced: Sema composes it from learned graph forms;
-// an LLM samples it from a parametric distribution. Neither is "just a
-// lookup."
+// Sema trains on the raw concatenation of prior turns and queries the same
+// accumulated bytes at inference.  The Conversation API tracks turn-boundary
+// offsets explicitly so no separator character is needed — the geometry never
+// inspects content to find turn boundaries.
 // ─────────────────────────────────────────────────────────────────────────
 
 import { test } from "node:test";
@@ -34,16 +30,14 @@ const newMind = () => new Mind({ seed: 7 });
 // ═══════════════════════════════════════════════════════════════════════
 // teachConversation — store one conversation (an ordered list of turns).
 //
-// Accumulate every prior turn into the context so each episode carries the
-// full conversation history:  (t₀ → t₁), (t₀+t₁ → t₂), (t₀+t₁+t₂ → t₃) …
-// A pivot turn ("what is its name?") that appears in two conversations now
-// produces different episode vectors because the context side encodes which
-// conversation it belongs to.  All SEMA operations remain sublinear — the
-// river cuts any context into O(log N) chunks regardless of length.
+// Accumulate prior turns by raw concatenation — no separator character.
+// Each episode carries the full conversation history: (t₀ → t₁),
+// (t₀+t₁ → t₂), (t₀+t₁+t₂ → t₃) … where + is byte concatenation.
 // ═══════════════════════════════════════════════════════════════════════
 async function teachConversation(mind, turns) {
+  let context = "";
   for (let i = 0; i + 1 < turns.length; i++) {
-    const context = turns.slice(0, i + 1).join("\n");
+    context += turns[i];
     await mind.ingest(context, turns[i + 1]);
   }
 }
@@ -51,13 +45,24 @@ async function teachConversation(mind, turns) {
 // ═══════════════════════════════════════════════════════════════════════
 // predictNext — given the turns spoken so far, predict the next turn.
 //
-// Join every prior turn into one accumulated context, mirroring the storage
-// pattern in teachConversation.  The resulting query string is the exact
-// context side of the matching episode, so recall resolves unambiguously.
+// Uses the Conversation API: beginConversation → addTurn for each prior
+// turn (BOTH speakers' lines are history being replayed, not questions to
+// answer — respondTurn would answer each one AND append its own reply to
+// the context) → respondTurnText for the final turn → endConversation.
+// Turns are raw strings, concatenated by the Mind — no separator.
 // ═══════════════════════════════════════════════════════════════════════
 async function predictNext(mind, priorTurns) {
-  const context = priorTurns.join("\n");
-  return await mind.respondText(context);
+  if (priorTurns.length === 0) return "";
+  const conv = mind.beginConversation();
+  for (let i = 0; i < priorTurns.length - 1; i++) {
+    mind.addTurn(conv, priorTurns[i]);
+  }
+  const { response } = await mind.respondTurnText(
+    conv,
+    priorTurns[priorTurns.length - 1],
+  );
+  mind.endConversation(conv);
+  return response;
 }
 
 // A small convenience: teach a conversation, then ask for the continuation
@@ -226,3 +231,218 @@ test("D2: prediction is deterministic across runs", async () => {
   };
   assert.equal(await run(), await run());
 });
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section E — Conversation API lifecycle & cache management
+//
+// Tests for the beginConversation / respondTurn / endConversation API
+// itself, independent of the conversation-training pattern above.
+// ═══════════════════════════════════════════════════════════════════════
+
+test("E1: begin → respondTurn → end completes a single-turn conversation", async () => {
+  const mind = newMind();
+  await mind.ingest("hello", "world");
+
+  const conv = mind.beginConversation();
+  const { response, state } = await mind.respondTurnText(conv, "hello");
+  assert.equal(response, "world");
+  // The reply is part of the exchange: one boundary, between the turn and
+  // the appended reply.
+  assert.equal(state.boundaries.length, 1);
+  mind.endConversation(conv);
+  await mind.store.close();
+});
+
+test("E2: multi-turn conversation accumulates context and boundaries", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+
+  const conv = mind.beginConversation();
+  // First turn establishes the subject — scripted history, so it is FED
+  // (addTurn), not asked.
+  mind.addTurn(conv, "I adopted a cat");
+
+  // Second turn is the pivot query.
+  const t2 = await mind.respondTurnText(conv, "what is its name?");
+  // Two boundaries: after the first turn, and after the pivot (the reply
+  // is part of the exchange).
+  assert.equal(t2.state.boundaries.length, 2);
+  assert.equal(t2.response, "her name is Whiskers");
+
+  mind.endConversation(conv);
+  await mind.store.close();
+});
+
+test("E3: save → end → restore → continue works", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+
+  // First two turns (context fed, pivot asked).
+  const conv = mind.beginConversation();
+  mind.addTurn(conv, "I adopted a cat");
+  const { state: saved } = await mind.respondTurnText(
+    conv,
+    "what is its name?",
+  );
+  assert.equal(saved.boundaries.length, 2);
+
+  // Save and end.
+  mind.endConversation(conv);
+
+  // Restore from the saved state into a new handle.
+  const conv2 = mind.beginConversation(saved);
+  // Boundaries are intact from the restore, and the conversation continues
+  // from where it left off.
+  const state2 = mind.addTurn(conv2, "and she likes to nap");
+  assert.equal(state2.boundaries.length, saved.boundaries.length + 1);
+  const { response } = await mind.respondTurnText(conv2, "what is its name?");
+  assert.ok(typeof response === "string");
+
+  mind.endConversation(conv2);
+  await mind.store.close();
+});
+
+test("E4: endConversation is idempotent", async () => {
+  const mind = newMind();
+  const conv = mind.beginConversation();
+  mind.endConversation(conv);
+  // Second end on the same handle — must not throw.
+  mind.endConversation(conv);
+  await mind.store.close();
+});
+
+test("E5: respondTurn on an ended conversation throws", async () => {
+  const mind = newMind();
+  const conv = mind.beginConversation();
+  mind.endConversation(conv);
+  await assert.rejects(
+    () => mind.respondTurn(conv, "hello"),
+    /not found/,
+  );
+  await mind.store.close();
+});
+
+test("E6: conversationState returns null after endConversation", async () => {
+  const mind = newMind();
+  const conv = mind.beginConversation();
+  mind.endConversation(conv);
+  assert.equal(mind.conversationState(conv), null);
+  await mind.store.close();
+});
+
+test("E7: multiple concurrent conversations are independent", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+  await teachConversation(mind, DOG);
+
+  const catConv = mind.beginConversation();
+  const dogConv = mind.beginConversation();
+
+  // Feed the distinguishing context to each.
+  mind.addTurn(catConv, "I adopted a cat");
+  mind.addTurn(dogConv, "I adopted a dog");
+
+  // The same pivot turn — different answers.
+  const catR = await mind.respondTurnText(catConv, "what is its name?");
+  const dogR = await mind.respondTurnText(dogConv, "what is its name?");
+
+  assert.equal(catR.response, "her name is Whiskers");
+  assert.equal(dogR.response, "his name is Rex");
+  assert.notEqual(catR.response, dogR.response);
+
+  // Each conversation has its own boundaries (turn|pivot, pivot|reply).
+  assert.equal(catR.state.boundaries.length, 2);
+  assert.equal(dogR.state.boundaries.length, 2);
+
+  // Ending one does not affect the other.
+  mind.endConversation(catConv);
+  assert.equal(mind.conversationState(catConv), null);
+  assert.notEqual(mind.conversationState(dogConv), null);
+
+  // End the second — both are now gone.
+  mind.endConversation(dogConv);
+  assert.equal(mind.conversationState(dogConv), null);
+
+  // Ending again is idempotent.
+  mind.endConversation(dogConv);
+  await mind.store.close();
+});
+
+test("E8: respondTurn with a forged handle throws", async () => {
+  const mind = newMind();
+  // { id: 999 } was never returned by beginConversation.
+  await assert.rejects(
+    () => mind.respondTurn({ id: 999 }, "hello"),
+    /not found/,
+  );
+  await mind.store.close();
+});
+
+test("E9: respond and respondTurn give the same answer for the same cumulative bytes", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+
+  // Via respond() — raw concatenation, same as respondTurn.
+  const viaRespond = await mind.respondText(
+    "I adopted a catwhat is its name?",
+  );
+
+  // Via the Conversation API — the first turn is fed (addTurn keeps the
+  // cumulative bytes identical to the raw concatenation above; respondTurn
+  // would append its own reply between the turns).
+  const conv = mind.beginConversation();
+  mind.addTurn(conv, "I adopted a cat");
+  const { response: viaConv } = await mind.respondTurnText(
+    conv,
+    "what is its name?",
+  );
+  mind.endConversation(conv);
+
+  assert.equal(viaRespond, viaConv);
+  await mind.store.close();
+});
+
+test("E10: an empty turn neither grows the context nor marks a boundary", async () => {
+  const mind = newMind();
+  await teachConversation(mind, CAT);
+
+  const conv = mind.beginConversation();
+  mind.addTurn(conv, "I adopted a cat");
+  const before = mind.conversationState(conv);
+
+  // Empty turns are no turns: addTurn and respondTurn alike must leave the
+  // context bytes and the (strictly increasing) boundaries untouched.
+  const viaAdd = mind.addTurn(conv, "");
+  assert.equal(viaAdd.context.length, before.context.length);
+  assert.deepEqual(viaAdd.boundaries, before.boundaries);
+
+  // respondTurn("") answers the ACCUMULATED context (an empty turn adds no
+  // bytes and no boundary of its own) — only its reply may grow the state,
+  // through the same append+boundary path as any turn.
+  const { response: r0, state: viaTurn } = await mind.respondTurnText(
+    conv,
+    "",
+  );
+  const replyLen = new TextEncoder().encode(r0).length;
+  assert.equal(viaTurn.context.length, before.context.length + replyLen);
+  assert.equal(
+    viaTurn.boundaries.length,
+    before.boundaries.length + (replyLen > 0 ? 1 : 0),
+  );
+  for (let i = 1; i < viaTurn.boundaries.length; i++) {
+    assert.ok(viaTurn.boundaries[i] > viaTurn.boundaries[i - 1]);
+  }
+
+  // The conversation still answers afterwards — the zero-growth refold must
+  // not have corrupted the pyramid's shared raw interiors.  (The empty
+  // turn's own reply may have advanced the exchange, so the answer is
+  // asserted by content, not byte-exactly.)
+  const { response } = await mind.respondTurnText(conv, "what is its name?");
+  assert.ok(
+    response.includes("her name is Whiskers"),
+    `expected the name to surface, got ${JSON.stringify(response)}`,
+  );
+
+  mind.endConversation(conv);
+  await mind.store.close();
+});

package/test/35-prefix-edge.test.mjs

@@ -0,0 +1,86 @@
+// test/35-prefix-edge.test.mjs — RC7: right-edge suffix inheritance
+//
+// When ingestPair learns C → D, every right-aligned byte suffix of C
+// that is already a known form inherits the edge.  Gate: ≥ 2 structural
+// parents, or (halo > 0 ∧ already an edge source).  Pure answers do
+// not qualify — they are destinations, not sources.
+//
+// All phrases verified via instrumentation first (see MISTAKES.md).
+
+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";
+import { resolve } from "../dist/src/mind/primitives.js";
+
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+const text = (b) => dec.decode(b.filter((x) => x !== 0));
+const mk = (s = 7) =>
+  new Mind({ seed: s, store: new SQliteStore({ path: ":memory:" }) });
+
+// Establish via pair (gives halo mass).  The second deposit where the
+// form appears as a fold-tree constituent gives ≥ 1 structural parent.
+async function establish(m, phrase) {
+  await m.ingest([phrase, "established"]);
+}
+
+test("A1 — right-aligned known suffix gains edge", async () => {
+  const m = mk();
+  await establish(m, "planet in our solar system");
+  const sid = resolve(m, enc.encode("planet in our solar system"));
+
+  await m.ingest([
+    "What is the largest planet in our solar system",
+    "Jupiter.",
+  ]);
+  const next = m.store.nextFirst(sid, 10).map((n) => text(m.store.bytes(n)));
+  assert.ok(next.some((s) => s.includes("Jupiter")));
+  await m.store.close();
+});
+
+test("A2 — suffix NOT previously known gets NO edge", async () => {
+  const m = mk();
+  const before = m.store.edgeSourceCount();
+  await m.ingest(["What is the largest planet", "Jupiter."]);
+  assert.equal(m.store.edgeSourceCount() - before, 1);
+  await m.store.close();
+});
+
+test("A3 — unestablished ≥ W suffix does NOT inherit", async () => {
+  const m = mk();
+  const before = m.store.edgeSourceCount();
+  // "prefix abcd" has "abcd" as a ≥W suffix, but it was never established.
+  await m.ingest(["prefix abcd", "answer"]);
+  // Only the full context should be a new edge source — no suffix edge.
+  assert.equal(m.store.edgeSourceCount() - before, 1);
+  await m.store.close();
+});
+
+test("B1 — inherited edge is present after propagation", async () => {
+  const m = mk();
+  await establish(m, "largest planet in our solar system");
+  await m.ingest([
+    "What is the largest planet in our solar system",
+    "Jupiter.",
+  ]);
+  const sid = resolve(m, enc.encode("largest planet in our solar system"));
+  const next = m.store.nextFirst(sid, 10).map((n) => text(m.store.bytes(n)));
+  assert.ok(next.some((s) => s.includes("Jupiter")));
+  await m.store.close();
+});
+
+test("B2 — bidirectional pair via suffix inheritance", async () => {
+  const m = mk();
+  await establish(m, "thank you");
+  await establish(m, "merci");
+  await m.ingest(["translates to merci", "thank you"]);
+  await m.ingest(["translates to thank you", "merci"]);
+
+  const sid = resolve(m, enc.encode("thank you"));
+  const next = m.store.nextFirst(sid, 10).map((n) => text(m.store.bytes(n)));
+  // The establish edge ("established") is still there, but the inherited
+  // edge ("merci") must ALSO be present.
+  assert.ok(next.some((s) => s.includes("merci")));
+  await m.store.close();
+});