@hviana/sema 0.9.0 → 0.9.2

package/dist/src/geometry.js

@@ -173,16 +173,23 @@ export function consensusFloor(N) {
 // groups of `maxGroup` adjacent items into one via permute-then-add
 // (positional seat binding), recursing until one root remains.
 //
-// FLAT per-level fold — one inline loop per level (foldSlice): no per-group
-// function calls, no Array.slice per group, the permute and add FUSED
-// (`gist[d] += v[seat[d]]`, no scratch buffer), and subtree byte lengths
-// carried incrementally on Folded (the old boundary scan re-walked subtrees
-// every level — O(n log n)).  The per-level SUPERPOSITION is byte-identical
-// to the original recursive foldGroup: the same FP additions in the same
-// order.
+// FLAT per-level fold — one loop per level (foldSlice), each group joined by
+// joinFlat with the permute and add FUSED (`gist[d] += v[seat[d]]`, no scratch
+// buffer), and subtree byte lengths carried incrementally on Folded (the old
+// boundary scan re-walked subtrees every level — O(n log n)).  The per-level
+// SUPERPOSITION is byte-identical to the original recursive foldGroup: the
+// same FP additions in the same order.
+//
+// THE SHAPE IS WRITTEN ONCE, OVER A FOLD ALGEBRA.  Which items group under
+// which parent is decided by the cut levels, the keyring and, inside an
+// over-long row, the items' content key — never by what an item IS.  So the
+// grouping (foldSlice, groupByLevel) takes the two things it needs from an
+// item, `join` and `key`, and runs unchanged over the vector fold (perception)
+// and over the identity fold ({@link contentIdentity}), which can therefore
+// never disagree about the tree.
 //
 // LINEAR fold — intermediate gists are NOT normalized; only the final root is
-// (riverFold's single normalize).  This is a deliberate change of similarity
+// (`rootOf`'s single normalize).  This is a deliberate change of similarity
 // semantics from the original per-group normalize, not a cached optimization:
 // the fold is now a pure linear operator — a superposition of positionally-
 // bound leaf vectors — so an interior node carries its span's natural
@@ -201,85 +208,22 @@ export function consensusFloor(N) {
  *  each extra level applies another seat permutation to the whole gist —
  *  near-identical inputs straddling such a cliff read as orthogonal
  *  (measured: 33-byte-identical prefixes at cos ≈ 0). */
-function foldSlice(space, items, start, count, out, force) {
-    const mg = space.maxGroup;
-    const D = space.D;
+function foldSlice(alg, mg, items, start, count, out, force) {
     const complete = count - (count % mg);
-    const foldAt = (at, size) => {
-        const gist = new Float32Array(D);
-        const kids = new Array(size);
-        let len = 0;
-        for (let k = 0; k < size; k++) {
-            const f = items[at + k];
-            const slot = twoEndedSeat(space.seats.length, size, k);
-            const seat = space.seats[slot].fwd;
-            const v = f.tree.v;
-            // Fused permute-and-accumulate — same FP ops, same order as the old
-            // permuteInto + addInto pair, with no scratch buffer.
-            for (let d = 0; d < D; d++)
-                gist[d] += v[seat[d]];
-            kids[k] = f.tree;
-            len += f.len;
-        }
-        out.push({ tree: sema(gist, null, kids), len });
-    };
-    for (let i = 0; i < complete; i += mg)
-        foldAt(start + i, mg);
+    for (let i = 0; i < complete; i += mg) {
+        out.push(alg.join(items.slice(start + i, start + i + mg)));
+    }
     const leftover = count - complete;
     if (leftover === 0)
         return;
-    if (force && leftover >= 2)
-        foldAt(start + complete, leftover);
+    if (force && leftover >= 2) {
+        out.push(alg.join(items.slice(start + complete, start + count)));
+    }
     else
         for (let i = complete; i < count; i++)
             out.push(items[start + i]);
 }
-function riverFold(space, row, stableBytes) {
-    if (row.length === 0) {
-        const z = new Float32Array(space.D);
-        return { tree: sema(z, new Uint8Array(0), null), len: 0 };
-    }
-    let level = row;
-    while (level.length > 1) {
-        // Find the item index where accumulated bytes reaches stableBytes.
-        let boundary = level.length;
-        if (stableBytes > 0) {
-            let acc = 0;
-            for (let i = 0; i < level.length; i++) {
-                acc += level[i].len;
-                if (acc >= stableBytes) {
-                    boundary = i + 1;
-                    break;
-                }
-            }
-        }
-        const next = [];
-        if (boundary < level.length) {
-            // Prefix folds independently of the suffix — structural stability.
-            foldSlice(space, level, 0, boundary, next, true);
-            foldSlice(space, level, boundary, level.length - boundary, next, true);
-        }
-        else {
-            foldSlice(space, level, 0, level.length, next, true);
-        }
-        level = next;
-    }
-    // LINEAR fold — this root normalize is the ONLY normalize of the entire
-    // fold; every intermediate gist stays unnormalized (see the folding
-    // header).  Skipped for a single-leaf input: that root IS the shared
-    // alphabet vector (already unit), and normalizing in place would mutate the
-    // alphabet itself.
-    if (row.length > 1)
-        normalize(level[0].tree.v);
-    return level[0];
-}
 // ---- public API ----
-function bytesToLeaves(alphabet, bytes) {
-    return Array.from(bytes, (b, i) => {
-        const v = alphabet.vecs[b];
-        return { tree: sema(v, bytes.slice(i, i + 1), null), len: 1 };
-    });
-}
 /** CONTENT-DEFINED FOLD BOUNDARIES — where a byte stream segments, chosen by
  *  the bytes rather than by arithmetic.
  *
@@ -341,42 +285,8 @@ function bytesToLeaves(alphabet, bytes) {
  *
  *  Levels are read from the hash the cut was ACCEPTED at, not recomputed, so
  *  they cost nothing beyond the divisions already being done. */
-// Cyclic-polynomial table for the bounded-window cut hash.  Derived once from
-// the fold's own mixing constant — no seed, no tuning.  A byte contributes
-// BUZ[b] on entering the window; the hash rotates by one per byte, so by the
-// time that byte leaves, its contribution has travelled k places and is
-// removed rotated by k.  The rotation is taken at the use site rather than
-// precomputed into a second table so the window width follows maxGroup
-// instead of being frozen at one value.
-const BUZ = new Uint32Array(256);
-{
-    let x = 0x9e3779b9 >>> 0;
-    for (let i = 0; i < 256; i++) {
-        x = Math.imul(x ^ (x >>> 15), 2654435761) >>> 0;
-        x = (x ^ (x >>> 13)) >>> 0;
-        BUZ[i] = x;
-    }
-}
-/** BUZ rotated by the window width — what a byte's contribution has become by
- *  the time it leaves.  Cached because the width follows `maxGroup`, which is
- *  fixed for a given space: built once, then a plain table lookup per byte. */
-let buzOutTable = null;
-let buzOutWidth = -1;
-function buzOut(k) {
-    if (buzOutWidth !== k || buzOutTable === null) {
-        const t = new Uint32Array(256);
-        for (let i = 0; i < 256; i++) {
-            const v = BUZ[i];
-            t[i] = ((v << k) | (v >>> (32 - k))) >>> 0;
-        }
-        buzOutTable = t;
-        buzOutWidth = k;
-    }
-    return buzOutTable;
-}
 function contentLevels(space, bytes) {
     const W = space.maxGroup;
-    const minLen = W - 1;
     const maxLen = space.seats.length;
     // MEASURED AND REFUTED — making E[segment] equal W.  A segment is at least
     // `minLen` bytes and then cuts with probability p, so E[len] = minLen +
@@ -452,21 +362,20 @@ function contentLevels(space, bytes) {
     //   old       0.870   0.902   0.492   0.879    0.888  0.441
     //   this      0.935   0.952   0.732   0.920    0.916  0.935
     //
-    // The cyclic polynomial (each byte enters as a table value, leaves rotated
-    // by the window width) has EXACTLY k bytes of memory and scrambles periodic
-    // input, so the threshold fires at content-chosen positions on a gradient
+    // The register (the last k raw bytes, `h = h << 8 | byte`, mixed by the
+    // two-round avalanche below) has EXACTLY k bytes of memory and scrambles
+    // periodic input, so the threshold fires at content-chosen positions on a gradient
     // just as it does on text — which is what leaves the `maxLen` fallback
     // rarely engaged instead of carrying the phase.  Segment lengths are
     // unchanged in distribution (mean 5.2-7.2 against the old 5.4-6.0), so the
     // mechanisms fitted to that distribution see the same scale.
     //
-    // Cost is the same shape as before: shifts, XORs and two table lookups per
-    // byte, no multiply and no auxiliary structure.  (An exact sliding-window
+    // Cost per byte: a shift, an OR and the avalanche's two multiplies — no
+    // table and no auxiliary structure.  (An exact sliding-window
     // minimum — winnowing — aligns slightly better still, 0.91-0.999, but its
     // deque costs 51 MB/s against this rule's 112 and buys nothing the
     // scrambling hash does not already give.)
     const k = W;
-    const OUT = buzOut(k);
     const cuts = [];
     const levels = [];
     const n = bytes.length;
@@ -648,8 +557,9 @@ function contentFoldSpan(space, alphabet, bytes, from, to) {
     for (let i = 0; i + 1 < edges.length; i++) {
         segs.push(flatFold(space, alphabet, span, edges[i], edges[i + 1]));
     }
-    if (segs.length > 1)
-        return groupByLevel(space, segs, levels, 1);
+    if (segs.length > 1) {
+        return groupByLevel(vectorFold(space), space, segs, levels, 1);
+    }
     return segs[0];
 }
 /** {@link contentFoldSpan} over a WHOLE stream, reusing the segments a previous
@@ -687,7 +597,7 @@ function contentFoldSpan(space, alphabet, bytes, from, to) {
  *  streams.  Verifying the bytes here would cost O(prefix) and defeat the
  *  whole point, so the obligation sits with the caller, and every caller
  *  discharges it structurally rather than by care: `perceiveDeposit` looks the
- *  entry up under `latin1Key(bytes.subarray(0, L))` — the prefix's own bytes
+ *  entry up under `latin1(bytes.subarray(0, L))` — the prefix's own bytes
  *  ARE the cache key — and a conversation's fold state advances only by
  *  append.  A new caller that cannot make the same structural argument must
  *  pass no `prev` at all; the cold path is always correct.
@@ -711,7 +621,7 @@ export function contentFoldIncremental(space, alphabet, bytes, prev) {
         segs.push(hit ?? flatFold(space, alphabet, bytes, edges[i], edges[i + 1]));
     }
     const folded = segs.length > 1
-        ? groupByLevel(space, segs, levels, 1)
+        ? groupByLevel(vectorFold(space), space, segs, levels, 1)
         : segs[0];
     // THE ROOT IS NORMALIZED IN PLACE, A CACHED SEGMENT NEVER IS.  With one
     // segment — or with a grouping that passes a lone item through — `folded`
@@ -745,14 +655,15 @@ export function contentFoldIncremental(space, alphabet, bytes, prev) {
  *  the cut levels are uniformly 0 and carry no signal.  Identical subtrees
  *  fold to identical vectors, so the same items in the same order always
  *  choose the same split — the property the whole fold rests on. */
+const ITEM_KEY_COORDS = 8;
 function itemKey(v) {
     let h = 0x811c9dc5;
-    for (let d = 0; d < 8; d++) {
+    for (let d = 0; d < ITEM_KEY_COORDS; d++) {
         h = Math.imul(h ^ ((v[d] * 8192) | 0), 0x01000193) >>> 0;
     }
     return h >>> 0;
 }
-function groupByLevel(space, items, levels, level) {
+function groupByLevel(alg, space, items, levels, level) {
     if (items.length === 1)
         return items[0];
     const maxSeats = space.seats.length;
@@ -783,7 +694,7 @@ function groupByLevel(space, items, levels, level) {
                 // equal — fall back to the ITEMS' own content.  A group's gist is
                 // diverse where its cut level is not, so hashing it gives a
                 // content-determined split point where the level array has none.
-                const key = itemKey(items[j].tree.v);
+                const key = alg.key(items[j]);
                 if (levels[j] > bestLevel ||
                     (levels[j] === bestLevel && key > bestKey)) {
                     bestLevel = levels[j];
@@ -792,12 +703,12 @@ function groupByLevel(space, items, levels, level) {
                 }
             }
             const part = items.slice(at, best + 1);
-            groups.push(part.length === 1 ? part[0] : joinFlat(space, part));
+            groups.push(part.length === 1 ? part[0] : alg.join(part));
             groupLevels.push(levels[best]);
             at = best + 1;
         }
         const slice = items.slice(at, to);
-        groups.push(slice.length === 1 ? slice[0] : joinFlat(space, slice));
+        groups.push(slice.length === 1 ? slice[0] : alg.join(slice));
     };
     let start = 0;
     for (let i = 0; i <= levels.length; i++) {
@@ -812,10 +723,10 @@ function groupByLevel(space, items, levels, level) {
     if (groups.length === items.length) {
         // This level split nothing — climb rather than spin.
         return level < 24
-            ? groupByLevel(space, items, levels, level + 1)
-            : riverFoldRaw(space, items);
+            ? groupByLevel(alg, space, items, levels, level + 1)
+            : riverFold(alg, space, items);
     }
-    return groupByLevel(space, groups, groupLevels, level + 1);
+    return groupByLevel(alg, space, groups, groupLevels, level + 1);
 }
 /** Join a row of already-folded items as one unnormalized node — the same
  *  two-ended seat binding as {@link flatFold}, one level up.  A group formed
@@ -837,6 +748,76 @@ function joinFlat(space, items) {
     }
     return { tree: sema(gist, null, kids), len };
 }
+/** The vector fold — perception's algebra. */
+const vectorFolds = new WeakMap();
+function vectorFold(space) {
+    let alg = vectorFolds.get(space);
+    if (alg === undefined) {
+        alg = {
+            join: (items) => joinFlat(space, items),
+            key: (item) => itemKey(item.tree.v),
+        };
+        vectorFolds.set(space, alg);
+    }
+    return alg;
+}
+/** The raw gist coordinate `p` of a node whose children are `kids` — the
+ *  coordinate {@link flatFold}/{@link joinFlat} would have written: the same
+ *  float32 additions, in the same order, from a zero start. */
+function boundCoord(space, n, kid, p) {
+    let acc = 0;
+    for (let k = 0; k < n; k++) {
+        const seat = space.seats[twoEndedSeat(space.seats.length, n, k)].fwd;
+        acc = Math.fround(acc + kid(k, seat[p]));
+    }
+    return acc;
+}
+/** The node a byte stream's content fold NAMES — `foldTree` over
+ *  {@link contentFoldSpan}'s tree, without building a single vector.
+ *
+ *  A fold names a node only when every child is named, so identity needs the
+ *  tree's SHAPE and the store's answer for each node — and the shape is a
+ *  function of the bytes (cuts and levels) plus, inside an over-long row, each
+ *  item's {@link itemKey}: eight coordinates of its raw gist.  Those are read
+ *  lazily through {@link boundCoord}, bit-identical to the coordinates the
+ *  vector fold computes, so the grouping (the SAME {@link groupByLevel}) cannot
+ *  differ.  `segment(from, to)` names a level-0 segment (one flat node over
+ *  single-byte atoms, or the atom itself); `branch(kids, from, to)` names the
+ *  group covering [from, to) — `kids` holds null for an unnamed child, because
+ *  the store names a branch by its BYTES when its children do not name it
+ *  (the write side's step 1b, store.ts `intern`), so an unnamed child does not
+ *  settle its ancestors.  Every item's grouping key is read from its content,
+ *  named or not, for the same reason.  An empty stream is the caller's: its
+ *  fold is the alphabet's zero-byte leaf, not a segment. */
+export function contentIdentity(space, alphabet, bytes, segment, branch) {
+    const { cuts, levels } = contentLevels(space, bytes);
+    const edges = [0, ...cuts, bytes.length];
+    const segs = [];
+    for (let i = 0; i + 1 < edges.length; i++) {
+        const from = edges[i], n = edges[i + 1] - from;
+        segs.push({
+            id: segment(from, edges[i + 1]),
+            from,
+            to: edges[i + 1],
+            coord: n === 1 ? (p) => alphabet.vecs[bytes[from]][p] : (p) => boundCoord(space, n, (k, at) => alphabet.vecs[bytes[from + k]][at], p),
+        });
+    }
+    if (segs.length === 1)
+        return segs[0].id;
+    const alg = {
+        join: (items) => {
+            const from = items[0].from, to = items[items.length - 1].to;
+            return {
+                id: branch(items.map((it) => it.id), from, to),
+                from,
+                to,
+                coord: (p) => boundCoord(space, items.length, (k, at) => items[k].coord(at), p),
+            };
+        },
+        key: (item) => item.key ??= itemKey(Array.from({ length: ITEM_KEY_COORDS }, (_, d) => item.coord(d))),
+    };
+    return groupByLevel(alg, space, segs, levels, 1).id;
+}
 /** One segment as a single unnormalized node: leaf per byte, each bound into
  *  a seat derived from its position relative to BOTH segment ends.
  *
@@ -878,14 +859,6 @@ function flatFold(space, alphabet, bytes, from, to) {
     }
     return { tree: sema(gist, null, kids), len: n };
 }
-/* * The stable-prefix segmented fold (fold-contract.md).  Each segment between
- *  consecutive boundaries folds PLAINLY and independently; segment roots
- *  join left-nested, and only the final root is normalized (the linear-fold
- *  contract: one normalize per perception).  A segment's own inner splits
- *  need no recursion here: a nested learnt prefix is itself an earlier
- *  boundary, so the left-nested join reproduces every intermediate learnt
- *  root ((s₀·s₁) IS the root the store learnt for the first two segments'
- *  bytes, and so on). */
 /** A fold's ROOT: ONE normalize per perception, at the root, exactly as
  *  riverFold did — the interior stays raw (the linear-fold contract).
  *
@@ -902,6 +875,14 @@ function rootOf(f) {
         normalize(f.tree.v);
     return f.tree;
 }
+/** The stable-prefix segmented fold (fold-contract.md).  Each segment between
+ *  consecutive boundaries folds PLAINLY and independently; segment roots
+ *  join left-nested, and only the final root is normalized (the linear-fold
+ *  contract: one normalize per perception).  A segment's own inner splits
+ *  need no recursion here: a nested learnt prefix is itself an earlier
+ *  boundary, so the left-nested join reproduces every intermediate learnt
+ *  root ((s₀·s₁) IS the root the store learnt for the first two segments'
+ *  bytes, and so on). */
 function stablePrefixFold(space, alphabet, bytes, boundaries) {
     const cuts = [];
     let prev = 0;
@@ -995,12 +976,15 @@ export function riverFoldRaw(space, row) {
         const z = new Float32Array(space.D);
         return { tree: sema(z, new Uint8Array(0), null), len: 0 };
     }
-    if (row.length === 1)
-        return row[0];
+    return riverFold(vectorFold(space), space, row);
+}
+/** The river's fixed-arity shape over any fold algebra: groups of maxGroup,
+ *  the trailing partial group forced, level after level to one root. */
+function riverFold(alg, space, row) {
     let level = row;
     while (level.length > 1) {
         const next = [];
-        foldSlice(space, level, 0, level.length, next, true);
+        foldSlice(alg, space.maxGroup, level, 0, level.length, next, true);
         level = next;
     }
     return level[0];

package/dist/src/meter.d.ts

@@ -97,6 +97,13 @@ export declare class Meter {
     perceivedBytes: number;
     /** `perceive` calls served from the per-response / conversation memo. */
     perceiveHits: number;
+    /** Bytes walked by the IDENTITY fold (`exactNode` — the fold's shape read
+     *  for its node id, no vectors).  Perception's content-addressed half: what
+     *  used to show up in `perceivedBytes` when every resolve folded vectors. */
+    identityBytes: number;
+    /** Branches the read side named by their BYTES — the flat node the write
+     *  side reused when the children named none (primitives.ts `branchNaming`). */
+    flatBranchNames: number;
     /** `recognise` calls that actually ran. */
     recognitions: number;
     /** Bytes recognised by those calls. */
@@ -150,12 +157,20 @@ export declare class Meter {
     searchPops: number;
     /** Chart items pushed by those searches. */
     searchPushes: number;
+    /** Chart items popped DOMINATED — a span's form or completion that could
+     *  only yield completions of that span costing at least one already yielded
+     *  (graph-search.ts `buildSearch`), so no rule was generated from it. */
+    searchDominated: number;
     /** `floor()` calls that returned a bound (the mechanism could fire). */
     mechanismFloors: number;
     /** `floor()` calls that returned null (structurally impossible). */
     mechanismSkips: number;
     /** `run()` calls — the ones the floor pruning let through. */
     mechanismRuns: number;
+    /** Mechanisms skipped because a mechanism floored lower, run AHEAD of them
+     *  (pipeline.ts, "a cheaper bound is looked at before a dearer one is paid
+     *  for"), already reached a grade their floor cannot beat. */
+    mechanismsBounded: number;
     /** Candidates the decider weighed. */
     candidates: number;
     /** `deriveThrough` yielded — a fact was reached through the subject the query
@@ -168,6 +183,11 @@ export declare class Meter {
     joinNoKey: number;
     /** Refused: the fact contains no entity that leads anywhere. */
     joinNoEntity: number;
+    /** Facts the join was priced for — the facts a lightest derivation stood on
+     *  (graph-search.ts `solve`), each once.  The output-sensitivity of the join
+     *  in one number: it tracks the answer's facts, never how many facts the
+     *  exploration reached (`test/150`). */
+    joinFacts: number;
     /** `recompleteNode` re-covered a produced form — the descent that decomposes
      *  a completion by ITS OWN kids.  Without this the descent is invisible: a
      *  caller could see the chain's result but not whether the recomposition
@@ -177,6 +197,19 @@ export declare class Meter {
     /** Times the reasoner pivoted on a span its answer contains and stepped
      *  across that fact. */
     pivotSteps: number;
+    /** `chooseNext` picks the question NAMED — a continuation one of whose own
+     *  establishing contexts the question (plus the node) wholly witnesses
+     *  (traverse.ts, the exact tier). */
+    askedContinuations: number;
+    /** Predecessor rows that exact tier read, against its shared √N budget. */
+    askedPredecessorReads: number;
+    /** Times the tier abstained on a read it could not trust: the continuations
+     *  came back at the √N cap, or its predecessor budget ran out before every
+     *  continuation was asked about — the distributional ladder decided. */
+    askedReadsSaturated: number;
+    /** Cover sites dropped as FRAGMENTS whose several continuations the question
+     *  names none of (mechanisms/cover.ts). */
+    unaskedFragments: number;
     /** Canon probes REFUSED because the canon budget ran out — the one thing the
      *  budget does that nothing could see.  The budget itself is derived
      *  (`bytes.length · chainReach(W)²`, recognition.ts), and the cheap exact route

package/dist/src/meter.js

@@ -91,6 +91,13 @@ export class Meter {
     perceivedBytes = 0;
     /** `perceive` calls served from the per-response / conversation memo. */
     perceiveHits = 0;
+    /** Bytes walked by the IDENTITY fold (`exactNode` — the fold's shape read
+     *  for its node id, no vectors).  Perception's content-addressed half: what
+     *  used to show up in `perceivedBytes` when every resolve folded vectors. */
+    identityBytes = 0;
+    /** Branches the read side named by their BYTES — the flat node the write
+     *  side reused when the children named none (primitives.ts `branchNaming`). */
+    flatBranchNames = 0;
     /** `recognise` calls that actually ran. */
     recognitions = 0;
     /** Bytes recognised by those calls. */
@@ -146,6 +153,10 @@ export class Meter {
     searchPops = 0;
     /** Chart items pushed by those searches. */
     searchPushes = 0;
+    /** Chart items popped DOMINATED — a span's form or completion that could
+     *  only yield completions of that span costing at least one already yielded
+     *  (graph-search.ts `buildSearch`), so no rule was generated from it. */
+    searchDominated = 0;
     // ── Mind: the mechanism market ──────────────────────────────────────────
     /** `floor()` calls that returned a bound (the mechanism could fire). */
     mechanismFloors = 0;
@@ -153,13 +164,17 @@ export class Meter {
     mechanismSkips = 0;
     /** `run()` calls — the ones the floor pruning let through. */
     mechanismRuns = 0;
+    /** Mechanisms skipped because a mechanism floored lower, run AHEAD of them
+     *  (pipeline.ts, "a cheaper bound is looked at before a dearer one is paid
+     *  for"), already reached a grade their floor cannot beat. */
+    mechanismsBounded = 0;
     /** Candidates the decider weighed. */
     candidates = 0;
     // ── Graph search: the fact join (DIRECTION) ─────────────────────────────
     //
     // The join's outcome was observable ONLY through the rationale, and the
     // rationale PERTURBS the search (measured: appending text to a refusal note
-    // changed a traced answer).  These four counters are the untraced view — the
+    // changed a traced answer).  These five counters are the untraced view — the
     // same surface every other work counter uses, incremented where the decision
     // is made, never behind a trace guard.
     /** `deriveThrough` yielded — a fact was reached through the subject the query
@@ -172,6 +187,11 @@ export class Meter {
     joinNoKey = 0;
     /** Refused: the fact contains no entity that leads anywhere. */
     joinNoEntity = 0;
+    /** Facts the join was priced for — the facts a lightest derivation stood on
+     *  (graph-search.ts `solve`), each once.  The output-sensitivity of the join
+     *  in one number: it tracks the answer's facts, never how many facts the
+     *  exploration reached (`test/150`). */
+    joinFacts = 0;
     /** `recompleteNode` re-covered a produced form — the descent that decomposes
      *  a completion by ITS OWN kids.  Without this the descent is invisible: a
      *  caller could see the chain's result but not whether the recomposition
@@ -187,6 +207,19 @@ export class Meter {
     /** Times the reasoner pivoted on a span its answer contains and stepped
      *  across that fact. */
     pivotSteps = 0;
+    /** `chooseNext` picks the question NAMED — a continuation one of whose own
+     *  establishing contexts the question (plus the node) wholly witnesses
+     *  (traverse.ts, the exact tier). */
+    askedContinuations = 0;
+    /** Predecessor rows that exact tier read, against its shared √N budget. */
+    askedPredecessorReads = 0;
+    /** Times the tier abstained on a read it could not trust: the continuations
+     *  came back at the √N cap, or its predecessor budget ran out before every
+     *  continuation was asked about — the distributional ladder decided. */
+    askedReadsSaturated = 0;
+    /** Cover sites dropped as FRAGMENTS whose several continuations the question
+     *  names none of (mechanisms/cover.ts). */
+    unaskedFragments = 0;
     /** Canon probes REFUSED because the canon budget ran out — the one thing the
      *  budget does that nothing could see.  The budget itself is derived
      *  (`bytes.length · chainReach(W)²`, recognition.ts), and the cheap exact route

package/dist/src/mind/articulation.js

@@ -2,10 +2,12 @@
 //
 //   articulate — substitute answer forms with the asker's synonyms,
 //                using concept (halo) resonance to match the voices.
+import { indexOf } from "../bytes.js";
 import { spliceAll } from "./types.js";
 import { recognise } from "./recognition.js";
 import { answers, contains } from "./traverse.js";
 import { bestHaloMate } from "./match.js";
+import { noLicence } from "./graph-search.js";
 import { coverSequence } from "../derive/src/index.js";
 import { rItem, rNode, traceDerivation } from "./trace.js";
 /** Re-voice an answer in the asker's own words.  For each recognised form
@@ -67,7 +69,18 @@ export async function articulate(ctx, answer, query) {
         if (!found)
             continue;
         const voice = found.item;
+        // THE ASKER'S WORDING ALREADY HOLDING THE FORM is not a re-voicing of it:
+        // splicing it in would add the asker's other words to the answer.  That is
+        // what `contains` asks of the DAG, and the DAG can miss it — the fold cuts
+        // `eva director` as `eva d|irector`, so `eva` is no structural child of it
+        // — so the question is also asked of the bytes, the reading that cannot
+        // miss.  Measured (test/106's chain): the answer's `eva`, a halo mate of the
+        // asker's `eva director` because both lead to the same fact, was revoiced
+        // as "The director of eva director is Gustaf Molander."
+        const formBytes = store.bytesPrefix(s.payload, voice.bytes.length + 1);
         if (voice.node === s.payload || contains(ctx, voice.node, s.payload) ||
+            (formBytes.length <= voice.bytes.length &&
+                indexOf(voice.bytes, formBytes, 0) >= 0) ||
             answers(ctx, voice.node, s.payload)) {
             continue;
         }
@@ -96,7 +109,7 @@ export async function articulate(ctx, answer, query) {
             s.end,
         ])),
     ]);
-    const solved = ctx.search.cover(answer.length, voicedSites, new Map(), ans.leaves, ans.splits, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+    const solved = ctx.search.cover(answer.length, voicedSites, noLicence(), ans.leaves, ans.splits, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
     const segs = solved && solved.segs;
     tArtCover?.done(segs === null
         ? []

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

@@ -350,6 +350,18 @@ export declare function poolVotes(ctx: MindContext, regionVotes: readonly Region
     anchored: Set<number>;
     steps: DerivationStep[];
 };
+/** The number of DISTINCT clusters a root's contributing regions form —
+ *  see Attention.clusters.  Two regions belong to the same cluster iff the
+ *  gap between them is strictly less than one river-fold quantum W: at
+ *  that distance there is no room for a genuinely separate, independently
+ *  perceivable unit of content between them (the same "smallest meaningful
+ *  distinction" quantum {@link reachThreshold}'s own doc invokes).  A gap
+ *  of a full quantum or more means real, separate structure could sit
+ *  between the two spans, so they count as independent corroboration.
+ *  Strict `<` (not `<=`): verified against gap 3.1's own "gender equality"
+ *  root, whose two genuine clusters sit EXACTLY W bytes apart — `<= W`
+ *  would wrongly merge them into one and break that pinned requirement. */
+export declare function countClusters(spans: readonly [number, number][], W: number): number;
 export declare function commitVotes(ctx: MindContext, pooled: {
     votes: Map<number, number>;
     votesIdf: Map<number, number>;