@hviana/sema 0.8.2 → 0.8.3

package/docs/mechanisms/extraction.md

@@ -7,13 +7,13 @@ what sits between them.
 
 ## Matcher — `skillExemplar` / `isSpanShaped` / `containsSpan` (`src/mind/match.ts`)
 
-An exemplar is span-shaped when its answer is an in-order embedding of its
-context. `isSpanShaped` is the open reading (sparse subsequence, any gaps) used
-to accept candidates; `answerRunsInContext` is the strong reading (greedy
-longest contiguous runs) used to decompose the answer for projection. Candidates
-are ranked anchors from `climbAttentionAll` (`Precomputed.spanShapedOf`), tried
-in order up to `pre.k`; sub-quantum (`< W = maxGroup`) or unanchored results are
-skipped.
+An exemplar is span-shaped when its answer embeds in order. `isSpanShaped` is
+the open reading (sparse subsequence, any gaps) for acceptance; `containsSpan`
+is the strict reading (contiguous run, or a resolved node) that fusion gates on,
+extraction decomposes with `answerRunsInContext` (greedy longest runs).
+Candidates are ranked anchors from `climbAttentionAll`
+(`Precomputed.spanShapedOf`), tried up to `pre.k`; sub-quantum (`< W`) or
+unanchored results are skipped.
 
 ## Projection — read between located frames (`src/mind/mechanisms/extraction.ts`)
 

package/docs/mechanisms/recall.md

@@ -24,16 +24,15 @@ W = `maxGroup` (river window); bars from `src/geometry.ts`.
 ## Echo — the refusing tail
 
 If no tier grounded, the exact cosine of the top hit is re-folded (`gistOf` on
-its bytes). Decision uses that exact value in the same query-relative,
-chance-corrected fraction — never the RaBitQ estimate. Below `reach` → silence;
-restating → silence; otherwise the hit's own bytes are returned as an ungrounded
-echo.
+its bytes). It uses that exact value in the same chance-corrected fraction —
+never the RaBitQ estimate. Below `reach` → silence; restating → silence;
+otherwise the hit's own bytes are returned as an ungrounded echo.
 
 ## Provenance
 
 Grounded answers carry `recall`; the echo carries `recall-echo` (`echoed: true`
-on `RecallResult`). Consumers distinguish a continuation through learned edges
-from a near-identity echo.
+on `RecallResult`); it declares `used: ∅`. Consumers distinguish a continuation
+through learned edges from a near-identity echo.
 
 ## Substitution bridge — refusal-path only (`src/mind/bridge.ts`)
 
@@ -47,13 +46,13 @@ unanimous, and the raw gap is length-balanced. Coverage must dominate the query
 and no dismissed gap may hide known content (`dismissedKnownContent` gate). Cost
 is `CONCEPT` per substitution plus `STEP`; accounted spans include matched and
 substituted ranges (so a 28/29-byte paraphrase is not charged `PASS` per
-substituted byte — observed double-charge that let `cast` outbid the bridge).
+substituted byte — the double-charge that let `cast` outbid the bridge).
 Zero-substitution identity bridges carry `complete: true` (the whole read-out);
 substituted bridges do not.
 
-Scaffolding-only queries abstain: when every stored window that could anchor is
+Scaffolding-only queries abstain: when every window that could anchor is
 saturated (corpus-global scaffolding, `allWindowsAreScaffolding`), the bridge
-returns nothing — a single substituted word cannot carry the semantic load.
+returns nothing — one substituted word cannot carry the load.
 
 ## Cost
 

package/jsr.json

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

package/package.json

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

package/src/alu/README.md

@@ -8,10 +8,10 @@ a truth value) are declared here once.
 
 It joins the mind as a `PipelineMechanism`
 ([`../mind/pipeline-mechanism.ts`](../mind/pipeline-mechanism.ts)) whose only
