@hviana/sema 0.8.5 → 0.8.6

package/dist/src/meter.d.ts

@@ -199,15 +199,30 @@ export declare class Meter {
      *  not computable at all.  With it, the price of extending the answer is
      *  `reasonSteps · STEP`, the ladder's own value for following an edge. */
     reasonSteps: number;
-    /** Bytes of the grounding's UNCOVERED material the extension was justified by
-     *  — the union of the spans each step carried a `W`-window of.  The gate
-     *  already computed WHICH span carried it per step and kept only a boolean;
-     *  this is that fact, accumulated.  Read with {@link reasonSteps}: one is the
-     *  price, the other the explanation. */
+    /** Bytes the admitted steps ACCOUNTED for — the witnesses' spans, summed by the
+     *  law's own function over the tail of the state's accounting.  It is NOT what
+     *  they carried: a step admitted by `reaches` may declare spans it holds no
+     *  window of, and then it accounts without carrying and consumes nothing (see
+     *  {@link closureDrainedBytes}).  Read with {@link reasonSteps}: one is the
+     *  price, the other the accounting. */
+    reasonAccountedBytes: number;
+    /** Bytes of the QUESTION's own material an admitted step CARRIED — the windows
+     *  of the remainder its product holds, read by the law's one reading.  The
+     *  accounting may be larger (a `reaches` step declares spans it holds no window
+     *  of) and the consumption is the window of a step that also reaches, so the
+     *  three form a lattice: consumed ⊆ carried ⊆ accounted. */
     reasonCarriedBytes: number;
+    /** Times the layer OFFERED a continuation to the law.  Read with
+     *  {@link lawRejects}: the offers the law refused are the Model X contract being
+     *  exercised, and `offerRuns - lawRejects` is the accepted transitions. */
+    offerRuns: number;
+    /** Times the law REFUSED the continuation the layer offered.  A refusal is
+     *  terminal by the layer's contract, so this counts the moments the contract
+     *  mattered — zero means the walk never needed it. */
+    lawRejects: number;
     /** Bytes of the question's REMAINDER a step CONSUMED — the drop the law's own
      *  `advance` makes when a declared move carries the material it accounts for.
-     *  Read with {@link reasonSteps} and {@link reasonCarriedBytes}: carrying is
+     *  Read with {@link reasonSteps} and {@link reasonAccountedBytes}: carrying is
      *  the engagement, this is the consumption, and before it the second was
      *  invisible. */
     closureDrainedBytes: number;

package/dist/src/meter.js

@@ -209,15 +209,30 @@ export class Meter {
      *  not computable at all.  With it, the price of extending the answer is
      *  `reasonSteps · STEP`, the ladder's own value for following an edge. */
     reasonSteps = 0;
-    /** Bytes of the grounding's UNCOVERED material the extension was justified by
-     *  — the union of the spans each step carried a `W`-window of.  The gate
-     *  already computed WHICH span carried it per step and kept only a boolean;
-     *  this is that fact, accumulated.  Read with {@link reasonSteps}: one is the
-     *  price, the other the explanation. */
+    /** Bytes the admitted steps ACCOUNTED for — the witnesses' spans, summed by the
+     *  law's own function over the tail of the state's accounting.  It is NOT what
+     *  they carried: a step admitted by `reaches` may declare spans it holds no
+     *  window of, and then it accounts without carrying and consumes nothing (see
+     *  {@link closureDrainedBytes}).  Read with {@link reasonSteps}: one is the
+     *  price, the other the accounting. */
+    reasonAccountedBytes = 0;
+    /** Bytes of the QUESTION's own material an admitted step CARRIED — the windows
+     *  of the remainder its product holds, read by the law's one reading.  The
+     *  accounting may be larger (a `reaches` step declares spans it holds no window
+     *  of) and the consumption is the window of a step that also reaches, so the
+     *  three form a lattice: consumed ⊆ carried ⊆ accounted. */
     reasonCarriedBytes = 0;
+    /** Times the layer OFFERED a continuation to the law.  Read with
+     *  {@link lawRejects}: the offers the law refused are the Model X contract being
+     *  exercised, and `offerRuns - lawRejects` is the accepted transitions. */
+    offerRuns = 0;
+    /** Times the law REFUSED the continuation the layer offered.  A refusal is
+     *  terminal by the layer's contract, so this counts the moments the contract
+     *  mattered — zero means the walk never needed it. */
+    lawRejects = 0;
     /** Bytes of the question's REMAINDER a step CONSUMED — the drop the law's own
      *  `advance` makes when a declared move carries the material it accounts for.
-     *  Read with {@link reasonSteps} and {@link reasonCarriedBytes}: carrying is
+     *  Read with {@link reasonSteps} and {@link reasonAccountedBytes}: carrying is
      *  the engagement, this is the consumption, and before it the second was
      *  invisible. */
     closureDrainedBytes = 0;

package/dist/src/mind/derivation.d.ts

@@ -196,6 +196,6 @@ export type Offer = (d: DerivationState) => Promise<Continuation | null>;
  *  Nothing here counts steps, and nothing here decides admissibility. */
 export declare function closure(d: DerivationState, query: Uint8Array, W: number, offer: Offer, 
 /** Called for each step the law admits, with the state before and after. */
-onTaken?: (before: DerivationState, after: DerivationState) => void, 
+onTaken?: (before: DerivationState, after: DerivationState, witnesses: ReadonlyArray<Witness>) => void, 
 /** Called when the law refused the continuation the layer offered. */
 onRefused?: (at: DerivationState) => void): Promise<DerivationState>;

package/dist/src/mind/derivation.js

@@ -321,7 +321,7 @@ onRefused) {
             return d;
         }
         const next = advance(d, t, explains);
-        onTaken?.(d, next);
+        onTaken?.(d, next, explains);
         d = next;
     }
 }

