@hviana/sema 0.6.0 → 0.7.1

package/dist/src/mind/mechanisms/recall.js

@@ -306,10 +306,14 @@ export async function recallByResonance(ctx, query, pre) {
         }
     }
     // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts).
-    // The WIDE candidate list every past-the-top-k mechanism reads lives on
-    // Precomputed (see wideResonance): shared across the whole response, so the
-    // exhaustive branch runs at most once whoever first-touches it.
-    const wideIds = () => pre.wideResonance();
+    // The bridge's proposal source is the response's ONE top-k read — the same
+    // list recall already ranked above — never an exhaustive √N scan.  The
+    // bridge's own candidate cap is 2·recallQueryK, so top-k proposals are
+    // exactly the budget it can consume, and every proposal is byte-verified
+    // downstream (§2.3).  Reuse the memoised `resonance()`; scanning every IVF
+    // cluster here once made every honest refusal cost hundreds of ms regardless
+    // of k.
+    const wideIds = async () => (await pre.resonance()).map((h) => h.id);
     // Every gist-based tier has failed; before refusing, align the query
     // byte-for-byte against the trained contexts its own stored windows
     // anchor, accepting mismatches only as corpus-attested, concept-bar

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -63,30 +63,6 @@ export declare class Precomputed {
      *  duplication a profile shows as doubled `annVectorReads` with nothing to
      *  account for it.  Cached BY PROMISE, so a second caller awaits the first. */
     resonance(): Promise<ReadonlyArray<Hit>>;
-    private _wide?;
-    /** The response's WIDE candidate list — the top-k when the query's gist has
-     *  no concept-level match anywhere, and an exhaustive √N read when it does.
-     *
-     *  Every mechanism that has to look PAST the top-k reads this one list: the
-     *  substitution bridge, prefix completion and the frame filler all did, and
-     *  it was memoised inside recall for exactly that reason (measured: 490 ms
-     *  median re-issued against 13 ms non-exhaustive, 36x).  A memo inside one
-     *  mechanism only serves that mechanism's own tiers, so it lives here now —
-     *  the same move `resonance` made for the top-k.
-     *
-     *  THE CONDITION IS THE TOP HIT'S SCORE, NOT THE CORPUS SIZE.  When nothing
-     *  ranks at concept level, an exhaustive ANN only scores more vectors below
-     *  the bar (profiled at 38K–40K annVectorReads per refusing query on a 325K-
-     *  context store); the structural channels — junction walks, anchor climbs,
-     *  the write side's window index — are the correct proposal source there,
-     *  because the ANN cannot propose what the gist cannot rank.  This was once
-     *  spelled `corpusN(ctx) <= (k · W)³`, which asks a different question and
-     *  answers it wrongly at exactly the scale it was written from: at N =
-     *  325,608 with k = 24 and W = 4 the cube is 884,736, so that store took the
-     *  exhaustive branch — the very branch measured above.  Measured cost of the
-     *  mismatch: substitutionBridge 8,544 ms of a 19,548 ms think (44%), against
-     *  1,248 ms and 14,218 ms without it, every answer byte-identical. */
-    wideResonance(): Promise<ReadonlyArray<number>>;
     private _frames?;
     /** THE FRAME INVENTORY — every ranked candidate that reads as an instance of
      *  the same frame as the query, each with the query spans it leaves VARIABLE

package/dist/src/mind/pipeline-mechanism.js

@@ -13,12 +13,12 @@
 //   4. TRAVELING EVIDENCE — run() returns MechanismResult with accounted, moves,
 //      and unexplained.  The pipeline computes the weight.
 import { indexOf } from "../bytes.js";
-import { conceptThreshold, dominates } from "../geometry.js";
+import { dominates } from "../geometry.js";
 import { windowIds } from "./canonical.js";
 import { read, resolve } from "./primitives.js";
 import { alignGraded, frameSlots, skillExemplar, } from "./match.js";
 import { climbAttentionAll } from "./attention.js";
-import { hubBound, sharedReachMemo } from "./traverse.js";
+import { sharedReachMemo } from "./traverse.js";
 // ── Precomputed ──────────────────────────────────────────────────────────────
 //
 // Precomputed is a LAZY container for structural analyses of the query — the
@@ -128,40 +128,17 @@ export class Precomputed {
     resonance() {
         return this._resonance ??= this.shared("resonance", () => this.ctx.store.resonate(this.guide, this.k));
     }
-    _wide;
-    /** The response's WIDE candidate list — the top-k when the query's gist has
-     *  no concept-level match anywhere, and an exhaustive √N read when it does.
-     *
-     *  Every mechanism that has to look PAST the top-k reads this one list: the
-     *  substitution bridge, prefix completion and the frame filler all did, and
-     *  it was memoised inside recall for exactly that reason (measured: 490 ms
-     *  median re-issued against 13 ms non-exhaustive, 36x).  A memo inside one
-     *  mechanism only serves that mechanism's own tiers, so it lives here now —
-     *  the same move `resonance` made for the top-k.
-     *
-     *  THE CONDITION IS THE TOP HIT'S SCORE, NOT THE CORPUS SIZE.  When nothing
-     *  ranks at concept level, an exhaustive ANN only scores more vectors below
-     *  the bar (profiled at 38K–40K annVectorReads per refusing query on a 325K-
-     *  context store); the structural channels — junction walks, anchor climbs,
-     *  the write side's window index — are the correct proposal source there,
-     *  because the ANN cannot propose what the gist cannot rank.  This was once
-     *  spelled `corpusN(ctx) <= (k · W)³`, which asks a different question and
-     *  answers it wrongly at exactly the scale it was written from: at N =
-     *  325,608 with k = 24 and W = 4 the cube is 884,736, so that store took the
-     *  exhaustive branch — the very branch measured above.  Measured cost of the
-     *  mismatch: substitutionBridge 8,544 ms of a 19,548 ms think (44%), against
-     *  1,248 ms and 14,218 ms without it, every answer byte-identical. */
-    wideResonance() {
-        return this._wide ??= this.shared("wideResonance", async () => {
-            const hits = await this.resonance();
-            if (hits.length > 0 &&
-                hits[0].score >= conceptThreshold(this.ctx.store.D)) {
-                const exhaustive = await this.ctx.store.resonate(this.guide, hubBound(this.ctx), true);
-                return exhaustive.map((h) => h.id);
-            }
-            return hits.map((h) => h.id);
-        });
-    }
+    // REMOVED — the WIDE exhaustive-√N resonance list (`wideResonance`).  It ran
+    // `resonate(guide, √N, exhaustive=true)` whenever the top hit cleared
+    // conceptThreshold, so consumers could look "past the top-k".  Every consumer
+    // only ever needed ≤ 2·recallQueryK proposals (the substitution bridge's own
+    // candidate cap) or a content-addressed answer (prefix completion's
+    // formsOpenedBy), and every proposal is byte-verified downstream (§2.3), so
+    // the exhaustive scan bought recall at O(index) cost for an O(k) need —
+    // measured: 244K annVectorReads per refusing query, ~1.5 s, every answer
+    // byte-identical to a top-k read.  The two consumers now read `resonance()`
+    // (the one top-k read) and the write side's window index respectively — see
+    // recall.ts and prefix-completion.ts.
     _frames;
     /** THE FRAME INVENTORY — every ranked candidate that reads as an instance of
      *  the same frame as the query, each with the query spans it leaves VARIABLE

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

@@ -37,6 +37,29 @@ export interface NarrowDecisionData {
     version: 1;
     margin: number;
 }
+/** Structured payload of the "regimePrediction" rationale step — the R8
+ *  observation exposed as data.  After the first mechanism (cover, which §2.6
+ *  runs first) grounds or abstains, the market's whole outcome is already
+ *  determined by the one cost ladder: the consensus climb runs exactly when
+ *  `worthRunning(2 * STEP)` is true — CAST (floor 2·STEP) is the cheapest
+ *  mechanism that first-touches it, and confluence (3·STEP) / extraction
+ *  (CONCEPT+STEP) are only reached after CAST is.  An incumbent at or below
+ *  that floor prunes CAST and, with it, the climb (retrieval); anything above
+ *  — or no incumbent — runs the full market and the climb (composition).
+ *  Purely observational; never read by inference. */
+export interface RegimePredictionData {
+    version: 1;
+    /** retrieval | composition — the two regimes R1 measured as a ~100× cost
+     *  step. */
+    regime: "retrieval" | "composition";
+    /** The incumbent's grade right after the first mechanism ran, or null when
+     *  it grounded nothing (best === null — composition, with no incumbent). */
+    incumbentGrade: number | null;
+    /** The cheapest composition floor in grade units (`grade(2 * STEP)` = 2,
+     *  CAST's floor) — the bar the incumbent must sit at or below for the
+     *  consensus climb to be skipped. */
+    climbFloorGrade: number;
+}
 /** Think: a single lightest-derivation exploration of the Sema graph.
  *
  *  Every answer travels the same path:

package/dist/src/mind/pipeline.js

@@ -92,9 +92,18 @@ export async function think(ctx, query, mechs) {
     };
     // ── Pre-computation ──────────────────────────────────────────────────
     const mechanisms = mechs ?? defaultMechanisms;
-    const rec = recognise(ctx, query);
+    const meter = ctx.meter;
+    // recognition is a shared analysis (§2.14 contract 5): it does the query's
+    // own store work (perceive → foldTree → resolve), which used to land in
+    // `think` and in nothing narrower — the meter's one accounting surface must
+    // charge it to itself, exactly as attention/weave/resonance are charged.
+    const rec = meter
+        ? await meter.time("recognise", async () => recognise(ctx, query))
+        : recognise(ctx, query);
     // Phase 1: collect computed spans from mechanisms that implement parse()
-    const computed = await collectComputed(ctx, mechanisms, query);
+    const computed = meter
+        ? await meter.time("collectComputed", () => collectComputed(ctx, mechanisms, query))
+        : await collectComputed(ctx, mechanisms, query);
     if (computed.length > 0) {
         ctx.trace?.step("computeExtensions", [rItem(query, "query")], computed.map((u) => rItem(query.subarray(u.i, u.j), "operand", undefined, [u.i, u.j])), `extensions recognised and evaluated ${computed.length} computation(s)`);
         for (const u of computed) {
@@ -107,6 +116,9 @@ export async function think(ctx, query, mechs) {
     // method on Precomputed, first-touched by whichever mechanism's floor
     // survives its cheap gates and the worthRunning check.  A query no
     // mechanism climbs for (e.g. one an extension decided) never climbs.
+    // NOT phased: the constructor itself is trivial (it only derives `k`), so a
+    // phase here would add a zero-work entry to every profiled report — the meter
+    // attributes WORK (§2.14); the trace already represents structure.
     const pre = new Precomputed(ctx, query, rec, computed, ctx._edgeGuide);
     const grade = (w) => Math.floor(w / STEP);
     const unaccounted = (spans) => unexplainedSpans(query.length, spans)
@@ -155,7 +167,7 @@ export async function think(ctx, query, mechs) {
     // Per-mechanism accounting (src/meter.ts).  The market's whole premise is
     // that mechanisms compete on one cost scale — so the profiling read-out is
     // also per-mechanism, uniformly: the loop never asks which one it holds.
-    const meter = ctx.meter;
+    let regimeReported = false;
     for (const mech of mechanisms) {
         const floor = meter
             ? await meter.time(`${mech.name}.floor`, () => mech.floor(ctx, query, pre, worthRunning))
@@ -192,6 +204,42 @@ export async function think(ctx, query, mechs) {
                 scaffolding: r.scaffolding,
             });
         }
+        // REGIME PREDICTION (R8) — observational only.  After the FIRST mechanism
+        // runs (cover, which §2.6 places first and floors at 0), the market's
+        // outcome is already determined: the consensus climb runs exactly when
+        // `worthRunning(2 * STEP)` is true — CAST (floor 2·STEP) is the cheapest
+        // mechanism that first-touches it, so an incumbent at or below grade 2
+        // prunes CAST and, with it, confluence (3·STEP) and extraction
+        // (CONCEPT+STEP) (retrieval); anything above — or no incumbent — runs the
+        // full market and the climb (composition).  The predicate is
+        // `worthRunning`, the same function the loop just used — nothing is
+        // computed here that the engine had not already computed, and nothing is
+        // read back by inference.
+        if (!regimeReported) {
+            regimeReported = true;
+            const climbFloorGrade = grade(2 * STEP);
+            // TS narrows `best` to null in the outer flow (it cannot see the closure
+            // assignments in `consider`) — cast back, the same read-back as `decided`
+            // below.
+            const incumbent = best;
+            const incumbentGrade = incumbent === null
+                ? null
+                : grade(incumbent.weight);
+            const regime = worthRunning(2 * STEP)
+                ? "composition"
+                : "retrieval";
+            ctx.trace?.step("regimePrediction", [rItem(query, "query")], [], regime === "retrieval"
+                ? `retrieval regime — incumbent grade ${incumbentGrade} ≤ climb floor ${climbFloorGrade}, so no composition mechanism runs; ` +
+                    `the consensus climb will not run`
+                : `composition regime — ${incumbentGrade === null
+                    ? "no incumbent (nothing grounded)"
+                    : `incumbent grade ${incumbentGrade}`} above climb floor ${climbFloorGrade}, so the full market and climb run`, undefined, {
+                version: 1,
+                regime,
+                incumbentGrade,
+                climbFloorGrade,
+            });
+        }
     }
     // (TS cannot see the closure assignments into `best` and narrows it to its
     // initial null, so the read-back needs the assertion.)

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

@@ -11,7 +11,12 @@ import type { MindContext, Recognition, Segment } from "./types.js";
  *     query's own cut cannot, and records sub-leaf boundaries as `splits`.
  *
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
-export declare function recognise(ctx: MindContext, bytes: Uint8Array): Recognition;
+/** Decompose `bytes` into the learnt forms it contains.  `trimmed` skips the
+ *  edge-trim fallbacks (which recover misaligned FRAGMENTS) — for callers whose
+ *  own gate rejects fragments anyway (the pivot), so the O(n·W²) trim search is
+ *  paid only where its output can be used.  Byte-identical for every caller
+ *  that keeps only top-level forms. */
+export declare function recognise(ctx: MindContext, bytes: Uint8Array, trimmed?: boolean): Recognition;
 /** Segment bytes using the geometry's own groupings — leaf-parent
  *  nodes from the perceived tree, with consecutive bare leaves merged
  *  into one segment.  Each segment's gist is perceived from its bytes

package/dist/src/mind/recognition.js

@@ -22,7 +22,12 @@ import { isChunk } from "../sema.js";
  *     query's own cut cannot, and records sub-leaf boundaries as `splits`.
  *
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
-export function recognise(ctx, bytes) {
+/** Decompose `bytes` into the learnt forms it contains.  `trimmed` skips the
+ *  edge-trim fallbacks (which recover misaligned FRAGMENTS) — for callers whose
+ *  own gate rejects fragments anyway (the pivot), so the O(n·W²) trim search is
+ *  paid only where its output can be used.  Byte-identical for every caller
+ *  that keeps only top-level forms. */
+export function recognise(ctx, bytes, trimmed = false) {
     // Content-keyed memo — works for both single-turn respond() and multi-turn
     // respondTurn() (where the map persists across calls).  ALWAYS consulted,
     // regardless of tracing — matching perceive()'s own memo, which carries no
@@ -62,7 +67,7 @@ export function recognise(ctx, bytes) {
     // not silent), so it is emitted here directly rather than only inside
     // recogniseImpl.
     if (ctx.recogniseMemo) {
-        const key = latin1Key(bytes);
+        const key = (trimmed ? "t" : "f") + latin1Key(bytes);
         const hit = ctx.recogniseMemo.get(key);
         if (hit !== undefined) {
             if (ctx.meter)
@@ -74,13 +79,13 @@ export function recognise(ctx, bytes) {
                 `lead somewhere (over ${hit.leaves.length} perceived leaves) [cached]`);
             return hit;
         }
-        const fresh = recogniseImpl(ctx, bytes);
+        const fresh = recogniseImpl(ctx, bytes, trimmed);
         ctx.recogniseMemo.set(key, fresh);
         return fresh;
     }
-    return recogniseImpl(ctx, bytes);
+    return recogniseImpl(ctx, bytes, trimmed);
 }
-function recogniseImpl(ctx, bytes) {
+function recogniseImpl(ctx, bytes, trimmed = false) {
     if (ctx.meter) {
         ctx.meter.recognitions++;
         ctx.meter.recognisedBytes += bytes.length;
@@ -194,7 +199,7 @@ function recogniseImpl(ctx, bytes) {
             // n.kids !== null enforces above) rather than degenerate into
             // single-byte-atom territory, which atomIsHub already governs
             // separately.
-            else if (end - start - 1 >= 2) {
+            else if (!trimmed && end - start - 1 >= 2) {
                 // The chunk's own boundary is drawn by content geometry, not by
                 // any notion of "form" — it can include one edge byte the query's
                 // fold happened to attach here that the trained span never had

package/dist/src/mind/resonance.js

@@ -9,7 +9,7 @@ import { mergeThreshold } from "../geometry.js";
 import { concat2, concatBytes, indexOf } from "../bytes.js";
 import { gistOf, read, resolve, walkTree } from "./primitives.js";
 import { perceive } from "./primitives.js";
-import { argmaxBy, argmaxCosine, candidateGist, hubBound } from "./traverse.js";
+import { argmaxCosine, candidateGist, hubBound } from "./traverse.js";
 import { cachedRead, junctionContainers, junctionSynonyms, walkCache, } from "./junction.js";
 import { recognise } from "./recognition.js";
 // ── The bridge — the junction between two adjacent results ──────────────────
@@ -288,7 +288,13 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
         for (const c of n.kids)
             queue.push(c); // breadth-first: larger regions first
     }
-    const rec = recognise(ctx, answer);
+    // TRIMMED recognition: the pivot's own filter below rejects fragments
+    // (`hasParents || hasContainers → -Infinity`), and recognition's edge-trim
+    // fallbacks exist to find exactly those misaligned FRAGMENTS.  Skipping them
+    // (the structural pass + canonResolve still run) is byte-identical for every
+    // pivot — the fallbacks' output is discarded by the filter — and halves the
+    // O(n·W²) recognition of a long answer (measured: 36KB recognise 4.0s → 2.0s).
+    const rec = recognise(ctx, answer, true);
     for (const s of rec.sites) {
         if (!consumed.has(s.payload) && ctx.store.hasNext(s.payload)) {
             scored.set(s.payload, Math.max(scored.get(s.payload) ?? 0, 1));
@@ -296,7 +302,26 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
     }
     // Byte containment, longest wins — the answer literally contains the
     // pivot's bytes, and the biggest well-evidenced span is the real pivot.
-    const found = argmaxBy(scored.keys(), (id) => {
+    //
+    // REAL SATURATION, not a hard cap: the score IS the candidate's byte
+    // length, so the scan is DECIDED the moment the first candidate that passes
+    // every filter is found in DESCENDING length order — a shorter candidate can
+    // never outscore it.  `contentLen` (the prefix-capped length read, §2.8) is
+    // the cheap ordering key, and the first-inserted tie-break is made explicit
+    // (`a.index - b.index`) so equal lengths keep `scored`'s insertion order —
+    // exactly the tie argmaxBy(strict) used to keep.  The bytes of at most ONE
+    // winning candidate are read; every shorter candidate the probes proposed is
+    // skipped without reconstruction, where the old argmax read them all.
+    const ranked = [...scored.keys()]
+        .map((id, index) => ({
+        id,
+        index,
+        len: ctx.store.contentLen(id, answer.length + 1),
+    }))
+        .sort((a, b) => b.len - a.len || a.index - b.index);
+    let pivotId = null;
+    for (const c of ranked) {
+        const id = c.id;
         // A PIVOT MUST BE A THING THE CORPUS DEPOSITED, NOT A PIECE OF ONE.
         // "Longest wins" ranks candidates but never asks whether the winner is
         // an entity at all, and by the time a chain reaches here `consumeAll`
@@ -330,18 +355,28 @@ export async function pivotInto(ctx, answer, consumed, voiced = []) {
         // what `parents`/`containers` record.  Reasoning steps THROUGH a fact;
         // a span that was never a fact on its own is not one to step through.
         // No constant enters — it is a structural predicate, not a threshold.
-        if (ctx.store.hasParents(id) || ctx.store.hasContainers(id)) {
-            return -Infinity;
-        }
+        if (ctx.store.hasParents(id) || ctx.store.hasContainers(id))
+            continue;
+        // A candidate whose bytes are LONGER than the answer cannot be a
+        // substring of it — `indexOf` would return −1 regardless.  Prune by
+        // length BEFORE reconstructing the bytes: `read` is an UNCAPPED read
+        // (AGENTS §2.8), and a resonated context far longer than the answer is
+        // exactly the candidate that makes it cost a whole deposit's worth of
+        // reconstruction for a containment test that must fail.  `contentLen`
+        // with the `answer.length + 1` cap is the prefix-capped length read the
+        // same contract prescribes; the prune is byte-identical to the old
+        // `indexOf` miss (it returns −1 for a needle longer than the haystack).
+        if (c.len > answer.length)
+            continue;
         const bytes = read(ctx, id);
         if (indexOf(answer, bytes, 0) < 0)
-            return -Infinity;
-        for (const v of voiced)
-            if (indexOf(v, bytes, 0) >= 0)
-                return -Infinity;
-        return bytes.length;
-    }, 0, true);
-    return found?.item ?? null;
+            continue;
+        if (voiced.some((v) => indexOf(v, bytes, 0) >= 0))
+            continue;
+        pivotId = id;
+        break;
+    }
+    return pivotId;
 }
 /** Which of the given labelled forms a span MEANS — generic resonance over
  *  perceived gists.  Each anchor form's gist is memoised; the span's gist

package/dist/src/store.js

@@ -723,7 +723,28 @@ export class AbstractStore {
             parts.push(child);
             got += child.length;
         }
-        return concat(parts);
+        const out = concat(parts);
+        // Cache the BRANCH too, not just the leaf above.  Reconstruction is a pure
+        // function of the store, so this is a transparent cache in the strict sense
+        // — an eviction costs a re-walk and nothing else — which is exactly what
+        // `_bytesCache`'s "smallest"/"clock" configuration is for.
+        //
+        // Caching only leaves made every branch re-walk its whole subtree on every
+        // request, and the DAG is hash-consed, so the same children recur under many
+        // parents.  Measured on the 18.9M-node store, ONE 1,314-byte query:
+        // 20,021,474 `_prefix` calls over 469,083 distinct ids (42.7x reuse) to
+        // produce 87,789 results — 97.7% of the work re-derived bytes it had already
+        // built.  One single-byte leaf was reconstructed 2,599,984 times.  Measuring
+        // reuse at the TOP level only shows 1.1x and hides all of it.
+        //
+        // Only a COMPLETE reconstruction may be cached: `_prefix` is also called
+        // with a cap, and a truncated prefix stored under `id` would be served as
+        // if it were the node's whole content by the `_bytesCache` hit above.
+        // `got < maxLen` is that proof — the walk ran out of children before it ran
+        // out of budget, so nothing below was truncated either.
+        if (got < maxLen)
+            this._bytesCache.set(id, out);
+        return out;
     }
     contentLen(id, cap = Infinity) {
         if (this.meter)

package/jsr.json

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

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@hviana/sema",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hviana/sema.git"
+  },
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -14,7 +18,8 @@
   "scripts": {
     "build": "tsc",
     "demo": "tsc && node dist/example/demo.js",
-    "test": "tsc && node --test test/**/*.test.mjs"
+    "test": "tsc && node --test test/**/*.test.mjs",
+    "prepublishOnly": "npm test"
   },
   "license": "PolyForm-Noncommercial-1.0.0",
   "devDependencies": {

package/src/meter.ts

@@ -32,7 +32,7 @@
  *  PHASES NEST, AND ARE NOT DISJOINT.  `think` contains every mechanism
  *  phase; a mechanism's `floor` contains whatever shared analysis it
  *  first-touched (`attention`, `weave`); `recall.run` contains
- *  `substitutionBridge`, which contains `recall.exhaustiveResonate`.  Read a
+ *  `substitutionBridge`.  Read a
  *  phase as "wall-clock spent inside this, inclusive" — never sum them and
  *  expect the total.  `CostReport.elapsedMs` is the only whole.
  *
@@ -198,9 +198,6 @@ export class Meter {
   mechanismRuns = 0;
   /** Candidates the decider weighed. */
   candidates = 0;
-  /** Candidates refused before the competition for explaining less than 1/W
-   *  of the query — the honesty-density floor (see pipeline.ts `consider`). */
-  thinRejects = 0;
 
   // ── Phases ──────────────────────────────────────────────────────────────
 

package/src/mind/attention.ts

@@ -45,6 +45,7 @@ import {
 import { recognise } from "./recognition.js";
 import { leafIdRun } from "./canonical.js";
 import {
+  atomIsHub,
   corpusN,
   edgeAncestors,
   hubBound,
@@ -2647,26 +2648,28 @@ async function crossRegionVotes(
   // the same container (or a sub-container of it) twice.
   const consumed = new Set<number>();
   let probes = 0;
-  // Once atoms themselves are hubs (N > W²), the cross-region analysis gets
-  // one k·W walk allowance per evidence tier. Without a shared allowance,
-  // each of k candidate pairs spends the full corpus-derived budget and a
-  // cumulative dialogue multiplies bounded work into tens of seconds. Small
-  // corpora retain exhaustive exact traversal: below this same scale the
-  // budget would be smaller than the structures the tests deliberately build.
+  // When atoms themselves are hubs (atomIsHub — a single byte reaches ≥ √N
+  // contexts, §2.8's own predicate), the corpus is large enough that the
+  // cross-region junction walks are dominated by the drift through common
+  // content's ancestry.  Each of k candidate pairs otherwise spends its own
+  // √N·W budget (profiled: 160,210 junction pops, 31% of think at
+  // N = 325,608), and a cumulative dialogue multiplies bounded work into tens
+  // of seconds.  The structural walk is therefore given ONE k·W allowance per
+  // evidence tier, shared across every pair — k pairs × W phrase-scale levels,
+  // the minimal exact check; a pair whose container is not reached within it
+  // falls through to the resonance tier (the ANN proposes what the shallow
+  // walk no longer exhaustively scans, §2.3).
   //
-  // MEASURED 2026-07-29, NOT YET RESOLVED.  This gate never engages at real
-  // scale: on the trained store N = 325,608 with k = 24 and W = 4, so the
-  // threshold is 96³ = 884,736 and a third of a million contexts still runs
-  // unbudgeted at hubBound·W = 2,280 pops PER PAIR — 160,210 junction pops,
-  // 5.9s, 31% of think.  Sharing one hubBound·W allowance across all pairs
-  // instead cuts that to 22,418 pops and 2.6s (think −19%), but is measurably
-  // too tight below ~10³ contexts: test/36 (N = 8, budget 8) loses the
-  // `red circle` binding root and test/14 (N = 120, budget 40) recalls 39/40.
-  // The sharing is the right shape; hubBound·W is the wrong size for it, and
-  // fitting a size to those two points would repeat the mistake the cube
-  // already makes — pricing the gate on the synthetic corpora.
-  const marketScale = k * ctx.space.maxGroup;
-  const corpusScale = N > marketScale ** 3;
+  // Below atomIsHub the store is small and atoms still discriminate, so the
+  // walks keep exhaustive exact traversal (per-walk √N·W) — the shared budget
+  // would otherwise be smaller than the structures the tests deliberately
+  // build.  The gate is the SAME derived predicate the climb already uses for
+  // byte atoms, not a separate corpus-size knob: an earlier `N > (k·W)³` cube
+  // never engaged at real scale (96³ = 884,736 > 325,608), and a "share one
+  // √N·W" experiment was too tight below ~10³ contexts (test/36, test/14) —
+  // both are the same mistake of pricing the gate on corpus size instead of on
+  // the atom-hub scale.
+  const corpusScale = atomIsHub(ctx, N);
   const exactBudget = corpusScale ? { n: k * ctx.space.maxGroup } : undefined;
   const synonymBudget = corpusScale ? { n: k * ctx.space.maxGroup } : undefined;