@hviana/sema 0.8.2 → 0.8.5

package/test/32-confluence.test.mjs

@@ -171,3 +171,71 @@ test("E1 — the intersection is seed-independent (it is exact, not resonant)",
     await m.store.close();
   }
 });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Section F — the early-exit budget: live, but never pruning
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("F1 — the two streams are found well inside the early-exit's budget", async () => {
+  // The mechanism scans the climb's ranked anchors with two cuts: `ranked.slice(0,
+  // pre.k)` and an early exit after `2W` anchors that returns null when fewer than
+  // two constraint streams exist.  Both are spec-legal (a capacity, and a formula
+  // over W — config.ts's default `maxGroup` is 4) but neither was DERIVED; what
+  // makes them legitimate is that they do not prune the case they exist to protect.
+  //
+  // MEASURED on this corpus: the two streams appear at ranks 1 and 4 against the
+  // budget of 8, while `ranked` is 9 — the cut IS live (it would have returned
+  // null at the 8th anchor) and it does NOT prune.  The last assertion is the
+  // anti-vacuity guard: if `ranked` ever fell to 8 or below, this test would be
+  // pinning nothing at all.
+  const W = 4; // the engine's default quantum: config.ts, geometry.maxGroup
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+  await m.ingest(materials);
+  const steps = [];
+  await m.respondText(
+    "Which material is translucent and featherlight?",
+    (s) => steps.push(s),
+  );
+  await m.store.close();
+
+  const findAnchors = (o, depth = 0) => {
+    if (o === null || typeof o !== "object" || depth > 5) return null;
+    if (Array.isArray(o.anchors) && o.anchors.length) return o;
+    for (const v of Object.values(o)) {
+      const r = findAnchors(v, depth + 1);
+      if (r) return r;
+    }
+    return null;
+  };
+  const step = steps.find((s) => findAnchors(s.data ?? s) !== null);
+  const td = step ? findAnchors(step.data ?? step) : null;
+  assert.ok(td, "the climb must report its anchors");
+
+  const meet = steps.find((s) =>
+    (s.mechanism ?? []).join("/").includes("intersectEvidence")
+  );
+  assert.ok(meet, "confluence must ENTER on a conjunctive query");
+
+  const ranks = (meet.inputs ?? [])
+    .filter((i) => typeof i.node === "number")
+    .map((i) => (td.anchors.find((a) => a.anchor === i.node) ?? {}).rank);
+  assert.ok(
+    ranks.length >= 2,
+    `the meet needs two streams (got ${ranks.length})`,
+  );
+  assert.ok(
+    Math.max(...ranks) < 2 * W,
+    `the streams must appear inside the budget (ranks ${
+      ranks.join(",")
+    } vs 2W=${2 * W})`,
+  );
+  assert.ok(
+    td.anchors.length > 2 * W,
+    `and the cut must be live on this fixture, else this test pins nothing ` +
+      `(ranked=${td.anchors.length}, 2W=${2 * W})`,
+  );
+});

package/test/36-already-answered-fusion.test.mjs