package/dist/src/mind/reasoning.js

@@ -183,6 +183,8 @@ export async function reason(ctx, query, d0, preConsumed, pre, voiced = []) {
     // admitted.
     let pending = null;
     const 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.
@@ -232,8 +234,9 @@ export async function reason(ctx, query, d0, preConsumed, pre, voiced = []) {
             cost: STEP,
         };
     };
-    const closed_ = await closure(d0, query, W, offer, (before, after) => {
+    const closed_ = await closure(d0, query, W, offer, (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);
         }
@@ -251,6 +254,10 @@ export async function reason(ctx, query, d0, preConsumed, pre, voiced = []) {
             ctx.trace?.step("pivotStep", [rItem(p.cur, "answer"), rNode(ctx, p.pivot, "pivot")], [rItem(p.fc, "answer", resolve(ctx, p.fc) ?? undefined)], "pivot on the shared span this answer contains, then step forward across that fact");
         }
     }, (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")
@@ -279,7 +286,7 @@ export async function reason(ctx, query, d0, preConsumed, pre, voiced = []) {
         // 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(closed_.accounted.slice(d0.accounted.length));
+        ctx.meter.reasonAccountedBytes += unaccountedBytes(closed_.accounted.slice(d0.accounted.length));
     }
     t?.done([rItem(closed_.product, "answer", resolve(ctx, closed_.product) ?? undefined)], 
     // A FIXPOINT: no further step was offered, or the law refused the one that
@@ -489,6 +496,7 @@ primarySpans = []) {
         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/docs/INDEX.md

@@ -36,7 +36,7 @@ proof in `test/` (pins that fail when the law is broken).
 | 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle        | `test/42`            |
 | 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                          | `test/27`, `test/16` |
 | 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                         | `test/55`            |
-| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law | `test/133`–`140`     |
+| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law | `test/133`–`143`     |
 
 ## Mechanisms (8)
 

package/docs/INVARIANTS.md

@@ -15,4 +15,4 @@
 | 11 | Honest degradation                   | `src/mind/pipeline.ts:weight=moves+PASS*unaccounted` `src/store.ts:BoundedMap:miss→re-derive`                                         | `test/28` `test/84` | `store.md`+`caches.md`    |
 | 12 | Meter contracts                      | `src/meter.ts:Meter,PhaseCost,time` `src/mind/pipeline-mechanism.ts:Precomputed.shared`                                               | `test/55`           | `meter.md`                |
 | 13 | Saturation                           | `traverse.ts:edgeAncestors,types.ts:SaturationReason` `src/mind/junction.ts:junctionContainersFrom` `src/mind/resonance.ts:pivotInto` | `test/27` `test/16` | `saturation.md`           |
-| 14 | Closure                              | `src/mind/derivation.ts:closed,admissible,advance`                                                                                    | `test/133`–`140`    | `closure.md`              |
+| 14 | Closure                              | `src/mind/derivation.ts:closed,admissible,advance`                                                                                    | `test/133`–`143`    | `closure.md`              |

package/docs/architecture/closure.md

@@ -23,6 +23,14 @@ field, no producer field, and no count of any kind. The witnesses `contains` and
 `moves` are the LAYER's: it holds the structure and hands them in, so the law
 never probes the store.
 
+## The boundary
+
+`product` (what it stands on, its identity being `resolve(product)`),
+`accounted` (the price its steps summed) and `remainder` (the question's debt,
+at one quantum) are the derivation's own. What it REACHED and what it SPENT are
+the layer's (`reaches`, `consumed`), never a field here: the law decides
+admission and consumption, the layer decides frontier and termination.
+
 ## The transition
 
 `admissible(state, continuation, query, W)` returns the witnesses the step pays
@@ -33,6 +41,10 @@ consumes what its window proves. Whole-span draining was refuted by `test/110`,
 the window alone by `test/138`. The state is BORN owing what its product does
 not carry.
 
+The walk ends when the layer stops offering or the law refuses; owning no
+search, the law cannot prevent a cycle — that is the layer's, over the structure
+it holds.
+
 ## One cost home
 
 `moves + PASS · unaccountedBytes` is computed in ONE place (`pipeline.ts`,
@@ -60,6 +72,7 @@ vocabulary, not the tracer's.
 ## Pins
 
 - `test/133`–`137` — the law's home, readings, refusal, limits.
-- `test/138` — a cycle cannot close it; a carried move can.
+- `test/138` — a cycle cannot close it, a carried move can.
 - `test/139` — carrying is ENGAGEMENT, not explanation.
-- `test/140` — irrelevant supply changes no answer.
+- `test/140` — irrelevant supply changes nothing.
+- `test/142`, `test/143` — the offer's contract, and the cycles.

package/docs/harness/gates.md

@@ -13,7 +13,7 @@ Guards honest silence, determinism, and every pinned contract. Silence:
 unrelated queries ground to nothing (`test/28`, `50`, `56`, `67`, `76`, `84`).
 Determinism: same seed + deposit order + query gives byte-identical answer
 (`test/20`). Every invariant is pinned, the closure law included
-(`test/133`–`140`). §14–25 (pipeline), §64 (derived thresholds), AGENTS.md §2
+(`test/133`–`143`). §14–25 (pipeline), §64 (derived thresholds), AGENTS.md §2
 invariants 1–5.
 
 ## 2 — Work accounting (profiler)

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/meter.ts

@@ -267,15 +267,30 @@ export class Meter {
    *  not computable at all.  With it, the price of extending the answer is
    *  `reasonSteps · STEP`, the ladder's own value for following an edge. */
   reasonSteps = 0;
-  /** Bytes of the grounding's UNCOVERED material the extension was justified by
-   *  — the union of the spans each step carried a `W`-window of.  The gate
-   *  already computed WHICH span carried it per step and kept only a boolean;
-   *  this is that fact, accumulated.  Read with {@link reasonSteps}: one is the
-   *  price, the other the explanation. */
+  /** Bytes the admitted steps ACCOUNTED for — the witnesses' spans, summed by the
+   *  law's own function over the tail of the state's accounting.  It is NOT what
+   *  they carried: a step admitted by `reaches` may declare spans it holds no
+   *  window of, and then it accounts without carrying and consumes nothing (see
+   *  {@link closureDrainedBytes}).  Read with {@link reasonSteps}: one is the
+   *  price, the other the accounting. */
+  reasonAccountedBytes = 0;
+  /** Bytes of the QUESTION's own material an admitted step CARRIED — the windows
+   *  of the remainder its product holds, read by the law's one reading.  The
+   *  accounting may be larger (a `reaches` step declares spans it holds no window
+   *  of) and the consumption is the window of a step that also reaches, so the
+   *  three form a lattice: consumed ⊆ carried ⊆ accounted. */
   reasonCarriedBytes = 0;
+  /** Times the layer OFFERED a continuation to the law.  Read with
+   *  {@link lawRejects}: the offers the law refused are the Model X contract being
+   *  exercised, and `offerRuns - lawRejects` is the accepted transitions. */
+  offerRuns = 0;
+  /** Times the law REFUSED the continuation the layer offered.  A refusal is
+   *  terminal by the layer's contract, so this counts the moments the contract
+   *  mattered — zero means the walk never needed it. */
+  lawRejects = 0;
   /** Bytes of the question's REMAINDER a step CONSUMED — the drop the law's own
    *  `advance` makes when a declared move carries the material it accounts for.
-   *  Read with {@link reasonSteps} and {@link reasonCarriedBytes}: carrying is
+   *  Read with {@link reasonSteps} and {@link reasonAccountedBytes}: carrying is
    *  the engagement, this is the consumption, and before it the second was
    *  invisible. */
   closureDrainedBytes = 0;

package/src/mind/derivation.ts

@@ -454,7 +454,11 @@ export async function closure(
   W: number,
   offer: Offer,
   /** Called for each step the law admits, with the state before and after. */
-  onTaken?: (before: DerivationState, after: DerivationState) => void,
+  onTaken?: (
+    before: DerivationState,
+    after: DerivationState,
+    witnesses: ReadonlyArray<Witness>,
+  ) => void,
   /** Called when the law refused the continuation the layer offered. */
   onRefused?: (at: DerivationState) => void,
 ): Promise<DerivationState> {
@@ -467,7 +471,7 @@ export async function closure(
       return d;
     }
     const next = advance(d, t, explains);
-    onTaken?.(d, next);
+    onTaken?.(d, next, explains);
     d = next;
   }
 }

package/src/mind/reasoning.ts

@@ -206,6 +206,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.
@@ -268,8 +269,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 +300,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;
@@ -329,7 +337,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 +578,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/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,93 @@
+// 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 } 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",
+  );
+});

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/55-cost-meter.test.mjs

@@ -419,7 +419,7 @@ test("12. the extension's cost obeys the ladder's own inequality", async () => {
   await store.close();
 
   const steps = c.reasonSteps ?? 0;
-  const carried = c.reasonCarriedBytes ?? 0;
+  const carried = c.reasonAccountedBytes ?? 0;
   assert.ok(
     steps >= 1,
     `the extension must run for this to mean anything (got ${steps})`,
@@ -765,7 +765,7 @@ test("18. the remainder the pipeline decides on is visible", async () => {
   };
 
   // The pivoting query: the reasoner runs, so the remainder is non-empty
-  // (measured: reasonSteps 1, reasonCarriedBytes 11).
+  // (measured: reasonSteps 1, reasonAccountedBytes 11).
   const pivot = await run("What is the capital of France famous for");
   assert.ok(
     (pivot.steps ?? 0) >= 1,