@hviana/sema 0.1.0

package/test/30-conflict-resolution.test.mjs

@@ -0,0 +1,166 @@
+// 30-conflict-resolution.test.mjs — distributional-evidence disambiguation
+// for conflicting continuations (chooseNext).
+//
+// When a context node has MULTIPLE learnt continuations (e.g. the same question
+// was answered differently across training samples), chooseNext resolves the
+// conflict by comparing each candidate's distributional evidence: the number of
+// distinct contexts that predict it (prevOf count).  This is the structural
+// manifestation of the candidate's halo — each prevOf entry corresponds to a
+// context whose signature was poured into the candidate's halo via pourHalo
+// during ingestPair.
+//
+// A candidate predicted by more distinct contexts carries stronger support and
+// wins regardless of insertion order.  When evidence is equal, first-inserted
+// wins (backward compatible — insertion order is the correct default for equal
+// support).  The gist-cosine comparison is NOT consulted here because for short
+// answer candidates it is dominated by accidental byte-pattern correlations.
+//
+// These assertions pin the behaviour so it cannot silently regress:
+//   • a single continuation still works (the common case — no overhead);
+//   • equal evidence keeps first-inserted (backward compatible);
+//   • MORE distributional evidence overrides insertion order;
+//   • the tiebreak is deterministic and seed-stable.
+
+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";
+
+// ── §1  Single continuation (the common case — must not regress) ─────────────
+
+test("single continuation: unchanged", async () => {
+  const m = new Mind({ seed: 7 });
+  await m.ingest([["fire", "hot"]]);
+  assert.equal(await m.respondText("fire"), "hot");
+});
+
+test("single continuation with query wrapper", async () => {
+  const m = new Mind({ seed: 7 });
+  await m.ingest([["ice", "cold"]]);
+  assert.equal(await m.respondText("the nature of ice is known"), "cold");
+});
+
+// ── §2  Equal evidence — first-inserted wins (backward compatible) ──────────
+
+test("equal evidence: first-inserted wins", async () => {
+  const m = new Mind({ seed: 7 });
+  // Both continuations have exactly ONE prev context each — equal support.
+  await m.ingest([["x", "first"]]);
+  await m.ingest([["x", "second"]]);
+  assert.equal(await m.respondText("x"), "first");
+});
+
+test("equal evidence, reversed insertion order", async () => {
+  const m = new Mind({ seed: 7 });
+  await m.ingest([["x", "second"]]);
+  await m.ingest([["x", "first"]]);
+  assert.equal(await m.respondText("x"), "second");
+});
+
+// ── §3  More distributional evidence overrides insertion order ───────────────
+
+test("more corroborated answer wins despite being trained second", async () => {
+  const m = new Mind({ seed: 7 });
+  // Wrong answer, trained first — 1 context.
+  await m.ingest([["a capital do Brasil é", "Rio de Janeiro"]]);
+  // Correct answer, trained second — but 4 DISTINCT corroborating contexts.
+  await m.ingest([["a capital do Brasil é", "Brasília"]]);
+  await m.ingest([["qual a capital do Brasil?", "Brasília"]]);
+  await m.ingest([["a capital brasileira é", "Brasília"]]);
+  await m.ingest([["Brasil tem como capital", "Brasília"]]);
+
+  assert.equal(await m.respondText("a capital do Brasil é"), "Brasília");
+});
+
+test("more corroborated answer wins with query wrapper", async () => {
+  const m = new Mind({ seed: 7 });
+  // The query must literally contain a trained context form so recognition
+  // can find it — Sema's recognition is content-addressed, not semantic.
+  await m.ingest([["speed of light is", "300 000 km/s"]]);
+  await m.ingest([["speed of light is", "299 792 458 m/s"]]);
+  await m.ingest([["light travels at", "299 792 458 m/s"]]);
+  await m.ingest([["c equals", "299 792 458 m/s"]]);
+
+  // "speed of light is" is a literal substring of this query.
+  const r = await m.respondText("the speed of light is?");
+  assert.ok(
+    r.includes("299 792 458 m/s"),
+    `expected answer to contain '299 792 458 m/s', got '${r}'`,
+  );
+});
+
+test("corroboration from diverse formulations beats single-source wrong answer", async () => {
+  const m = new Mind({ seed: 7 });
+  // One source claims a wrong chemical symbol.
+  await m.ingest([["water is", "Wo"]]);
+  // Multiple diverse sources give the correct one.
+  await m.ingest([["water is", "H2O"]]);
+  await m.ingest([["the chemical formula for water is", "H2O"]]);
+  await m.ingest([["water's molecular composition is", "H2O"]]);
+
+  assert.equal(await m.respondText("water is"), "H2O");
+});
+
+// ── §4  Three-way conflict — most corroborated wins ─────────────────────────
+
+test("three conflicting continuations: most evidenced wins", async () => {
+  const m = new Mind({ seed: 7 });
+  await m.ingest([["answer is", "alpha"]]); // 1 context
+  await m.ingest([["answer is", "beta"]]); // 1 context
+  await m.ingest([["answer is", "gamma"]]); // 1 context
+  await m.ingest([["the answer is", "beta"]]); // +1 for beta
+  await m.ingest([["correct answer is", "beta"]]); // +1 for beta
+  await m.ingest([["desired answer is", "beta"]]); // +1 for beta
+
+  // Beta: 4 prev contexts. Alpha: 1. Gamma: 1. Beta wins.
+  assert.equal(await m.respondText("answer is"), "beta");
+});
+
+// ── §5  Single shared context, diverging answers ────────────────────────────
+
+test("shared prefix with diverging continuations resolved by evidence", async () => {
+  const m = new Mind({ seed: 7 });
+
+  // "Paris is the capital of" has two continuations.  The wrong one (Germany)
+  // slips in first with a single source.  The correct one (France) is
+  // corroborated by multiple formulations that ALL predict "France".
+  await m.ingest([["Paris is the capital of", "Germany"]]); // wrong, 1 source
+  await m.ingest([["Paris is the capital of", "France"]]); // correct
+  await m.ingest([["the capital of this country is", "France"]]); // corroboration
+  await m.ingest([["which country has Paris? It is", "France"]]); // corroboration
+
+  assert.equal(await m.respondText("Paris is the capital of"), "France");
+});
+
+// ── §6  Seed stability ──────────────────────────────────────────────────────
+
+test("same result with different seeds", async () => {
+  for (const seed of [7, 42, 123]) {
+    const m = new Mind({ seed });
+    await m.ingest([["color is", "red"]]);
+    await m.ingest([["color is", "blue"]]);
+    await m.ingest([["favorite color is", "blue"]]);
+    await m.ingest([["preferred color is", "blue"]]);
+
+    assert.equal(await m.respondText("color is"), "blue");
+  }
+});
+
+// ── §7  Multi-hop chain with a conflicting intermediate node ────────────────
+
+test("multi-hop chain with resolved conflict at intermediate node", async () => {
+  const m = new Mind({ seed: 7 });
+
+  // Wrong chain: A → wrong_intermediate
+  await m.ingest([["start", "wrong middle"]]);
+  // Correct chain: A → correct_intermediate → final_answer
+  await m.ingest([["start", "correct middle"]]);
+  await m.ingest([["correct middle", "final answer"]]);
+  // Additional corroboration for the correct intermediate
+  await m.ingest([["begin here", "correct middle"]]);
+  await m.ingest([["the starting point is", "correct middle"]]);
+
+  // Should follow the more corroborated intermediate to the final answer.
+  const r = await m.respondText("start");
+  assert.equal(r, "final answer");
+});