@@ -94,7 +94,16 @@ test("fuseAttention: a root whose continuation is already answered in the query
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.ok(
     !out.includes("reply-greet"),
     `a root whose continuation is already answered in the query must not fuse in, got "${out}"`,
@@ -126,7 +135,16 @@ test("fuseAttention: ordinary multi-topic fusion (no embedded answers) is comple
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.ok(
     out.includes("answer alpha"),
     `an ordinary further topic must still fuse in, got "${out}"`,

package/test/37-cluster-dispersion-fusion.test.mjs

@@ -127,7 +127,16 @@ test("fuseAttention: 2 clusters, low breadth — dispersion alone is enough (gap
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.equal(
     out,
     "answer alpha" + dec(primary),
@@ -154,7 +163,16 @@ test("fuseAttention: 1 cluster, dominant breadth — dominance alone is enough (
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.equal(
     out,
     "answer alpha" + dec(primary),
@@ -180,7 +198,16 @@ test("fuseAttention: 1 cluster, low breadth — neither measure saves it (the li
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.equal(
     out,
     dec(primary),

package/test/38-reason-restate-guard.test.mjs

@@ -57,7 +57,20 @@ test("reason(): a forward hop landing on bytes already present in the query is r
     queryResolved: resolve(m, query),
   };
 
-  const out = await reason(m, query, answer, new Set(), pre);
+  // `reason()` reports the WHOLE extension (bytes + what it carried + how many
+  // steps) so a caller can price it; these assertions measure the bytes, and
+  // that is all this change touches — the law they pin is untouched.
+  // `reason()` now consumes and returns the derivation STATE; with no remainder
+  // the derivation is CLOSED, so the law admits any contained continuation —
+  // which is exactly what these two cases exercise.  The assertions below are
+  // untouched.
+  const state = {
+    product: answer,
+    accounted: [],
+    remainder: [],
+    cost: 0,
+  };
+  const out = (await reason(m, query, state, new Set(), pre)).product;
   assert.equal(
     dec(out),
     "bridge context",
@@ -82,7 +95,20 @@ test("reason(): an ordinary forward hop onto genuinely new content is unaffected
     queryResolved: resolve(m, query),
   };
 
-  const out = await reason(m, query, answer, new Set(), pre);
+  // `reason()` reports the WHOLE extension (bytes + what it carried + how many
+  // steps) so a caller can price it; these assertions measure the bytes, and
+  // that is all this change touches — the law they pin is untouched.
+  // `reason()` now consumes and returns the derivation STATE; with no remainder
+  // the derivation is CLOSED, so the law admits any contained continuation —
+  // which is exactly what these two cases exercise.  The assertions below are
+  // untouched.
+  const state = {
+    product: answer,
+    accounted: [],
+    remainder: [],
+    cost: 0,
+  };
+  const out = (await reason(m, query, state, new Set(), pre)).product;
   assert.equal(
     dec(out),
     "a wholly new fact never mentioned in any query",

package/test/43-cast-analog-seat.test.mjs

@@ -65,6 +65,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
   const dominant = {
     anchor: franceId,
     vote: 100,
+    idfVote: 100, // the fixture builds an Attention: the field has to exist
     ctx: enc("What is the capital of France?"),
     runs: [{ qs: 0, qe: 30, cs: 0, weight: 1 }],
   };
@@ -75,6 +76,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
   const spainPoint = {
     anchor: spainAnalogSrcId,
     vote: 50,
+    idfVote: 50, // the fixture builds an Attention: the field has to exist
     ctx: enc("some other prompt"),
     runs: [{ qs: 32, qe: 62, cs: 0, weight: 1 }],
   };
@@ -85,6 +87,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -95,6 +98,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -103,6 +107,7 @@ test("CAST comparison: a nextOf-descendant analog is seated by its own bytes, no
         {
           anchor: spainAnalogSrcId,
           vote: 50,
+          idfVote: 50, // the fixture builds an Attention: the field has to exist
           start: 32,
           end: 62,
           breadth: 0.5,
@@ -174,6 +179,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
   const dominant = {
     anchor: franceId,
     vote: 100,
+    idfVote: 100, // the fixture builds an Attention: the field has to exist
     ctx: enc("What is the capital of France?"),
     runs: [{ qs: 0, qe: 30, cs: 0, weight: 1 }],
   };
@@ -182,6 +188,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
   const japanPoint = {
     anchor: japanId,
     vote: 50,
+    idfVote: 50, // the fixture builds an Attention: the field has to exist
     ctx: enc("What is the capital of Japan? Tokyo is the capital of Japan."),
     runs: [{ qs: 32, qe: 62, cs: 0, weight: 1 }],
   };
@@ -192,6 +199,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -202,6 +210,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
         {
           anchor: franceId,
           vote: 100,
+          idfVote: 100, // the fixture builds an Attention: the field has to exist
           start: 0,
           end: 30,
           breadth: 1,
@@ -210,6 +219,7 @@ test("CAST comparison: a DIRECTLY aligned analog is never re-projected past its
         {
           anchor: japanId,
           vote: 50,
+          idfVote: 50, // the fixture builds an Attention: the field has to exist
           start: 32,
           end: 62,
           breadth: 0.5,