@hviana/sema 0.8.5 → 0.8.7

package/src/mind/reasoning.ts

@@ -58,6 +58,18 @@ export async function reason(
   // broad structural gate; pinned by test/31-audit.
   const qId = pre.queryResolved;
   if (qId !== null && ctx.store.prevCount(qId) > 0) {
+    // THE ECHO GUARD, NAMED — the audit's point 1 could not attribute two real
+    // walks that stopped with no note at all, and this is where one of them went:
+    // the query IS a learnt continuation, so the reasoner returns the grounded
+    // read-out and never offers anything.  Without this note the walk looks like
+    // an unexplained stop; with it, "no note" can only mean the offer was never
+    // asked.  No decision changes: the guard returns exactly where it did.
+    ctx.trace?.step(
+      "echoGuard",
+      [rItem(query, "query")],
+      [],
+      "the query is itself a learnt continuation — answering the grounded read-out without walking",
+    );
     return d0;
   }
 
@@ -206,6 +218,7 @@ export async function reason(
     | null = null;
 
   const offer: Offer = async (d) => {
+    if (ctx.meter) ctx.meter.offerRuns += 1;
     const cur = d.product;
     // The first step's `cur` IS the grounding's product, so the guard above
     // already resolved it and read its reverse edges — reuse both.
@@ -220,10 +233,37 @@ export async function reason(
     // fixpoint falls through to the pivot step instead.  Offered with `moves`:
     // completing the answer's OWN learnt form is an identity step, not a claim
     // about the asker's material.
+    // THE READ, KEPT — its LENGTH is free and it is the only instrument the
+    // bound has: a read that came back full may have been cut off, and a read
+    // that came back short did not.  No second read is paid for this.
+    const outs = curId !== null ? ctx.store.nextFirst(curId, bound) : [];
+    const saturated = outs.length >= bound;
+    // THE RE-REACH, NAMED — the audit's structural-identity case (its test G), and
+    // the silent path it hid in.  MEASURED, and this is the point's closure: across
+    // thirteen real questions on the trained store — the roteiro's ten plus three —
+    // this note fires ZERO times.  The case, if it exists in this engine, is not on
+    // that material.  It is not unimplementable, it is unobserved, and the audit's
+    // own rule is that an unobserved claim stays declared as unobserved: a
+    // distinction between legitimate convergence and a cycle cannot be implemented
+    // responsibly before it is seen, and the brief's section 13 puts measurement
+    // before code.  What exists here is the instrument that will show it the moment
+    // it happens.  When every successor of the current product has already
+    // been spoken for, the absorb above is skipped WITHOUT a word and the walk
+    // falls to the pivot: the same structure reached again is indistinguishable
+    // from having none.  This note does not change the decision — it makes the
+    // state observable first, because the distinction between a legitimate
+    // convergence and a cycle cannot be implemented responsibly until it is seen.
     if (
-      curId !== null &&
-      ctx.store.nextFirst(curId, bound).some((n) => !consumed.has(n))
+      curId !== null && outs.length > 0 && !outs.some((n) => !consumed.has(n))
     ) {
+      ctx.trace?.step(
+        "reachAlreadySpokenFor",
+        [rItem(cur, "answer")],
+        [],
+        `every continuation of this product (${outs.length}) has already been spoken for — the same structure, reached again`,
+      );
+    }
+    if (curId !== null && outs.some((n) => !consumed.has(n))) {
       const fwd = await follow(ctx, curId, qv);
       const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
       if (
@@ -235,18 +275,79 @@ export async function reason(
         pending = { kind: "absorb", cur, curId, fwd };
         return { product: fwd, contains: true, reaches: true, cost: STEP };
       }
+      // THE ABSORB'S OWN REFUSALS, TOLD APART — a learnt continuation existed
+      // and was declined, so the walk falls through to the pivot rather than
+      // ending.  Which of the four reasons it was is exactly what the rationale
+      // could not say before: `null` at the end of the walk is one state, and
+      // this is another (AGENTS §6 — the note belongs where the mechanism emits
+      // it, not in a counter beside it).
+      const whyAbsorb = fwd === null
+        ? "the unconsumed edge led nowhere"
+        : bytesEqual(fwd, cur)
+        ? "the continuation reached was the product already in hand"
+        : fwdId !== null && consumed.has(fwdId)
+        ? "the continuation reached had already been spoken for"
+        : "this continuation only restates the question";
+      ctx.trace?.step(
+        "absorbCandidateRefused",
+        [rItem(cur, "answer")],
+        [],
+        `${whyAbsorb} — falling through to the pivot`,
+      );
+    }
+
+    if (saturated) {
+      // THE BUDGET, NAMED — the audit's point 2.  `nextFirst` is read with a cap
+      // (`hubBound`), so a saturated read may have hidden a continuation, and the
+      // walk would end as if none existed.  The note says MAY, because the length
+      // cannot tell a full read from a truncated one; it can only tell that this
+      // is where a cut would have happened.
+      ctx.trace?.step(
+        "readBoundSaturated",
+        [rItem(cur, "answer")],
+        [],
+        "the read came back full — a continuation may have been cut off by the bound",
+      );
     }
 
     // Pivot: the longest unconsumed learnt context the answer contains.
     consumeAll(curId);
     const pivot = await pivotInto(ctx, cur, consumed, voiced);
-    if (pivot === null) return null;
+    if (pivot === null) {
+      // THE ENUMERATION, DECLARED — the one duty the law cannot perform for the
+      // layer: only the layer knows that it has nothing left to offer.  Before
+      // this note the walk ended in a bare `null`, indistinguishable from the
+      // causes below it; a reader of the rationale could not tell "exhausted"
+      // from "the candidate was refused" (AGENTS §6: a gap in instrumentation
+      // is a defect IN the instrumentation).
+      ctx.trace?.step(
+        "enumerationExhausted",
+        [rItem(cur, "answer")],
+        [],
+        "the layer has no further candidate — its enumeration is exhausted",
+      );
+      return null;
+    }
     const fc = await follow(ctx, pivot, qv);
     consumeAll(pivot);
     if (
       fc === null || bytesEqual(fc, cur) ||
       restates(query, fc, 0, { proper: true })
     ) {
+      // THE THREE REFUSALS, TOLD APART — a candidate was reached and declined,
+      // which is NOT the same state as having none: the law reads both as "no
+      // continuation", but the rationale should not.
+      const why = fc === null
+        ? "the pivot's context carried no continuation"
+        : bytesEqual(fc, cur)
+        ? "the continuation reached was the product already in hand"
+        : "this continuation only restates the question";
+      ctx.trace?.step(
+        "pivotCandidateRefused",
+        [rItem(cur, "answer")],
+        [],
+        `${why} — refused`,
+      );
       return null;
     }
     pending = { kind: "pivot", cur, pivot, fc };
@@ -268,8 +369,12 @@ export async function reason(
     query,
     W,
     offer,
-    (before, after) => {
+    (before, after, witnesses) => {
       if (ctx.meter) {
+        ctx.meter.reasonCarriedBytes += witnesses.reduce(
+          (n, w) => n + (w.window ? w.window[1] - w.window[0] : 0),
+          0,
+        );
         ctx.meter.closureDrainedBytes += unaccountedBytes(before.remainder) -
           unaccountedBytes(after.remainder);
       }
@@ -295,6 +400,9 @@ export async function reason(
       }
     },
     (at) => {
+      // THE LAW REFUSED — counted where it happened, before the bookkeeping
+      // below decides whether there is a step to report.
+      if (ctx.meter) ctx.meter.lawRejects += 1;
       const p = pending;
       pending = null;
       if (p === null || p.kind !== "pivot") return;
@@ -316,6 +424,34 @@ export async function reason(
     },
   );
 
+  // THE WALK'S OWN ENDING, NAMED — the audit's point 1.  Every stop INSIDE the
+  // offer now has a note, but a walk can also end without the offer ever being
+  // asked, or after a step the law took and then found nothing to follow: those
+  // ended as "no note at all", indistinguishable from a mechanism that never ran.
+  // Two endings cover every remaining case, and together they make a silent stop
+  // impossible — which is what the `Offer` contract needs, because `null` is read
+  // as exhaustion and exhaustion must be a statement, not an absence.
+  t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
+  if (closed_.remainder.length === 0) {
+    ctx.trace?.step(
+      "walkClosed",
+      [rItem(closed_.product, "answer")],
+      [],
+      "the derivation is closed — nothing is left unaccounted for",
+    );
+  } else {
+    ctx.trace?.step(
+      "walkEndedWithoutOffer",
+      [rItem(closed_.product, "answer")],
+      closed_.remainder.map(([a, b]) =>
+        rItem(query.subarray(a, b), "uncovered")
+      ),
+      `the walk ended with ${
+        unaccountedBytes(closed_.remainder)
+      } byte(s) unaccounted and no further offer — no structural continuation`,
+    );
+  }
+
   // INSTRUMENTATION ONLY — the extension's two facts, untraced (meter.ts
   // contract 1: a counter never reaches a decision).  They are what a caller
   // needs to PRICE the extension instead of taking it unconditionally, and both
@@ -329,7 +465,7 @@ export async function reason(
     // over the tail of the state's list — and computed ONLY when a meter is
     // attached: this used to slice and MAP a fresh array on every response, for a
     // counter that usually does not exist.  One allocation, under the meter.
-    ctx.meter.reasonCarriedBytes += unaccountedBytes(
+    ctx.meter.reasonAccountedBytes += unaccountedBytes(
       closed_.accounted.slice(d0.accounted.length),
     );
   }
@@ -570,6 +706,10 @@ export async function fuseAttention(
   if (fusedWitness === null) return { ...state, product: out };
   const fused = advance(state, fusedT, fusedWitness);
   if (ctx.meter) {
+    ctx.meter.reasonCarriedBytes += fusedWitness.reduce(
+      (n, w) => n + (w.window ? w.window[1] - w.window[0] : 0),
+      0,
+    );
     ctx.meter.closureDrainedBytes += unaccountedBytes(state.remainder) -
       unaccountedBytes(fused.remainder);
   }

package/src/mind/traverse.ts

@@ -563,7 +563,13 @@ export function hubCap<T>(
 /** Whether `descendant` lies within `ancestor`'s subtree — a structural DAG
  *  relation read off the hash-consed `kids` lists, by a bounded explicit-stack
  *  descent.  Used by articulation to keep a voice from revoicing a fragment
- *  OF that voice. */
+ *  OF that voice.
+ *
+ *  A HOMONYM, NOT A RELATIVE: the law's `Continuation.contains` (derivation.ts) is
+ *  a producer's claim that its step IS a continuation, a boolean on one step.  This
+ *  is a structural relation between two nodes in the DAG.  The shared word is
+ *  deliberate vocabulary — "containment" is what both name — and the two must not be
+ *  read as one. */
 export function contains(
   ctx: MindContext,
   ancestor: number,

package/test/121-the-extension-does-not-grow-with-the-corpus.test.mjs

@@ -9,7 +9,7 @@
 //
 // MEASURED BEFORE THIS TEST EXISTED, one call per size:
 //
-//     N= 250 / 500 / 1000 / 2000  ⇒  reasonSteps 1, reasonCarriedBytes 11,
+//     N= 250 / 500 / 1000 / 2000  ⇒  reasonSteps 1, reasonAccountedBytes 11,
 //                                     pops 338 (k = 0.000), same answer
 //
 // THE BARS ARE THE REPO'S OWN (trap 4 — no new numbers): test/89 asserts k < 1 for
@@ -72,7 +72,7 @@ async function measure(n) {
   return {
     answer,
     steps: c.reasonSteps ?? 0,
-    carried: c.reasonCarriedBytes ?? 0,
+    carried: c.reasonAccountedBytes ?? 0,
     pops: c.searchPops ?? 0,
   };
 }
@@ -91,7 +91,7 @@ test("a bigger corpus does not buy more extension work for the same answer", asy
     steps.push(r.steps);
     answers.push(r.answer);
     console.log(
-      `    N=${n} → reasonSteps ${r.steps}, reasonCarriedBytes ${r.carried}, ` +
+      `    N=${n} → reasonSteps ${r.steps}, reasonAccountedBytes ${r.carried}, ` +
         `pops ${r.pops}`,
     );
   }

package/test/136-the-two-named-limits.test.mjs

@@ -124,7 +124,7 @@ test("136.2 the extension is not priced — and it pays for itself", async () =>
   // would refuse the IDENTITY steps the law admits, which is the documented
   // failure of the (c) remedy (material lost: "hot" for "cold hot").
   assert.ok(
-    (counters.reasonCarriedBytes ?? 0) * PASS >
+    (counters.reasonAccountedBytes ?? 0) * PASS >
       (counters.reasonSteps ?? 0) * STEP,
     "the extension is carrying less than its steps are worth — measured 11 bytes " +
       "against 1 step here.  If this ever fails, the absent price comparison HAS " +

package/test/142-the-layer-offers-only-what-the-law-admits.test.mjs

@@ -0,0 +1,155 @@
+// 142 — the layer offers only what the law admits, which is what makes a refusal final.
+//
+// THE CONTRACT THIS PINS.  `closure` stops when the law refuses the continuation the layer
+// offered, and reads that refusal as "no continuation exists".  That is valid only under
+// ONE of two architectures: the layer searches for an admissible continuation and offers
+// only a valid one (X), rather than offering candidates for the law to filter (Y).  Sema is
+// X — the producer tries the forward absorb first and reaches for the pivot only when the
+// absorb's guards fail, returning null when neither exists — so the one offer the law can
+// still refuse is the pivot without ownership, and it is the layer's last.
+//
+// 142.1 pins the premise: the law CAN refuse (a continuation that neither carries question
+// material nor declares a move), and admits the two species.  Without a refusal the contract
+// would be vacuous.  142.2 pins the consequence in the engine: the walk ends at that refusal
+// and the satisfying answer is untouched.
+
+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 { admissible, closure } from "../dist/src/mind/derivation.js";
+
+const QUERY = new TextEncoder().encode("ABCDEFGHIJ");
+const W = 4;
+const state = () => ({
+  product: new Uint8Array(0),
+  accounted: [],
+  remainder: [[0, 10]],
+  cost: 0,
+});
+
+test("142.1 the law refuses what neither carries nor reaches, and admits both species", () => {
+  // neither: no window held, no move declared
+  assert.equal(
+    admissible(
+      state(),
+      { product: new TextEncoder().encode("Paris"), contains: true, cost: 1 },
+      QUERY,
+      W,
+    ),
+    null,
+    "an offer that neither carries nor reaches is refused — so offering one is not free",
+  );
+  // carries: the product holds a window of the remainder
+  assert.notEqual(
+    admissible(
+      state(),
+      {
+        product: new TextEncoder().encode("ZZZZABCDZZ"),
+        contains: true,
+        cost: 1,
+      },
+      QUERY,
+      W,
+    ),
+    null,
+    "carrying admits",
+  );
+  // reaches: a declared move, which needs no question material
+  assert.notEqual(
+    admissible(
+      state(),
+      {
+        product: new TextEncoder().encode("Paris"),
+        contains: true,
+        reaches: true,
+        cost: 1,
+      },
+      QUERY,
+      W,
+    ),
+    null,
+    "a declared move admits on its own ground",
+  );
+});
+
+test("142.2 the walk ends at the refusal, with the satisfying answer untouched", async () => {
+  const LINKS = [
+    ["What is the capital of France", "The capital of France is Paris"],
+    ["Paris", "Paris is famous for the Eiffel Tower"],
+    ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+  ];
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(LINKS);
+  const out = await mind.respond("What is the capital of France famous for");
+  const text = new TextDecoder().decode(out.bytes).replace(/\0+/g, "").trim();
+  await store.close();
+  assert.equal(
+    text,
+    LINKS[1][1],
+    "the layer's last offer was refused, and the answer stands",
+  );
+});
+
+// B OF THE AUDIT'S TEN: what a refusal MEANS at the walk's boundary.
+//
+// The walk asks ONCE per round and stops when the law refuses it — it does not ask
+// again.  That is the load-bearing half of the `Offer` contract: a refusal is read
+// as "no continuation exists", and it is why the layer must offer only what the law
+// will admit (model X, pinned by 142.1 and 142.2).  A layer that offered candidates
+// for the law to filter would be wrong here, and its own fallbacks must therefore be
+// INTERNAL to one offer call — which is what the engine's layer does.
+//
+// WHAT THIS DOES NOT SETTLE, and must not be read as settling: the walk reads every
+// reason the layer stopped as exhaustion, and the audit found six of them (exhausted,
+// candidate refused, cycle, read bound, no structure, layer done).  `enumerationExhausted`
+// in reasoning.ts now makes that claim observable; proving the claim TRUE is the open
+// decision the audit left (its section 18.6), not something this test asserts.
+test("142.3 a refusal ends the walk, and is not retried", async () => {
+  const enc = (t) => new TextEncoder().encode(t);
+  // Refused on the law's own ground; admitted for carrying a window (both from 142.1).
+  const REFUSED = { product: enc("Paris"), contains: true, cost: 1 };
+  const ADMITTED = { product: enc("ZZZZABCDZZ"), contains: true, cost: 1 };
+
+  // SANITY FIRST: the literals must be what this test says they are, or the walk
+  // below would end for another reason and pin nothing.
+  assert.equal(
+    admissible(state(), REFUSED, QUERY, W),
+    null,
+    "REFUSED is refused by the law (as in 142.1)",
+  );
+  assert.notEqual(
+    admissible(state(), ADMITTED, QUERY, W),
+    null,
+    "ADMITTED carries a window, so the law admits it (as in 142.1)",
+  );
+
+  const queued = [REFUSED, ADMITTED];
+  const offered = [];
+  const offer = async () => {
+    const next = queued.length > 0 ? queued.shift() : null;
+    offered.push(next);
+    return next;
+  };
+  const taken = [];
+  await closure(
+    state(),
+    QUERY,
+    W,
+    offer,
+    (_before, after) => taken.push(after),
+  );
+
+  assert.equal(
+    offered.length,
+    1,
+    "the law is asked once: a refusal is not retried",
+  );
+  assert.equal(
+    taken.length,
+    0,
+    "nothing was taken — the walk ended at the refusal",
+  );
+  assert.equal(queued.length, 1, "the second candidate was never offered");
+});

package/test/143-cycles-terminate-and-are-not-closure.test.mjs

@@ -0,0 +1,62 @@
+// 143 — cycles, in the engine: three topologies, and what must hold for each.
+//
+// The law holds no `visited`, no `depth`, no `hop`, no `once` and no `cap` — cycle
+// prevention belongs to the layer that controls states and consumption, and a cycle is not
+// closure.  So the engine must terminate on each topology anyway, and the answer must be a
+// fact of the corpus rather than a composition typed around the loop.
+//
+// A→B→A · A→B→C→A · A→B, B→C, C→B (a loop with a tail, where the refusal is not trivial).
+// Each fact is filed under both of its ends, the way the store files one, so the walk has
+// every edge the loop needs.
+
+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 TOPOLOGIES = {
+  "A→B→A": [
+    ["Alice knows Bob", "Alice knows Bob"],
+    ["Bob knows Alice", "Bob knows Alice"],
+  ],
+  "A→B→C→A": [
+    ["Alice knows Bob", "Alice knows Bob"],
+    ["Bob knows Carol", "Bob knows Carol"],
+    ["Carol knows Alice", "Carol knows Alice"],
+  ],
+  "A→B, B→C, C→B": [
+    ["Alice knows Bob", "Alice knows Bob"],
+    ["Bob knows Carol", "Bob knows Carol"],
+    ["Carol knows Bob", "Carol knows Bob"],
+  ],
+};
+
+async function ask(corpus, query) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(corpus);
+  const out = await mind.respond(query);
+  const text = new TextDecoder().decode(out.bytes).replace(/\0+/g, "").trim();
+  await store.close();
+  return text;
+}
+
+for (const [name, corpus] of Object.entries(TOPOLOGIES)) {
+  test(`143 ${name} terminates and answers from the corpus`, async () => {
+    const first = await ask(corpus, "Alice knows");
+    const second = await ask(corpus, "Alice knows");
+    assert.equal(
+      second,
+      first,
+      "two runs agree: no order-dependent wander around the loop",
+    );
+    if (first.length > 0) {
+      assert.ok(
+        corpus.some(([, fact]) => first.includes(fact) || fact.includes(first)),
+        `the answer is one of the corpus's own facts, not a composition typed around the loop: ${
+          JSON.stringify(first)
+        }`,
+      );
+    }
+  });
+}

package/test/144-identity-is-content.test.mjs

@@ -0,0 +1,55 @@
+// 144-identity-is-content.test.mjs — two nodes with the same payload do not exist.
+//
+// WHAT IS PINNED.  Two of the audit's ten discriminating tests look like identity
+// gaps and are not: F ("same payload in two nodes") and G ("the same structure by
+// different paths").  The store is content-addressed, so the same text deposited
+// twice adds NO structure at all, and the second deposit resolves to the very node
+// the first one interned.  That is measured here, on the public surface, rather
+// than argued.
+//
+// WHY IT MATTERS FOR THE LAW.  The layer's cycle control is a set of NODE IDS, so
+// if identical content could live at two ids, the set would miss the second — which
+// is what the audit suspected.  It cannot: identity IS the content.  The consequence
+// is the audit's answer to G — "the same structure by another path" is the same
+// node, and calling its re-reach a cycle is correct, because that node's content was
+// already accounted for.
+//
+// The measurement also carries its own sanity: the first deposit MUST move the
+// count, or the probe is measuring the wrong quantity and proves nothing.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Mind, SQliteStore } from "../dist/src/index.js";
+
+test("144.1 depositing the same text twice adds no structure", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "sema-144-"));
+  const stem = join(dir, "store");
+  const store = new SQliteStore({ path: stem });
+  try {
+    const mind = new Mind({ seed: 7, store });
+    const before = store.edgeSourceCount();
+    await mind.ingest("a b c");
+    const once = store.edgeSourceCount();
+    await mind.ingest("a b c");
+    const twice = store.edgeSourceCount();
+
+    // SANITY FIRST: the quantity has to be one the deposit moves, otherwise the
+    // assertion below is true for the wrong reason and pins nothing.
+    assert.ok(
+      once > before,
+      `the first deposit must add structure (was ${before}, now ${once}) — ` +
+        `if it does not, this test is measuring the wrong quantity`,
+    );
+    assert.equal(
+      twice,
+      once,
+      "the same text deposited twice must not add structure: identity IS content",
+    );
+  } finally {
+    await store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/145-the-instrument-answers.test.mjs

@@ -0,0 +1,58 @@
+// 145-the-instrument-answers.test.mjs — a measurement must move what it claims to measure.
+//
+// WHY THIS FILE EXISTS.  During the derivation audit four probes were run and four times the
+// instrument, not the engine, was wrong: a local import map that could not resolve the engine's
+// types; a call I believed deposited text and deposited nothing; a trace note that never fired
+// because the corpus did not reach it; and a two-hop question that grounded on one hop.  Every
+// time the output looked like a result.  The guards that caught them lived inside the probes,
+// and a probe is thrown away — so the two quantities this suite measures with are pinned here,
+// where the next person will find them (AGENTS 6: close the gap in the instrumentation, once).
+//
+// WHAT IS PINNED.  `edgeSourceCount()` must MOVE when a deposit adds structure, and must NOT
+// move when the same text is deposited again.  Positive and negative together are what make it
+// an instrument: the first says it is alive, the second says it discriminates.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Mind, SQliteStore } from "../dist/src/index.js";
+
+async function withStore(fn) {
+  const dir = mkdtempSync(join(tmpdir(), "sema-145-"));
+  const store = new SQliteStore({ path: join(dir, "store") });
+  try {
+    return await fn(new Mind({ seed: 7, store }), store);
+  } finally {
+    await store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+test("145.1 the instrument is alive: a deposit moves the edge-source count", async () => {
+  await withStore(async (mind, store) => {
+    const before = store.edgeSourceCount();
+    await mind.ingest("a b c");
+    const after = store.edgeSourceCount();
+    assert.ok(
+      after > before,
+      `a deposit must move the count (was ${before}, now ${after}) — if it does not, ` +
+        `every probe that reads this number measures the wrong quantity`,
+    );
+  });
+});
+
+test("145.2 the instrument discriminates: the same text moves nothing", async () => {
+  await withStore(async (mind, store) => {
+    await mind.ingest("a b c");
+    const once = store.edgeSourceCount();
+    await mind.ingest("a b c");
+    assert.equal(
+      store.edgeSourceCount(),
+      once,
+      "the same text again must not move the count — otherwise the number cannot tell " +
+        "new structure from repeated text, and F of the audit would be unmeasurable",
+    );
+  });
+});

package/test/146-the-contains-gate.test.mjs

@@ -0,0 +1,67 @@
+// 146-the-contains-gate.test.mjs — `contains`, the one gate no producer ever closes.
+//
+// WHAT IS PINNED.  The formula above `admissible` is written with CONTAINS as a term, and the
+// engine's three producers all declare it true (measured: the only `contains:` literals in src/
+// are reasoning.ts's absorb, pivot and fusion — all constants).  So the gate cannot reject
+// anything today, and this file makes that state explicit rather than accidental:
+//
+//   • the clause WORKS when it is told false — the law is not ignoring the field;
+//   • and a layer that wants to END a walk does it by offering nothing (`null`), not by declaring
+//     a step that is not a continuation.
+//
+// The second half is the contract; the first is the proof that the field is real.  A gate that
+// neither fires nor is exercised is indistinguishable from a field that was forgotten.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { admissible } from "../dist/src/mind/derivation.js";
+
+const QUERY = new TextEncoder().encode("ABCDEFGHIJ");
+const W = 4;
+const state = () => ({
+  product: new Uint8Array(0),
+  accounted: [],
+  remainder: [[0, 10]],
+  cost: 0,
+});
+
+test("146.1 the contains clause refuses when it is told false", () => {
+  const admits = {
+    product: new TextEncoder().encode("ZZZZABCDZZ"),
+    contains: true,
+    cost: 1,
+  };
+  assert.notEqual(
+    admissible(state(), admits, QUERY, W),
+    null,
+    "with contains true and a window held, the law admits",
+  );
+  assert.equal(
+    admissible(state(), { ...admits, contains: false }, QUERY, W),
+    null,
+    "with contains false the law refuses, whatever else the step carries — " +
+      "so the field is read, not decorative",
+  );
+});
+
+test("146.2 contains false is not how a walk ends", async () => {
+  // The contract's own words, in the law's doc: a layer ends a walk by offering
+  // nothing.  A step that declares itself not-a-continuation is refused, which is
+  // what makes the declaration meaningful rather than a way to stop silently.
+  const step = {
+    product: new TextEncoder().encode("ZZZZABCDZZ"),
+    contains: true,
+    reaches: true,
+    cost: 1,
+  };
+  assert.notEqual(
+    admissible(state(), step, QUERY, W),
+    null,
+    "a declared move is admitted",
+  );
+  assert.equal(
+    admissible(state(), { ...step, contains: false }, QUERY, W),
+    null,
+    "and the same move with contains false is refused — the claim gates everything",
+  );
+});