-special role is the optional `parse(query)` method every mechanism may
-implement. The mind knows nothing about what the ALU computes; it only knows
-that `parse` returns `ComputedSpan[]`, which enter the one lightest-derivation
-search as authoritative axioms (at `STEP` cost, like a learned edge).
+special role is the optional `parse(query)` every mechanism may implement. The
+mind knows nothing about what the ALU computes; it only knows that `parse`
+returns `ComputedSpan[]`, which enter the one lightest-derivation search as
+authoritative axioms (at `STEP`, like a learned edge).
 
 It has no dependency on the rest of the codebase except the pure byte helpers in
 `../bytes.ts`, and is intended to be reused as a self-contained sublibrary in
@@ -166,7 +166,7 @@ The ALU is completely decoupled from Sema. It joins the mind through
 re-exported from [`../mind/pipeline.ts`](../mind/pipeline.ts)), a thin adapter
 that wraps the ALU's `parse` in a `PipelineMechanism` — the same uniform
 interface every grounding mechanism (CAST, confluence, cover, extraction,
-recall) implements, so nothing about the ALU is special-cased in the pipeline.
+recall) implements, so nothing about the ALU is special-cased.
 
 ### The contract
 
@@ -175,7 +175,7 @@ recall) implements, so nothing about the ALU is special-cased in the pipeline.
 ```ts
 interface PipelineMechanism {
   parse?(query: Uint8Array): Promise<ComputedSpan[]>;
-  floor(ctx, query, pre): Promise<number | null>;
+  floor(ctx, query, pre, worthRunning): Promise<number | null>;
   run(ctx, query, pre): Promise<MechanismResult[]>;
 }
 ```
@@ -259,7 +259,7 @@ whose span overlaps a computed span is **masked** before the search. This is the
 the computed `4` is the cover's sole completion there. The search itself stays a
 neutral cost engine (a computed `Out` and a learned edge both cost `STEP`);
 precedence lives entirely in the masking step, which is in
-`src/mind/pipeline.ts`, not in the search and not in the ALU.
+`src/mind/mechanisms/cover.ts`, not in the search and not in the ALU.
 
 A computation and an _unrelated_ rewrite still compose in one answer
 (`"ice 2+2"` → `"cold 4"`) because the masking is scoped to the colliding span
