@hviana/sema 0.5.8 → 0.5.9

package/src/store-sqlite.ts

@@ -146,6 +146,20 @@ CREATE TABLE IF NOT EXISTS canon (
   id INTEGER NOT NULL,
   PRIMARY KEY (h, id)
 ) WITHOUT ROWID;
+-- CONSTITUENT SKETCH (Store.sketchGet/sketchPut): the bottom-k minimal
+-- constituents of a node's subtree, k = √D, chosen by identity hash.  The blob is
+-- a packed int32 little-endian run, already in hash order; an EMPTY blob is a
+-- real answer (a minimal unit has no constituents) and a MISSING ROW means
+-- "not yet computed" — the two must stay distinguishable, which is why absence
+-- is a missing row rather than an empty blob sentinel.  (node:sqlite binds a
+-- zero-length Uint8Array as NULL, so the column is nullable and a NULL blob
+-- reads back as the empty sketch — the ROW is what records "computed".)
+-- Measured on the trained
+-- store: 80.8% of nodes sketch EMPTY, mean 1.14 ids, ~72 MB over 15.7M nodes.
+CREATE TABLE IF NOT EXISTS sketch (
+  id  INTEGER PRIMARY KEY,
+  ids BLOB
+);
 CREATE TABLE IF NOT EXISTS snapshot (
   id INTEGER PRIMARY KEY CHECK (id = 1),
   data BLOB NOT NULL
@@ -256,6 +270,8 @@ export class SQliteStore extends AbstractStore implements Store {
   private _insCanon: any = null;
   private _selCanon: any = null;
   private _cntCanon: any = null;
+  private _insSketch: any = null;
+  private _selSketch: any = null;
   private _selContentFrom: any = null;
   private _delMeta: any = null;
   private _insSnapshot: any = null;
@@ -1029,6 +1045,43 @@ export class SQliteStore extends AbstractStore implements Store {
     return (this._selCanon.all(h) as Array<{ id: number }>).map((r) => r.id);
   }
 
+  // -- Constituent sketch (Store optional capability) --
+
+  sketchGet(id: number): number[] | null {
+    if (!this._selSketch) {
+      this._selSketch = this.sqlite!.prepare(
+        "SELECT ids FROM sketch WHERE id = ?",
+      );
+    }
+    const row = this._selSketch.get(id) as
+      | { ids: Uint8Array | null }
+      | undefined;
+    if (row === undefined) return null; // never computed — NOT the same as []
+    const b = row.ids;
+    if (b === null || b.byteLength === 0) return []; // computed, no constituents
+    const out: number[] = [];
+    const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    for (let i = 0; i + 4 <= b.byteLength; i += 4) {
+      out.push(dv.getInt32(i, true));
+    }
+    return out;
+  }
+
+  sketchPut(id: number, ids: readonly number[]): void {
+    if (!this._insSketch) {
+      this._insSketch = this.sqlite!.prepare(
+        "INSERT OR REPLACE INTO sketch (id, ids) VALUES (?, ?)",
+      );
+    }
+    const b = new Uint8Array(ids.length * 4);
+    const dv = new DataView(b.buffer);
+    for (let i = 0; i < ids.length; i++) dv.setInt32(i * 4, ids[i], true);
+    // Join the deferred write transaction (committed by flush/commit), like
+    // canonAdd — a training run writes these in bulk.
+    this._dbBeginTx();
+    this._insSketch.run(id, b);
+  }
+
   canonCount(): number {
     if (!this._cntCanon) {
       this._cntCanon = this.sqlite!.prepare(

package/src/store.ts

@@ -524,6 +524,34 @@ export interface Store {
     fromId?: NodeId,
   ): void;
 
+  // ── constituent sketch (optional capability) ───────────────────────────
+  // The bottom-k MINIMAL CONSTITUENTS of a node's subtree, k derived from the
+  // representation's own capacity (√D — see companyProfile in mind/learning.ts),
+  // selected by identity hash so the choice is a property of each constituent
+  // and never of where it sits in the fold.
+  //
+  // DURABLE DERIVED STATE, NOT A CACHE.  §2.12 permits a cache to cost only
+  // speed; this decides which terms enter a halo — a learned relation — so an
+  // eviction would change the geometry rather than slow it down.  It is
+  // therefore written like the canon index: computed once, kept, never
+  // budgeted.  Soundness rests on the set being INTRINSIC — minimality,
+  // `len ≥ W` and non-domination are properties of the node's own subtree and
+  // do not move as the corpus grows.  The one corpus-dependent reading, the
+  // hub exclusion, is deliberately NOT stored: it is applied by the caller at
+  // pour time over the ≤ k candidates, which is the drift companyProfile
+  // already documents as benign and one-directional.
+  //
+  // Backends that do not implement the pair leave both absent; companyProfile
+  // then recomputes the sketch per pour and simply loses the amortisation.
+
+  /** The stored sketch of `id`, or null when it has never been computed.
+   *  An empty array is a REAL answer (a minimal unit has no constituents) and
+   *  must be distinguished from null. */
+  sketchGet?(id: NodeId): NodeId[] | null;
+  /** Record `ids` as the sketch of `id`.  Idempotent; ids are already sorted
+   *  by the caller's identity hash. */
+  sketchPut?(id: NodeId, ids: readonly NodeId[]): void;
+
   // ── lifecycle ──────────────────────────────────────────────────────────
   size(): Promise<number>;
   saveSnapshot(bytes: Uint8Array): Promise<void>;

package/test/29-counterfactual.test.mjs

@@ -521,8 +521,27 @@ test("D1 — site-aware climb finds diverse anchors for CAST weave", async () =>
   await m.store.close();
 });
 
+// D2 asserted `provenance === "cast"` — a PROXY, and it hid the very thing this
+// test is named for.  The climb here elects between two anchors whose votes sit
+// 0.54σ–1.04σ apart, i.e. inside the estimator's own resolution: `steel is hard
+// so steel is strong` scores 0.897–1.013 depending on the seed while `water is
+// frigid so water is freezing` holds ~0.983, so the TOP FLIPS on 6 of 24 seeds
+// (measured; the SD tracks 1/√D and the flip rate collapses 19/60 → 12/60 →
+// 2/60 as D goes 256 → 1024 → 4096).  CAST voiced the runner-up regardless of
+// which anchor the climb had committed, so the proxy stayed green while the
+// climb was demonstrably seed-dependent.  See `test/87-codominant-commitment`.
+//
+// The strong form asserts the property in the title: every seed must produce
+// the SAME OUTCOME — same provenance and same bytes.  Uniformity alone is not
+// enough (all seeds could agree on a wrong answer), so correctness is asserted
+// too: the property transfer must still land on "freezing" via CAST.
+//
+// The seed set deliberately includes 1, 8, 18, 20, 22 and 23 — the seeds whose
+// noise puts the OTHER anchor on top.  A seed set that never flips would not
+// exercise the defect at all.
 test("D2 — site-aware climb is seed-independent", async () => {
-  for (const seed of [1, 7, 42, 99]) {
+  const outcomes = new Map();
+  for (const seed of [1, 7, 8, 18, 20, 22, 23, 42, 99]) {
     const m = mk(seed);
     await m.ingest([
       ["ice is cold so ice is brittle", "brittle"],
@@ -530,11 +549,29 @@ test("D2 — site-aware climb is seed-independent", async () => {
       ["water is frigid so water is freezing", "freezing"],
     ]);
     const r = await m.respond("steel is frigid");
-    assert.equal(
-      r.provenance,
-      "cast",
-      `seed ${seed}: CAST must fire — got ${r.provenance}`,
-    );
+    const text = new TextDecoder().decode(r.bytes ?? new Uint8Array());
+    outcomes.set(seed, `${r.provenance}|${text}`);
     await m.store.close();
   }
+  const distinct = new Set(outcomes.values());
+  assert.equal(
+    distinct.size,
+    1,
+    `the outcome depends on the seed — ${
+      [...outcomes].map(([s, o]) => `seed ${s}: ${JSON.stringify(o)}`).join(
+        "; ",
+      )
+    }`,
+  );
+  const [only] = distinct;
+  assert.ok(
+    only.startsWith("cast|"),
+    `seed-independent, but not through CAST: ${JSON.stringify(only)}`,
+  );
+  assert.ok(
+    /freezing/i.test(only),
+    `seed-independent, but the property transfer was lost: ${
+      JSON.stringify(only)
+    }`,
+  );
 });

package/test/77-company-saturation.test.mjs

@@ -0,0 +1,302 @@
+// 77-company-saturation.test.mjs — companyProfile stops because the
+// REPRESENTATION IS FULL, not because a budget ran out.
+//
+// The old rule was `PROFILE_VISITS = 64`: a constant, and one that decided
+// which constituents entered a halo by where they sat in a BFS. It was also
+// wrong in both directions on the trained store — it fired at 64 visits while
+// capacity needed a median of 69 (dropping readable evidence), and an uncapped
+// walk accepted ~50 terms where the representation holds √D = 32.
+//
+// The replacement is derived: a superposition of m unit signatures contributes
+// 1/m per term to any cosine taken against it, so once m > √D one term moves
+// nothing above estimatorNoise(D) = 1/√D. `profileCapacity(D) = √D` is that
+// point (geometry.ts). The constituent set is stored as a bottom-k sketch keyed
+// on each unit's own identity, so membership is a property of the UNIT and not
+// of traversal order.
+//
+// Every check below reads the diagnostics companyProfile reports through
+// ingest's inspectRationale — if the instrumentation were decorative, T8 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";
+import { estimatorNoise, profileCapacity } from "../dist/src/geometry.js";
+
+/** Ingest, collecting every companyProfile diagnostic payload. */
+async function ingestTraced(mind, items) {
+  const seen = [];
+  await mind.ingest(items, undefined, undefined, (s) => {
+    if (s.mechanism[s.mechanism.length - 1] === "companyProfile") {
+      seen.push(s.data);
+    }
+  });
+  return seen;
+}
+
+/** A store that counts the reads companyProfile's stopping rule performs. */
+function countingStore(opts) {
+  const store = new SQliteStore(opts);
+  const counts = { get: 0, sketchGet: 0, sketchPut: 0, parentsFirst: 0 };
+  for (const m of ["get", "sketchGet", "sketchPut", "parentsFirst"]) {
+    const orig = store[m].bind(store);
+    store[m] = (...a) => {
+      counts[m]++;
+      return orig(...a);
+    };
+  }
+  return { store, counts };
+}
+
+const mk = (D = 1024) => {
+  const store = new SQliteStore({ path: ":memory:", D });
+  return { store, mind: new Mind({ seed: 7, store }) };
+};
+
+// A long partner whose constituents are many and mostly unique.
+const longText = (n, tail = "") =>
+  Array.from({ length: n }, (_, i) => `alpha${i} beta${i} gamma${i}`).join(
+    " ",
+  ) + tail;
+
+// ── 1. deep type-level company still works ───────────────────────────────
+// The motivating case: the shared unit sits BELOW the top of the fold, so a
+// depth-1 profile would miss it entirely (test/76 T1 is the full fixture).
+test("T1: a unit shared below depth 1 still enters both profiles", async () => {
+  const { store, mind } = mk();
+  await mind.ingest([
+    ["The Eiffel Tower is in Paris", "Tour Eiffel dia any Paris"],
+    [
+      "A completely unrelated control sentence",
+      "Another unrelated control string",
+    ],
+  ]);
+  // Both partners must have found constituents at all — an empty sketch on a
+  // full sentence is the depth-1 failure this design exists to prevent.
+  const ids = [];
+  for (let i = 0; i < store.nodeCount(); i++) {
+    const s = store.sketchGet?.(i);
+    if (s && s.length > 0) ids.push(i);
+  }
+  assert.ok(ids.length > 0, "no node acquired a non-empty constituent sketch");
+});
+
+// ── 2. training order ────────────────────────────────────────────────────
+test("T2: forward and reverse training order give identical sketches", async () => {
+  const pairs = [
+    ["The Eiffel Tower is in Paris", "Tour Eiffel dia any Paris"],
+    ["Water freezes at zero degrees", "El agua se congela a cero grados"],
+    ["The capital of France is Paris", "La capitale de la France est Paris"],
+  ];
+  const read = async (items) => {
+    const { store, mind } = mk();
+    await mind.ingest(items);
+    // Key sketches by CONTENT, not id — ids depend on mint order by design.
+    const dec = new TextDecoder();
+    const out = new Map();
+    for (let i = 0; i < store.nodeCount(); i++) {
+      const s = store.sketchGet?.(i);
+      if (!s || s.length === 0) continue;
+      const key = dec.decode(store.bytes(i).filter((x) => x !== 0));
+      out.set(
+        key,
+        s.map((n) => dec.decode(store.bytes(n).filter((x) => x !== 0))).sort(),
+      );
+    }
+    return out;
+  };
+  const fwd = await read(pairs);
+  const rev = await read([...pairs].reverse());
+  // Every partner present in both must have the SAME constituent set.
+  let compared = 0;
+  for (const [k, v] of fwd) {
+    if (!rev.has(k)) continue;
+    compared++;
+    assert.deepEqual(
+      v,
+      rev.get(k),
+      `sketch differs by training order for ${JSON.stringify(k)}`,
+    );
+  }
+  assert.ok(compared > 0, "no partner was comparable across orders");
+});
+
+// ── 3. long partners stop by SATURATION, not by a budget ─────────────────
+test("T3: a long partner reports capacity as the stop reason", async () => {
+  const { mind } = mk();
+  const diag = await ingestTraced(mind, [[
+    longText(40),
+    "a short continuation",
+  ]]);
+  const long = diag.filter((d) => d.wholeLen > 400);
+  assert.ok(long.length > 0, "expected at least one long partner");
+  for (const d of long) {
+    assert.equal(d.capacity, profileCapacity(1024), "capacity must be √D");
+    assert.equal(
+      d.stopReason,
+      "capacity",
+      "long partner must stop at capacity",
+    );
+    assert.ok(d.saturated, "long partner must report saturation");
+    assert.equal(
+      d.sketched,
+      d.capacity,
+      "sketch must be exactly capacity-sized",
+    );
+  }
+});
+
+// ── 4. a unit shared at DIFFERENT depths must not be systematically lost ──
+test("T4: a unit shared at different fold depths enters both sketches", async () => {
+  // The motivating fixture. Content-defined cuts put " Paris" at a different
+  // depth in each sentence — "The Eiffel Tower is in Paris" folds to
+  // "The Eiffel " + "Tower is in Paris", "Tour Eiffel dia any Paris" to
+  // "Tour Eiffel " + "dia any Paris" — so the shared unit is a child of
+  // NEITHER. A selection keyed on traversal position reaches it in one partner
+  // and not the other; one keyed on the unit's own identity keeps it in both.
+  //
+  // NOTE the earlier version of this test compared "zzmarker " at the head
+  // against " zzmarker" at the tail. Those are DIFFERENT BYTES, hence different
+  // node identities, so the comparison could never have been about position.
+  const { store, mind } = mk();
+  const A = "The Eiffel Tower is in Paris";
+  const B = "Tour Eiffel dia any Paris";
+  await mind.ingest([[A, B]]);
+
+  const dec = new TextDecoder();
+  const enc = new TextEncoder();
+  const nodeOf = (text) => {
+    const want = enc.encode(text);
+    for (let i = 0; i < store.nodeCount(); i++) {
+      if (store.contentLen(i, want.length + 1) !== want.length) continue;
+      const b = store.bytes(i);
+      if (b.length === want.length && b.every((x, j) => x === want[j])) {
+        return i;
+      }
+    }
+    return null;
+  };
+  const a = nodeOf(A), b = nodeOf(B);
+  assert.ok(a !== null && b !== null, "both partners must be interned");
+  const sa = store.sketchGet(a) ?? [];
+  const sb = store.sketchGet(b) ?? [];
+  assert.ok(
+    sa.length > 0 && sb.length > 0,
+    "both partners must sketch something",
+  );
+  const shared = sa.filter((n) => sb.includes(n));
+  assert.ok(
+    shared.length > 0,
+    `no shared constituent: A=${
+      JSON.stringify(sa.map((n) => dec.decode(store.bytes(n))))
+    } ` +
+      `B=${JSON.stringify(sb.map((n) => dec.decode(store.bytes(n))))}`,
+  );
+});
+
+// ── 5. an irrelevant tail must not buy unbounded work ────────────────────
+test("T5: work per profile does not grow with an irrelevant structural tail", async () => {
+  const work = [];
+  for (const n of [10, 40, 160]) {
+    const { store, counts } = countingStore({ path: ":memory:", D: 1024 });
+    const mind = new Mind({ seed: 7, store });
+    await mind.ingest([[longText(n), "continuation"]]);
+    work.push({ n, parentsFirst: counts.parentsFirst });
+  }
+  // parentsFirst is the hub probe — exactly one per SKETCHED constituent, so it
+  // measures the stopping rule's own cost. Capacity bounds it at √D per pour.
+  const cap = profileCapacity(1024);
+  for (const w of work) {
+    assert.ok(
+      w.parentsFirst <= cap * 8,
+      `hub probes ${w.parentsFirst} at n=${w.n} exceed a capacity-bounded budget`,
+    );
+  }
+  // 16x the tail must not cost 16x the stopping work.
+  const ratio = work[2].parentsFirst / Math.max(1, work[0].parentsFirst);
+  assert.ok(
+    ratio < 4,
+    `stopping work grew ${ratio.toFixed(1)}x for a 16x tail`,
+  );
+});
+
+// ── 6. corpus growth must not explode the stopping cost ──────────────────
+test("T6: the same partner costs the same to profile as the corpus grows", async () => {
+  const probe = async (extra) => {
+    const { store, counts } = countingStore({ path: ":memory:", D: 1024 });
+    const mind = new Mind({ seed: 7, store });
+    const filler = Array.from(
+      { length: extra },
+      (_, i) => [`ctx ${i} alpha`, `ans ${i} beta`],
+    );
+    await mind.ingest(filler);
+    const before = counts.parentsFirst;
+    await mind.ingest([[longText(30), "continuation"]]);
+    return counts.parentsFirst - before;
+  };
+  const small = await probe(20);
+  const large = await probe(600);
+  assert.ok(
+    large <= small * 2 + 16,
+    `profiling cost grew with corpus size: ${small} -> ${large} hub probes`,
+  );
+});
+
+// ── 7. stopping happened only once evidence was insignificant ────────────
+test("T7: saturated profiles report a marginal at or below the noise floor", async () => {
+  const { mind } = mk();
+  const diag = await ingestTraced(mind, [[
+    longText(40),
+    "a short continuation",
+  ]]);
+  const sat = diag.filter((d) => d.saturated);
+  assert.ok(sat.length > 0, "expected a saturated profile");
+  for (const d of sat) {
+    assert.equal(d.noiseFloor, estimatorNoise(1024));
+    // mass = accepted + 1, and capacity is the point where 1/mass reaches the
+    // floor. Accepting everything sketched puts marginal AT the floor; hub
+    // exclusion can leave it above, and the diagnostics must say which.
+    assert.ok(d.mass > 1, "a saturated profile superposed nothing");
+    assert.equal(d.residual, d.sketched - d.accepted);
+    assert.ok(
+      d.marginal <= d.noiseFloor || d.hubDropped + d.dominating === d.residual,
+      `marginal ${d.marginal} above floor ${d.noiseFloor} with unexplained residual`,
+    );
+  }
+});
+
+// ── 8. the instrumentation is not decorative ─────────────────────────────
+test("T8: perturbing capacity measurably moves the diagnostics", async () => {
+  // profileCapacity is √D, so changing D perturbs the saturation point. If the
+  // reported numbers did not follow, the diagnostics would be describing
+  // something other than the rule that actually stops the walk.
+  const at = async (D) => {
+    const store = new SQliteStore({ path: ":memory:", D });
+    const mind = new Mind({ seed: 7, store });
+    const diag = await ingestTraced(mind, [[
+      longText(40),
+      "a short continuation",
+    ]]);
+    return diag.filter((d) => d.saturated);
+  };
+  const small = await at(256); // capacity 16
+  const large = await at(4096); // capacity 64
+  assert.ok(
+    small.length > 0 && large.length > 0,
+    "both D values must saturate",
+  );
+  assert.equal(small[0].capacity, profileCapacity(256));
+  assert.equal(large[0].capacity, profileCapacity(4096));
+  assert.ok(
+    large[0].sketched > small[0].sketched,
+    `sketch size did not follow capacity: ${small[0].sketched} vs ${
+      large[0].sketched
+    }`,
+  );
+  assert.ok(
+    large[0].marginal < small[0].marginal,
+    `marginal did not follow capacity: ${small[0].marginal} vs ${
+      large[0].marginal
+    }`,
+  );
+});

package/test/78-atom-hub-recognition-cliff.test.mjs

@@ -0,0 +1,135 @@
+// 78-atom-hub-recognition-cliff.test.mjs — recognition must not LOSE interior
+// sites when the corpus crosses the atomIsHub threshold.
+//
+// THE BUG THIS PINS.  `atomIsHub` flips at exactly N = 4096 edge sources:
+// atomReach = ⌈N·W/256⌉ = ⌈N/64⌉ exceeds boundFor = √N there (W = 4).
+// recogniseImpl gated FOUR things on that flip, and one of them —
+// tryChain's `!boundary && atomsAreHubs` — blanket-suppressed every
+// off-boundary chain. A store crossing 4096 therefore silently stopped
+// recognising interior forms it had recognised at 4095, with no error and no
+// failing test. Measured on the two-hop fixture below: 4 sites including
+// "France" at N = 3920, 2 sites without it at N = 4227.
+//
+// The fix asks whether the byte-exact branch tryChain ALREADY found is a
+// deposited whole (`bearsEdge`) instead of whether its offset happened to land
+// on a fold cut. So the discriminating assertion is: at N > 4096, an interior
+// form that BEARS A CONTINUATION EDGE is still a recognised site.
+//
+// WHY THIS IS SLOW AND MUST STAY SO.  The threshold is a property of corpus
+// scale, so the only honest fixture is one that actually crosses it — 4300
+// deposits, ~6 s. A cheaper store would sit below the flip and pass under the
+// old code too, which is exactly the hole this file exists to close.
+
+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 { recognise } from "../dist/src/mind/recognition.js";
+import { atomIsHub, corpusN } from "../dist/src/mind/traverse.js";
+
+const CHAIN = [
+  ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+  ["France capital", "The capital of France is Paris."],
+  // The PIVOT: a bare entity that bears a continuation edge, and which occurs
+  // INSIDE hop 1's answer at an offset the fold did not choose as a cut.
+  ["France", "The capital of France is Paris."],
+];
+const ANSWER = "The country of Eiffel Tower is France.";
+
+// Lexically VARIED filler. A single repeated template ("filler 12 alpha") folds
+// to a handful of shared chunks and leaves the query almost uncontested, which
+// was enough to let the two-hop chain compose even with the gate in place —
+// i.e. a templated corpus makes the behavioural test non-discriminating. Real
+// corpora are lexically diverse, so the filler must be too.
+const WORDS =
+  ("alpha bravo charlie delta echo foxtrot golf hotel india juliet " +
+    "kilo lima mike november oscar papa quebec romeo sierra tango uniform " +
+    "victor whiskey xray yankee zulu amber bronze copper dahlia ember fjord " +
+    "gossamer harbour indigo jasmine kestrel lantern marigold nectar opal " +
+    "pewter quartz ripple saffron thistle umber violet willow xenon yarrow")
+    .split(" ");
+const filler = (i) => {
+  const w = (n) => WORDS[(i * 7 + n * 13) % WORDS.length];
+  return [
+    `${w(1)} ${w(2)} ${w(3)} ${i}`,
+    `${w(4)} ${w(5)} ${w(6)} ${w(7)} ${i}`,
+  ];
+};
+
+/** One store, ingested past the atomIsHub flip. */
+async function pastTheFlip() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(CHAIN);
+  await mind.ingest(Array.from({ length: 4300 }, (_, i) => filler(i)));
+  return { store, mind };
+}
+
+const dec = new TextDecoder();
+const textOf = (store, id) =>
+  dec.decode(store.bytes(id).filter((x) => x !== 0));
+
+test("the fixture really is past the atomIsHub threshold", async () => {
+  const { store, mind } = await pastTheFlip();
+  const n = corpusN(mind);
+  assert.ok(n > 4096, `fixture must cross N=4096, got ${n}`);
+  assert.equal(
+    atomIsHub(mind, n),
+    true,
+    "atoms must read as hubs, or this file tests nothing",
+  );
+});
+
+test("an edge-bearing interior form is still recognised past the flip", async () => {
+  const { store, mind } = await pastTheFlip();
+  mind.beginResponse?.();
+  const rec = recognise(mind, new TextEncoder().encode(ANSWER));
+  mind.endResponse?.();
+  const texts = rec.sites.map((s) => textOf(store, s.payload));
+  assert.ok(
+    texts.includes("France"),
+    `interior form "France" was not recognised past the flip; sites = ${
+      JSON.stringify(texts)
+    }`,
+  );
+});
+
+test("the interior form is reachable as a pivot, so the chain composes", async () => {
+  // The behavioural consequence: reason() pivots on the longest unconsumed
+  // learnt context the grounded answer CONTAINS. Lose the site and the hop is
+  // structurally unreachable, whatever the rest of the pipeline does.
+  const { mind } = await pastTheFlip();
+  const steps = [];
+  const out = await mind.respondText(
+    "What is the capital of the country of Eiffel Tower?",
+    (s) => steps.push(s.mechanism[s.mechanism.length - 1]),
+  );
+  assert.ok(
+    steps.includes("pivotStep"),
+    `no pivotStep past the flip; answer was ${JSON.stringify(out)}`,
+  );
+  assert.ok(
+    out.includes("Paris"),
+    `two-hop chain did not compose past the flip: ${JSON.stringify(out)}`,
+  );
+});
+
+test("a fragment that leads nowhere is still NOT recognised", async () => {
+  // The other half of the contract: the gate was protecting against
+  // opportunistic byte-atom chains, and the fix must not have opened that door.
+  // "owe" occurs inside "Eiffel Tower country" but was never deposited as a
+  // form of its own, so it bears no edge and no halo.
+  const { store, mind } = await pastTheFlip();
+  mind.beginResponse?.();
+  const rec = recognise(mind, new TextEncoder().encode(ANSWER));
+  mind.endResponse?.();
+  for (const s of rec.sites) {
+    const t = textOf(store, s.payload);
+    assert.ok(
+      t.length >= 4,
+      `sub-window fragment ${JSON.stringify(t)} was admitted as a site`,
+    );
+  }
+  // And pure noise must still ground to nothing.
+  assert.equal(await mind.respondText("qq8f3kz9 zzxq wvbn"), "");
+});