package/test/31-audit.test.mjs

@@ -0,0 +1,288 @@
+// 31-audit.test.mjs — flip points pinned by the inference-path audit.
+//
+// Each section freezes a decision boundary the audit found unguarded:
+//   A. Response provenance (honesty read-out, incl. the recall-echo marker)
+//   B. express() confidence floor (no fabrication from unrelated vectors)
+//   C. Perfect-self-match reverse recall with MULTIPLE predecessors
+//   D. The reason() echo gate (a query that is itself a learnt continuation)
+//   E. consensusFloor — one derived formula, shared by its two consumers
+//
+// The assertions describe BEHAVIOUR only.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { consensusFloor, Mind } from "../dist/src/index.js";
+
+const newMind = () => new Mind({ seed: 7 });
+const text = (r) => new TextDecoder().decode(r.bytes.filter((b) => b !== 0));
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section A — provenance
+// ═══════════════════════════════════════════════════════════════════════
+
+test("A1: a grounded fact carries a non-echo provenance", async () => {
+  const m = newMind();
+  await m.ingest([
+    ["what is ice?", "ice is frozen water"],
+    ["what is fire?", "fire is hot plasma"],
+  ]);
+  const r = await m.respond("what is ice?");
+  assert.equal(text(r), "ice is frozen water");
+  assert.ok(
+    ["cast", "join", "cover", "extract", "recall"].includes(r.provenance),
+    `grounded answer must not be an echo (got ${r.provenance})`,
+  );
+  await m.store.close();
+});
+
+test("A2: silence carries no provenance", async () => {
+  const m = newMind();
+  await m.ingest([["what is a cat?", "a cat is a small feline"]]);
+  const r = await m.respond("explain quantum chromodynamics");
+  assert.equal(r.v, null);
+  assert.equal(r.provenance, undefined);
+  await m.store.close();
+});
+
+test("A3: every answer's provenance is from the closed set", async () => {
+  const m = newMind();
+  await m.ingest([
+    ["ice", "cold"],
+    ["fire", "hot"],
+    ["what is ice?", "ice is frozen water"],
+  ]);
+  const allowed = new Set([
+    "cast",
+    "join",
+    "cover",
+    "extract",
+    "recall",
+    "recall-echo",
+  ]);
+  for (const q of ["ice", "what is ice?", "ice fire", "icy things"]) {
+    const r = await m.respond(q);
+    if (r.v !== null) {
+      assert.ok(allowed.has(r.provenance), `${q} → ${r.provenance}`);
+    }
+  }
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section B — express() confidence floor
+// ═══════════════════════════════════════════════════════════════════════
+
+test("B1: express of a related embedding returns bytes; of an unrelated vector, silence", async () => {
+  const m = newMind();
+  await m.ingest([
+    ["what is ice?", "ice is frozen water"],
+    ["what is fire?", "fire is hot plasma"],
+  ]);
+  const emb = await m.embedding("what is ice?");
+  assert.notEqual(emb, null);
+  const related = await m.express(emb);
+  assert.ok(related.length > 0, "a related vector must still express");
+
+  // A pseudo-random direction is (whp) far below the reach threshold of
+  // every stored gist — expressing it would fabricate an answer.
+  const rand = new Float32Array(emb.length);
+  for (let i = 0; i < rand.length; i++) {
+    rand[i] = (Math.sin(i * 12.9898) * 43758.5453) % 1;
+  }
+  const unrelated = await m.express(rand);
+  assert.equal(unrelated.length, 0, "an unrelated vector must express nothing");
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section C — perfect self-match with multiple predecessors
+// ═══════════════════════════════════════════════════════════════════════
+
+test("C1: a shared answer asked verbatim reverse-recalls ONE of its contexts, not itself", async () => {
+  const m = newMind();
+  await m.ingest([
+    ["what makes ice special?", "it stays frozen"],
+    ["what makes glass special?", "it stays frozen"],
+    ["what is fire?", "fire is hot plasma"],
+  ]);
+  const out = await m.respondText("it stays frozen");
+  assert.ok(
+    out === "what makes ice special?" || out === "what makes glass special?",
+    `expected a predecessor context, got ${JSON.stringify(out)}`,
+  );
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section D — the reason() echo gate
+// ═══════════════════════════════════════════════════════════════════════
+
+test("D1: a query that is itself a learnt continuation still answers deterministically", async () => {
+  // "beta bridge" is the continuation of "alpha follows"; asking it back must
+  // not echo the conversation — it grounds to its own chain fixpoint, the
+  // same answer the chain head reaches.
+  const m = newMind();
+  await m.ingest([
+    ["alpha follows", "beta bridge"],
+    ["beta bridge", "gamma end"],
+    ["gamma end", "delta done"],
+  ]);
+  assert.equal(await m.respondText("beta bridge"), "delta done");
+  assert.equal(await m.respondText("alpha follows"), "delta done");
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section E — consensusFloor: one derived formula
+// ═══════════════════════════════════════════════════════════════════════
+
+test("E1: consensusFloor is ln(N) + 1/2", () => {
+  for (const N of [2, 10, 1000, 1e6]) {
+    assert.equal(consensusFloor(N), Math.log(N) + 1 / 2);
+  }
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section G — pass-2 flip points
+// ═══════════════════════════════════════════════════════════════════════
+
+test("G1: answerRunsInContext decomposes a sparse subsequence and rejects a non-subsequence", async () => {
+  const { answerRunsInContext } = await import(
+    "../dist/src/mind/mechanisms/extraction.js"
+  );
+  const enc = (s) => new TextEncoder().encode(s);
+  const runs = answerRunsInContext(
+    null,
+    enc("the red fox jumps high"),
+    enc("red high"),
+  );
+  assert.deepEqual(runs, [
+    { start: 4, end: 8, ansLen: 4 },
+    { start: 18, end: 22, ansLen: 4 },
+  ]);
+  assert.equal(answerRunsInContext(null, enc("abc"), enc("xyz")), null);
+});
+
+test("G2: detectSaturated — a saturated PARENT region cannot swallow an unsaturated chunk", async () => {
+  const { detectSaturated } = await import("../dist/src/mind/attention.js");
+  const ctx = { space: { maxGroup: 4 } };
+  // collectRegions emits post-order: the parent (0-8) arrives AFTER its two
+  // chunks and shares chunk 1's start.  With chunk 2 (4-8) unsaturated, the
+  // saturated parent + saturated chunk 3 must NOT fuse into one interval
+  // spanning 0-12 over the unsaturated middle.
+  const regions = [
+    { start: 0, end: 4, chunk: true },
+    { start: 4, end: 8, chunk: true },
+    { start: 0, end: 8, chunk: false }, // post-order parent
+    { start: 8, end: 12, chunk: true },
+  ];
+  const sat = detectSaturated(ctx, regions, [true, false, true, true]);
+  assert.deepEqual(sat.intervals, [
+    { start: 0, end: 4 },
+    { start: 8, end: 12 },
+  ]);
+  assert.equal(sat.leadingEnd, 4);
+});
+
+test("G3: poured halo mass breaks equal-diversity ties (repetition is evidence)", async () => {
+  // Both continuations have ONE distinct predecessor context; the second is
+  // reinforced across three episodes.  Insertion order must not decide —
+  // the poured mass must.
+  const m = newMind();
+  await m.ingest([["the sky is", "blue today"]]);
+  for (let i = 0; i < 3; i++) await m.ingest([["the sky is", "grey often"]]);
+  assert.equal(await m.respondText("the sky is"), "grey often");
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section H — pass-3 flip points
+// ═══════════════════════════════════════════════════════════════════════
+
+test("H1: an ALU kernel decline is observable, not silent", async () => {
+  const { Alu } = await import("../dist/src/alu/src/index.js");
+  const alu = new Alu();
+  const enc = (s) => new TextEncoder().encode(s);
+  const v = alu.recogniseValue(enc("tall"));
+  assert.equal(alu.applyCaught, 0);
+  // A symbol fed to arithmetic: the rule declines (null) — and the decline
+  // is counted with the error retained, so a genuine kernel bug can never
+  // hide behind the same catch invisibly.
+  assert.equal(alu.apply("add", [v, v]), null);
+  assert.equal(alu.applyCaught, 1);
+  assert.ok(alu.lastApplyError !== null);
+});
+
+test("H2: the ALU meaning-memo does not change answers across repeat responds", async () => {
+  const m = newMind();
+  await m.ingest([
+    ["1+2", "3"],
+    ["where do penguins live?", "penguins live in antarctica"],
+  ]);
+  // Arithmetic by word-operator (exercises meaningOf), literal infix, and a
+  // plain-English query — each asked twice; the memoised second pass must
+  // answer identically.
+  for (const q of ["sum 3 4", "2+2 3+3", "where do penguins live?"]) {
+    const first = await m.respondText(q);
+    assert.equal(await m.respondText(q), first, q);
+  }
+  assert.equal(await m.respondText("sum 3 4"), "7");
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section I — pass-4 flip points
+// ═══════════════════════════════════════════════════════════════════════
+
+test("I1: containsSpan rejects a sparse subsequence that isSpanShaped accepts", async () => {
+  const { containsSpan, isSpanShaped } = await import(
+    "../dist/src/mind/mechanisms/extraction.js"
+  );
+  const m = newMind();
+  await m.ingest([["what is ice?", "ice is frozen water"]]);
+  const enc = (s) => new TextEncoder().encode(s);
+  // "cold" is a gap-tolerant subsequence of this sentence (c…o…l…d in order)
+  // but NOT a contiguous run nor a recognised subtree: the fusion gate
+  // (containsSpan) must reject it while extraction's multi-piece reading
+  // (isSpanShaped) still accepts it.
+  const query = enc("since october, less daylight");
+  const short = enc("cold");
+  assert.equal(isSpanShaped(m, query, short), true);
+  assert.equal(containsSpan(m, query, short), false);
+  // A contiguous run passes both.
+  assert.equal(containsSpan(m, enc("very cold night"), short), true);
+  await m.store.close();
+});
+
+test("I2: a read of a dangling node id is empty, safe, and COUNTED", async () => {
+  const m = newMind();
+  await m.ingest([["a b", "c d"]]);
+  assert.equal(m.store.danglingReads, 0);
+  const out = await m.express(99_999_999);
+  assert.equal(out.length, 0);
+  assert.equal(m.store.danglingReads, 1);
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════
+// Section F — rationale still traces a full respond (instrumentation path)
+// ═══════════════════════════════════════════════════════════════════════
+
+test("F1: inspectRationale sees the provenance-bearing pipeline end to end", async () => {
+  const m = newMind();
+  await m.ingest([
+    ["what is ice?", "ice is frozen water"],
+    ["what is fire?", "fire is hot plasma"],
+  ]);
+  const steps = [];
+  const r = await m.respond("what is ice?", (s) => steps.push(s));
+  assert.ok(r.provenance !== undefined);
+  const names = new Set(steps.map((s) => s.mechanism ?? s.name));
+  assert.ok(steps.length > 0, "rationale stream must not be empty");
+  assert.ok(
+    [...names].some((n) => String(n).includes("respond")) ||
+      steps.some((s) => JSON.stringify(s).includes("respond")),
+    "the respond mechanism must appear in the rationale",
+  );
+  await m.store.close();
+});

package/test/32-confluence.test.mjs

@@ -0,0 +1,173 @@
+// 32-confluence.test.mjs — the Confluence Join: conjunctive queries.
+//
+// THE CLASS: answers that are stored in NO single fact and exist only as the
+// INTERSECTION of independent evidence streams.  "Which material is
+// translucent and featherlight?" — each property reaches its own exemplars;
+// the entity satisfying BOTH lives exactly where the streams meet.  A path-
+// following mechanism cannot answer this (any one path grounds one
+// constraint), and fusion answers it WRONG (one fact per constraint, from
+// different entities).  Confluence intersects the aligned exemplars across
+// constraints and returns the discriminative content they share, gated by
+// the same structural IDF the attention climb derives — so it can only ever
+// name content that byte-literally exists in two independently learnt facts:
+// it cannot fabricate.
+//
+// Every filler in these corpora is ≥ maxGroup bytes (the literal-alignment
+// quantum), the same constraint CAST's weave detection lives under.
+
+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 mk = (seed = 7) =>
+  new Mind({ seed, store: new SQliteStore({ path: ":memory:" }) });
+const ask = async (m, q) =>
+  (await m.respondText(q)).replace(/\s+/g, " ").trim();
+
+// A small materials corpus: each entity has two properties; every property
+// is shared with a distractor entity, so NO single constraint identifies
+// anything — only the intersection does.
+const materials = [
+  ["Porcelain is translucent", "translucent"],
+  ["Porcelain is featherlight", "featherlight"],
+  ["Aluminium is featherlight", "featherlight"],
+  ["Aluminium is waterproof", "waterproof"],
+  ["Cast iron is waterproof", "waterproof"],
+  ["Cast iron is translucent", "translucent"],
+];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Section A — two-constraint entity resolution
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("A1 — the entity satisfying BOTH constraints is found, not a one-constraint distractor", async () => {
+  const m = mk();
+  await m.ingest(materials);
+
+  // translucent ∩ featherlight = Porcelain (Aluminium is featherlight but
+  // not translucent; Cast iron is translucent but not featherlight).
+  const got = await ask(m, "Which material is translucent and featherlight?");
+  assert.ok(
+    /Porcelain/i.test(got),
+    `expected the intersection entity Porcelain, got "${got}"`,
+  );
+  assert.ok(
+    !/Aluminium|Cast iron/i.test(got),
+    `a one-constraint distractor leaked into the answer: "${got}"`,
+  );
+  await m.store.close();
+});
+
+test("A2 — each pairing resolves to ITS intersection (the join is not a lucky top anchor)", async () => {
+  const m = mk();
+  await m.ingest(materials);
+
+  const cases = [
+    [/featherlight.*waterproof|waterproof.*featherlight/, "Aluminium"],
+    [/waterproof.*translucent|translucent.*waterproof/, "Cast iron"],
+  ];
+  const got1 = await ask(m, "Which material is featherlight and waterproof?");
+  assert.ok(/Aluminium/i.test(got1), `expected Aluminium, got "${got1}"`);
+  assert.ok(!/Porcelain/i.test(got1), `distractor leaked: "${got1}"`);
+
+  const got2 = await ask(m, "Which material is waterproof and translucent?");
+  assert.ok(/Cast iron/i.test(got2), `expected Cast iron, got "${got2}"`);
+  assert.ok(!/Aluminium/i.test(got2), `distractor leaked: "${got2}"`);
+  await m.store.close();
+});
+
+test("A3 — constraint order does not change the intersection", async () => {
+  const m = mk();
+  await m.ingest(materials);
+
+  const got = await ask(m, "Which material is featherlight and translucent?");
+  assert.ok(
+    /Porcelain/i.test(got),
+    `expected Porcelain regardless of constraint order, got "${got}"`,
+  );
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Section B — honesty: an empty intersection must not fabricate
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("B1 — no entity satisfies both: the join must not invent a pairing", async () => {
+  const m = mk();
+  await m.ingest([
+    ["Porcelain is translucent", "translucent"],
+    ["Aluminium is waterproof", "waterproof"],
+    ["Obsidian is razor sharp", "razor sharp"],
+  ]);
+
+  // Nothing is both translucent and waterproof — the intersection is empty.
+  // Whatever fallback answers, it must not ASSERT the false conjunction.
+  const got = await ask(m, "Which material is translucent and waterproof?");
+  assert.ok(
+    !/Porcelain is waterproof|Aluminium is translucent/i.test(got),
+    `a fabricated conjunction was asserted: "${got}"`,
+  );
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Section C — cross-domain: the same meet works on relational facts
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("C1 — who did BOTH things: conjunctive resolution over biographical facts", async () => {
+  const m = mk();
+  await m.ingest([
+    ["Leonardo painted the Mona Lisa", "the Mona Lisa"],
+    ["Leonardo designed flying machines", "flying machines"],
+    ["Raphael painted the School of Athens", "the School of Athens"],
+    ["Brunelleschi designed the great dome", "the great dome"],
+  ]);
+
+  const got = await ask(
+    m,
+    "Who painted the Mona Lisa and designed flying machines?",
+  );
+  assert.ok(/Leonardo/i.test(got), `expected Leonardo, got "${got}"`);
+  assert.ok(
+    !/Raphael|Brunelleschi/i.test(got),
+    `a one-constraint distractor leaked: "${got}"`,
+  );
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Section D — non-interference: single-constraint queries keep their path
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("D1 — a single-constraint query still answers through the ordinary pipeline", async () => {
+  const m = mk();
+  await m.ingest(materials);
+
+  const got = await ask(m, "Porcelain is translucent");
+  assert.ok(
+    got.length > 0 && !/Aluminium|Cast iron/i.test(got),
+    `single-fact query degraded: "${got}"`,
+  );
+  await m.store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Section E — seed independence (approximate resonance must not decide)
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("E1 — the intersection is seed-independent (it is exact, not resonant)", async () => {
+  for (const seed of [1, 7, 42, 99]) {
+    const m = mk(seed);
+    await m.ingest(materials);
+    const got = await ask(
+      m,
+      "Which material is translucent and featherlight?",
+    );
+    assert.ok(
+      /Porcelain/i.test(got) && !/Aluminium|Cast iron/i.test(got),
+      `seed ${seed}: expected Porcelain, got "${got}"`,
+    );
+    await m.store.close();
+  }
+});