@@ -302,11 +302,10 @@ registry.derive("hypot", 2, ["hypot"], (args, ctx) =>
   ]));
 ```
 
-No kernel edit, no graph-search edit, no resonance edit — name it, list its
-surface forms, write the body in terms of existing ops. A scalar op broadcasts
-over `nd` automatically; pass `structural = true` (the trailing flag on
-`prim`/`derive`) only for an op that consumes a list _whole_, like the `nd`
-kernel's own.
+No kernel, graph-search or resonance edit — name it, list its surface forms,
+write the body from existing ops. A scalar op broadcasts over `nd`
+automatically; pass `structural = true` (the trailing flag on `prim`/`derive`)
+only for an op that consumes a list _whole_, like the `nd` kernel's own.
 
 ## Layout
 

package/src/config.ts

@@ -116,6 +116,17 @@ export interface MindConfig {
   seed: number;
   recallQueryK: number;
   haloQueryK: number;
+  /** Branch nodes the pivot sweep may PROBE looking for the learnt context an
+   *  answer contains — the pivot's own shortlist capacity, separate from
+   *  `recallQueryK` because they are different quantities: this one bounds a
+   *  MECHANICAL sweep over the answer's tree (breadth-first, largest regions
+   *  first, so an exhausted allowance drops the far ones and never the near
+   *  ones), while `recallQueryK` bounds the bridge's candidate reads.  Sharing
+   *  one number for both meant that tightening either silently starved the
+   *  other — measured: at `recallQueryK: 1` the pivot cannot find a pivot at
+   *  all.  (`rationaleSampleK` was split out of `recallQueryK` for the same
+   *  reason, found by an adversarial review.) */
+  pivotProbeK: number;
   /** Corpus reading (see src/mind/corpus.ts): results per call, resolved
    *  nodes climbed from, contexts requested per climb, probes used to stride
    *  the id space when browsing, bytes of each side a preview keeps, and the
@@ -148,6 +159,7 @@ export const DEFAULT_CONFIG: MindConfig = {
   seed: 42,
   recallQueryK: 12,
   haloQueryK: 12,
+  pivotProbeK: 12,
   rationaleSampleK: 12,
   corpusLimitMax: 24,
   corpusClimbs: 24,
@@ -196,6 +208,7 @@ export function resolveConfig(opts: Partial<MindConfig> = {}): MindConfig {
     seed: opts.seed ?? DEFAULT_CONFIG.seed,
     recallQueryK: opts.recallQueryK ?? DEFAULT_CONFIG.recallQueryK,
     haloQueryK: opts.haloQueryK ?? DEFAULT_CONFIG.haloQueryK,
+    pivotProbeK: opts.pivotProbeK ?? DEFAULT_CONFIG.pivotProbeK,
     rationaleSampleK: opts.rationaleSampleK ?? DEFAULT_CONFIG.rationaleSampleK,
     corpusLimitMax: opts.corpusLimitMax ?? DEFAULT_CONFIG.corpusLimitMax,
     corpusClimbs: opts.corpusClimbs ?? DEFAULT_CONFIG.corpusClimbs,

package/src/geometry.ts

@@ -155,6 +155,27 @@ export function profileCapacity(D: number): number {
   return Math.max(1, Math.floor(Math.sqrt(D)));
 }
 
+/**
+ *  The POOLED-vote significance floor, and the derivation lives here because
+ *  its PREMISE is a property of the caller's weighting.
+ *
+ *  DERIVATION (docs/architecture/thresholds.md §2): a maximally-specific region
+ *  contributes at most `ln N` to a pooled vote, so `ln(N) + 1/2` sits half a
+ *  unit above ONE region's ceiling — it demands corroboration BEYOND a single
+ *  region, which is what makes it a consensus bar rather than a resonance bar.
+ *
+ *  PREMISE: that per-region ceiling is an IDF, `ln(N/c)` — attention.ts's
+ *  `inverse` mode, the mode every non-test caller runs.  The other two modes
+ *  weight a region by `ln(1+c)` (`direct`) or `ln(N/c) + ln(1+c)` (`combined`),
+ *  i.e. `ln N + ln(1 + 1/c)`, so they exceed the premise's ceiling by at most
+ *  `ln 2` — a DERIVED bound, not a hole: the floor stays within `ln 2` of its
+ *  own premise in every mode, and exactly on it in `inverse`.
+ *
+ *  MEASURED: the floor is read on the pooled vote (`commitVotes`, `recall`,
+ *  `cast`).  Across 27 anchors on 6 queries, 11 cleared it by the sum and NONE
+ *  by a single region's peak — gating on one region would refuse every elected
+ *  root.
+ */
 export function consensusFloor(N: number): number {
   return Math.log(N) + 1 / 2;
 }

package/src/meter.ts

@@ -223,6 +223,12 @@ export class Meter {
   joinNoKey = 0;
   /** Refused: the fact contains no entity that leads anywhere. */
   joinNoEntity = 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
+   *  happened, so "the recursion stopped" and "the recursion never ran" were
+   *  indistinguishable from the counters alone. */
+  recompletes = 0;
 
   // ── Mind: the multi-hop pivot (EXTENSION) ───────────────────────────────
   //
@@ -233,6 +239,51 @@ export class Meter {
   /** Times the reasoner pivoted on a span its answer contains and stepped
    *  across that fact. */
   pivotSteps = 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
+   *  is deliberately unbudgeted, so this counter says exactly when the expensive
+   *  route was priced out.  Counted where the fact happens (the `!canonBudget`
+   *  refusal), not where the probe is called. */
+  canonProbesDenied = 0;
+  /** The pipeline's remainder AT THE DECISION POINT, in bytes: what the grounded
+   *  answer plus the pre-computed spans left unexplained, after the same W floor
+   *  the fuse gate uses.  This is the quantity that licenses (or refuses) the
+   *  post-grounding extension and the fusion — it was computed, used, and never
+   *  published, so nothing could measure what a search had LEFT when it decided.
+   *  Read with {@link postGroundingRemainderSpans}. */
+  postGroundingRemainderBytes = 0;
+  /** How many spans that remainder consists of (each at least one W window). */
+  postGroundingRemainderSpans = 0;
+  /** Times `fuseAttention` produced a FUSED answer — not times it was called.
+   *  It is entered whenever the query has a remainder ≥ W and returns early when
+   *  there is nothing to bridge (`containsSpan`, a lone root, an empty pass), so
+   *  the call and the fact are different things and only the fact is counted.
+   *  Its own rationale step reports the fusion; this is the untraced view, and
+   *  its cost is one bridging edge: `fuseRuns · STEP`. */
+  fuseRuns = 0;
+  /** Steps the post-grounding EXTENSION took — pivots plus forward-absorbs.
+   *  `pivotSteps` counts only the former, so before this the extension's COST was
+   *  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. */
+  reasonCarriedBytes = 0;
+  /** Branch-node probes the pivot sweep actually spent looking for the learnt
+   *  context an answer contains (one `resonate` per probe).  The untraced view
+   *  of what the multi-hop's shortlist costs. */
+  pivotProbes = 0;
+  /** Branch nodes the pivot's probe cap withheld (`branchCount − probeCap`, over
+   *  every call).  A capacity fact, not a verdict: the sweep is breadth-first,
+   *  so the probes it DOES spend are the largest regions, and recognition still
+   *  contributes every exact containment candidate regardless of the budget.
+   *  Read it with {@link pivotProbes} — one says the work, the other the
+   *  shortfall. */
+  pivotBranchesUnprobed = 0;
 
   // ── Mind: the cover's connector assembly (LIMIT) ────────────────────────
   //

package/src/mind/attention.ts

@@ -180,6 +180,10 @@ export interface ConsensusAnchorTrace {
 
   pooledVote: number;
   idfVote: number;
+  /** The LARGEST single-region contribution behind this anchor — the bar
+   *  recall's own gate reads (mechanisms/recall.ts).  Published so the one
+   *  decision-making quantity the climb computes is not invisible. */
+  peak: number;
 
   candidateBreadth: number;
   contributingVotes: number;
@@ -1243,15 +1247,18 @@ export async function voteRegions(
       }
       contrastiveMargin = margin;
       // Scaled by what this region does NOT address — see `cov` above.
-      const noiseFloor = estimatorNoise(ctx.store.D) * (1 - cov);
-      if (margin <= noiseFloor) {
+      // The bar THIS gate applies: the estimator's noise scaled by what the
+      // region does NOT address (`cov`).  ONE definition, used by the rejection
+      // path below and by the voted payload — the trace reports the applied bar.
+      const appliedFloor = estimatorNoise(ctx.store.D) * (1 - cov);
+      if (margin <= appliedFloor) {
         recordRegion("contrastive-margin-rejection", {
           selected,
           reachNode: voterId,
           idf,
           dfWeight: wf,
           contrastiveMargin: margin,
-          contrastiveNoiseFloor: noiseFloor,
+          contrastiveNoiseFloor: appliedFloor,
           ...(contrastiveRival ? { contrastiveRival } : {}),
         });
         continue;
@@ -1305,7 +1312,12 @@ export async function voteRegions(
       ...(contrastiveMargin !== undefined
         ? {
           contrastiveMargin,
-          contrastiveNoiseFloor: estimatorNoise(ctx.store.D),
+          // THE BAR THE GATE ACTUALLY APPLIED — the same expression
+          // the rejection path's `appliedFloor` defines, inline here because
+          // this payload is built in a scope that does not carry that local.
+          // Publishing the raw estimatorNoise(D) instead made a region that
+          // PASSED look closer to its limit than it was.
+          contrastiveNoiseFloor: estimatorNoise(ctx.store.D) * (1 - cov),
           ...(contrastiveRival ? { contrastiveRival } : {}),
         }
         : {}),
@@ -1438,7 +1450,15 @@ export function poolVotes(
     },
     pool,
   };
-  lightestDerivation(system);
+  // THE SEARCH WAS THE ONE LAYER WITH NO TIME.  The climb's phases are timed
+  // (voteRegions, structuralResonance, crossRegion) but the pooled derivation
+  // was not, so any cost or gain inside it stayed invisible.
+  // `timeSync`, not `time`: the search is SYNCHRONOUS, and wrapping it in a
+  // promise only to time it would make the profiled path wait where the
+  // unprofiled one does not (meter.ts's own contract).
+  if (ctx.meter) {
+    ctx.meter.timeSync("climb.derivation", () => lightestDerivation(system));
+  } else lightestDerivation(system);
 
   const votes = new Map<number, number>();
   const votesIdf = new Map<number, number>();
@@ -1476,12 +1496,24 @@ export function poolVotes(
   // The LARGEST single region's contribution to this anchor's pooled vote.
   // The pool is a SUM (deliberately — see the pooling note above), so it says
   // how much evidence there is in total, never whether any ONE place in the
-  // query carries evidence on its own.  Consumers that hold an anchor to
-  // consensusFloor(N) = ln(N) + 1/2 need the latter: that bar prices ONE
-  // region's maximally-discriminative evidence (ln N is the IDF of content
-  // reaching a single context), so comparing a six-region sum against it is a
-  // dimensional error.  Recorded here, beside the count, because this is the
-  // only place the per-region contributions are still separable.
+  // query carries evidence on its own.  Recorded here, beside the count,
+  // because this is the only place the per-region contributions are still
+  // separable.
+  //
+  // THE BAR IS THE POOLED FLOOR, AND IT WAS ONCE CLAIMED OTHERWISE HERE.
+  // This comment used to say that holding an anchor to consensusFloor(N)
+  // "prices ONE region's evidence", so comparing a six-region sum against it
+  // was "a dimensional error".  THAT WAS FALSE.  `thresholds.md` §2 derives
+  // `consensusFloor` as the POOLED-vote significance floor ("each region
+  // contributes at most ln(N/c) <= ln(N); ln(N) + 1/2 demands ..."), and the
+  // climb weights by IDF, so the sum and the floor are in ONE dimension —
+  // which is exactly why `recall.ts` gates `forest[0].idfVote` against it and
+  // why `commitVotes` does too.  The other two weighting modes DO leave that
+  // dimension (by at most ln 2, two-sided: `direct` deflates a region and
+  // `combined` inflates it), and the gates therefore read the IDF sum, which
+  // is mode-independent; `test/55` tests 19 and 20 pin both halves — the sum
+  // as the reading the bar is derived for, and the absence of any gate
+  // inversion across the three modes.
   const regionPeak = new Map<number, number>();
   const steps: DerivationStep[] = [];
   let order = 0;
@@ -1665,6 +1697,7 @@ export function commitVotes(
         anchor,
         vote,
         peak: regionPeak.get(anchor) ?? 0,
+        idfVote: votesIdf.get(anchor) ?? 0,
         start: s.start,
         end: s.end,
         breadth: (regionSupport.get(anchor) ?? 0) / totalRegions,
@@ -1674,6 +1707,16 @@ export function commitVotes(
         ),
       };
     })
+    // THE ORDER IS NOT A PREFERENCE: with equal evidence it decides ADMISSION,
+    // through the stable sort and the first-come overlap absorption below.
+    // Measured on test/34's corpus, query "red": the two candidates (`red
+    // circle` and `red square`) carry IDENTICAL `vote` and IDENTICAL `idfVote`
+    // (1.3863 each, three seeds), so this comparator leaves them tied and the
+    // stable sort keeps the ENUMERATION order — which is corpus-determined and
+    // admits `red square`, 60/60 seeds.  Adding an id tie-break (`|| a.anchor -
+    // b.anchor`) picks `red circle` instead and makes a single region reach the
+    // JOINT context, which is the premise `test/34` exists to protect.  The
+    // gates read IDF; this line only decides who gets looked at first.
     .sort((a, b) => b.vote - a.vote);
   const overlaps = (a: Attention, b: Attention) =>
     a.start < b.end && b.start < a.end;
@@ -1719,6 +1762,13 @@ export function commitVotes(
       rank,
       pooledVote: point.vote,
       idfVote: votesIdf.get(point.anchor) ?? 0,
+      // The LARGEST single-region contribution behind this anchor — the bar
+      // recall's own gate reads (mechanisms/recall.ts: forest[0].peak > LN2),
+      // and until now the only decision-making quantity the climb computed and
+      // did not publish.  `regionPeak` reached `ranked` (see its build below)
+      // and stopped there.  Published, not recomputed: the value is the one the
+      // climb already carries.
+      peak: point.peak,
       candidateBreadth: regions.length,
       contributingVotes: regionAxioms.get(point.anchor) ?? 0,
       contributingEvidence: regionSupport.get(point.anchor) ?? 0,
@@ -1748,6 +1798,18 @@ export function commitVotes(
     let passesConsensusFloor: boolean | undefined;
     let pastLeadingSaturation: boolean | undefined;
     let tiedWithDominant: boolean | undefined;
+    // ── ONE OF THREE ADMISSIONS, AND THEY ARE NOT THE SAME READING ────────
+    // This block admits by VOTES: per-region evidence pooled, gated on the
+    // natural break and on consensusFloor, with the dominant allowed to bypass
+    // both.  `structuralResonance` admits by a MARGIN over the estimator's own
+    // noise, and `crossRegionVotes` admits by STRUCTURE (which regions may pair
+    // at all, with at least one side individually discriminative).  Read
+    // together they look like one policy written three times; they are three
+    // different measurements of the same question ("is this evidence?"), and
+    // unifying them would average three readings into one — the mistake
+    // `extraction.ts` records as "do not unify the two into one machine".
+    // What they DO share, and must keep sharing, is the discipline of deriving
+    // every bar from D/W/N rather than choosing it (thresholds.md).
     const rejectionReasons: AnchorRejectionReason[] = [];
     if (absorbed) {
       status = "overlap";
@@ -1757,9 +1819,75 @@ export function commitVotes(
       pastLeadingSaturation = pastLeading;
       const vote = votesIdf.get(point.anchor) ?? 0;
       if (roots.length === 0) {
-        // The first non-overlapping root is DOMINANT and bypasses the two
-        // vote thresholds (it always grounds) — only the leading-saturation
-        // gate still applies to it.
+        // THE DOMINANCE PRIVILEGE, AND THE TENSION IT CARRIES (measured).
+        //
+        // The first non-overlapping candidate is DOMINANT: it bypasses both
+        // vote gates below and grounds on its own; only the leading-saturation
+        // gate still applies to it.  The privilege is load-bearing — analogies,
+        // substitutions and composed contexts are precisely candidates the
+        // query does NOT contain, and the engine loses them without it.
+        //
+        // WHICH candidate receives it, though, is decided by this loop's ORDER.
+        // That order comes from `ranked`, and when two candidates carry equal
+        // evidence the stable sort preserves the ENUMERATION order, so the
+        // privilege is allocated by an ordering rather than by a rule.
+        //
+        // Measured on test/34's corpus, query "red":
+        //
+        //   0:#77 vote=1.3863 idf=1.3863 [0,3) | 1:#49 vote=1.3863 idf=1.3863 [0,3)
+        //
+        // Both candidates (`red square` #77, `red circle` #49) have IDENTICAL
+        // `vote` AND IDENTICAL `idfVote` over the SAME support span, so the
+        // comparator leaves them tied, the second is absorbed as "overlap", and
+        // the first grounds.  With this build's enumeration order that first is
+        // `red square`, 60/60 seeds, and `red circle` — the JOINT context — is
+        // never reached by "red" alone.  That is the premise test/34 exists to
+        // protect: no single region reaches the joint context, which is what
+        // makes the binding query unreachable without direct region
+        // interaction.
+        //
+        // THE TENSION: the premise therefore holds BY ENUMERATION ORDER, not by
+        // a rule, so any change to this ordering can move the privilege onto the
+        // joint context and let one region reach it.  Measured: adding
+        // `|| a.anchor - b.anchor` — the lowest-id tie-break that AGENTS.md §2
+        // sanctions as an equivalent corpus-determined tie-break — does exactly
+        // that: "red" then attends to `red circle`, test/34 fails 6/1, and the
+        // canonical suite reports 1 failure.
+        //
+        // TWO ATTEMPTS TO MAKE IT A RULE, BOTH REFUTED BY MEASUREMENT:
+        //
+        //  1. EVIDENCE SEPARATION.  Grant the privilege only when the first
+        //     candidate's evidence is separated from the next distinct
+        //     candidate's by more than the co-dominant band (sqrt(k) *
+        //     estimatorNoise(D)).  Refuted: that band exists to ADMIT the
+        //     anchors the estimator cannot separate from the dominant — its own
+        //     documented purpose — so withholding the privilege on ties removes
+        //     the very case it was written for.  Suite: 4 failures (the two
+        //     co-dominant band laws, breadth/scale invariance, test/29 D2).
+        //
+        //  2. QUERY-OWNED CONTENT.  Grant the privilege only to a candidate
+        //     that IS a recognised region's identity (regions.some(r => r.id ===
+        //     point.anchor)).  Measured: for "circle" that identity IS the
+        //     ranked candidate, so the privilege stays and `circle` grounds; for
+        //     "red" the identity is the `red` node itself while the candidates
+        //     are the conjunctions, so neither is privileged; for "red then
+        //     circle" the composed context carries idf 3.958 and clears both
+        //     gates on its own evidence.  All four control queries came out
+        //     right — and the suite: 10 failures, six of them in the
+        //     analogy/counterfactual/CAST suites ("an analogy still transfers
+        //     from a structure the query never names"; "a substitute the query
+        //     NAMES may still be voiced").  Refuted: the privilege exists to
+        //     admit what the query does NOT contain, so identity is the wrong
+        //     axis.
+        //
+        // WHAT A FUTURE ATTEMPT MUST RESPECT: whatever allocates this privilege
+        // has to (a) keep it available to candidates the query does not contain
+        // — analogies, substitutions, compositions — and (b) not depend on the
+        // estimator's ordering among anchors of equal evidence, because that
+        // ordering is not a fact about the corpus.  No lever satisfying both has
+        // been found.  Until one is, this premise rests on the enumeration order
+        // recorded above, and test/34 is the only test that notices if it
+        // moves.
         dominant = true;
         if (pastLeading) {
           status = "root";
@@ -1768,8 +1896,15 @@ export function commitVotes(
           rejectionReasons.push("leading-saturation");
         }
       } else {
-        passesNaturalBreak = vote >= rootCut;
-        passesConsensusFloor = vote >= floor;
+        // THE FLOOR AND THE BREAK READ THE IDF WEIGHTING.  `floor` is derived
+        // for pooled IDF-weighted votes, and `rootCut` comes from the IDF
+        // distribution (`idfDesc`), so gating the mode-dependent `vote` against
+        // either let a weighting mode change an admission (measured: anchor 87,
+        // inverse 2.682 admitted vs direct 1.468 refused).  Reading the IDF sum
+        // makes the verdict mode-independent, and changes nothing in the
+        // engine's own mode, where the two readings coincide.
+        passesNaturalBreak = point.idfVote >= rootCut;
+        passesConsensusFloor = point.idfVote >= floor;
         // CO-DOMINANT — an anchor the estimator cannot separate from the
         // dominant inherits the dominant's exemption, because that exemption's
         // only warrant is being TOP, and "top" is not a fact about the corpus
@@ -2467,6 +2602,13 @@ export async function structuralResonance(
     });
   };
 
+  // ── ADMISSION BY MARGIN, not by votes (see voteRegions' note) ─────────
+  // What this site measures: how far the best ANN proposal's effective score
+  // (score × semanticConfidence) stands above the runner-up's, against
+  // `estimatorNoise(D)`.  What it does NOT measure: how many regions voted,
+  // or whether the query's regions agree — that is voteRegions' question, and
+  // here a synthetic gist has already replaced them.  The two bars are both
+  // derived (thresholds.md), and neither is a tuning of the other.
   let selected: StructuralResonanceProposal | null = null;
   let selectedReach: AncestorReach | null = null;
   let selectedIdf = 0;
@@ -2582,6 +2724,15 @@ async function crossRegionVotes(
   // successfully reconstructed while probing one pair must not be read and
   // perceived again while probing another pair in the same climb.
   const siblingGistMemo = new Map<number, CachedSiblingGist>();
+  // ── ADMISSION BY STRUCTURE, not by a bar (see voteRegions' note) ──────
+  // What this site decides: WHICH regions may pair at all — a region that
+  // already voted (individually discriminative), or a KNOWN non-voting one as
+  // the weak side of a pair whose other side voted; never two non-voting
+  // regions, and never a span contained in a maximal one whose reading is
+  // exact.  The bar (the container's idf) comes later, on the candidate.  So
+  // its "rejection reasons" name structural disqualifications — a different
+  // vocabulary because it answers a different question, and the three
+  // taxonomies stay separate for the same reason the readings do.
   const votedSpans = new Set<string>();
   for (const rv of rvs.votes) votedSpans.add(`${rv.start},${rv.end}`);
   const seen = new Set<string>();

package/src/mind/canonical.ts

@@ -88,6 +88,49 @@ export function leafIdPrefix(
   return ids;
 }
 
+/** Which prefixes of `prefix ‖ tail` are STORED NODES — as lengths in the
+ *  tail's own coordinates, ascending, excluding the empty one.  This is the
+ *  candidate set a rule needs to join an already-stored prefix to a suffix it
+ *  has not stored: a key names a relation exactly when `prefix ‖ tail[0..p]` IS
+ *  a node, and a key can end strictly inside the tail without sitting on any
+ *  fold boundary (a stored member's end is the end of ITS OWN stream, and the
+ *  fold never emits a cut at a stream's end).  Measured: "stockholm mayor"
+ *  exists, leads on, and its boundary 6 is in neither the tail's cuts nor the
+ *  concatenation's.
+ *
+ *  ONE cheap content-addressed probe per offset — `leafIdPrefix` walks the bytes
+ *  once (a point probe each), `findBranch` hashes the growing kid run — and NO
+ *  `resolve`, which is what keeps this off the O(suffix) vector folds the
+ *  recognition path pays.  It stops at the first byte that was never interned,
+ *  which costs nothing real: a stored key's bytes are interned by construction. */
+export function keyEnds(
+  ctx: MindContext,
+  prefix: Uint8Array,
+  tail: Uint8Array,
+): number[] {
+  if (prefix.length === 0 || tail.length === 0) return [];
+  const joined = new Uint8Array(prefix.length + tail.length);
+  joined.set(prefix, 0);
+  joined.set(tail, prefix.length);
+  const ids = leafIdPrefix(ctx, joined);
+  if (ids.length < prefix.length) return [];
+  const ends: number[] = [];
+  // The kid run GROWS by one id per offset; `findBranch` wants an array, so the
+  // run is built once and pushed into, never re-sliced.  Re-slicing
+  // `ids.slice(0, prefix.length + p)` per offset made this O(|tail| ·
+  // (|prefix| + |tail|)) — quadratic in the tail, where the learning path this
+  // follows slices a run that SHRINKS.  Same ends, linear copying.
+  const run = ids.slice(0, prefix.length);
+  // The loop ENDS at the first byte that was never interned (`ids.length`):
+  // every later prefix contains it, so none of them can be a node either — this
+  // is where the scan stops, not a silent truncation of the answer.
+  for (let p = 1; prefix.length + p <= ids.length; p++) {
+    run.push(ids[prefix.length + p - 1]);
+    if (ctx.store.findBranch(run) !== null) ends.push(p);
+  }
+  return ends;
+}
+
 /** The canonical W-window node ids of a byte stream, offset → id — the
  *  CONTENT-ADDRESSED IDENTITY of every W-sized slice, under which any content
  *  two deposits share IS the same node (hash-consing paid the comparison at