@hviana/sema 0.8.1 → 0.8.3

package/AGENTS.md

@@ -2,8 +2,8 @@
 
 The working manual for anyone (human or AI agent) changing Sema. For pattern
 detail, see `docs/INDEX.md` → `docs/architecture/*.md`. You should be able to
-develop against this document and docs/ alone; read the theory in
-`docs/architecture/` when you need why a pattern holds, not to get work done.
+develop against this document and docs/ alone; read `docs/architecture/` for why
+a pattern holds.
 
 ## 1. Orientation
 
@@ -14,7 +14,7 @@ accelerators), and a cost-based search that composes answers from stored facts
 the only runtime dependency.
 
 ```bash
-npm install        # dev tooling + parquet reader used by one example
+npm install        # dev tooling + parquet reader for one example
 npm run build      # tsc → dist/
 npm test           # tsc && node --test test/**/*.test.mjs
 npm run demo       # example/demo.ts — the four-note README demo
@@ -62,6 +62,7 @@ shared content-addressed ascent; `Precomputed` in
 `src/mind/pipeline-mechanism.ts` is the per-response lazy memo; `src/meter.ts`
 is the write-only work accounting surface. See `docs/INDEX.md` for the full
 contract table and `docs/architecture/factored-machinery.md` for ownership.
+Tie-breaks are corpus-determined, but not interchangeable (`determinism.md`).
 
 ## 3. Where things live
 
@@ -89,7 +90,7 @@ contract table and `docs/architecture/factored-machinery.md` for ownership.
 | Sublibraries (own READMEs)           | `src/derive/`, `src/alu/`, `src/rabitq-ivf/`                                                       |
 
 Mind functions are free functions over `MindContext` (`src/mind/types.ts`), not
-methods — `mind.ts` is a thin assembly that delegates.
+methods; `mind.ts` is a thin assembly.
 
 ## 4. Recipes
 
@@ -97,7 +98,7 @@ methods — `mind.ts` is a thin assembly that delegates.
 
 Implement `PipelineMechanism` (`floor` → admissible bound or `null`; `run` →
 candidates with `bytes`/`accounted`/`moves`/`unexplained` + optional
-`scaffolding`/`complete`). Register via
+`scaffolding`/`complete`/`used`). Register via
 `new Mind({ mechanismFactories: [host => yourMechanism(host)] })`. Verify the
 four market constraints (decoupled, declared competence, visible budget,
 evidence travels). → `docs/architecture/mechanism-market.md`
@@ -125,14 +126,13 @@ Run the full suite with your store substituted. → `docs/architecture/store.md`
 ## 5. Testing norms
 
 Tests are `node:test` suites in `test/*.test.mjs`, numbered by theme, run
-against built `dist/` (`npm test`; single suite:
-`node --test test/22-multihop.test.mjs` after `tsc`). New behaviour ⇒ test in
-the matching numbered suite or a new one. Many tests pin contracts that look
-like implementation details (ladder order, span-shape readings,
-`MechanismResult.complete`, fold invariance, recognition idempotence, honest
-silence). A simplification that fails an existing test is wrong until the test
-is proven wrong. Sublibraries test themselves in
-`src/{alu,derive,rabitq-ivf}/test/` with zero Sema dependency.
+against built `dist/` (`npm test`; one suite:
+`node --test test/22-multihop.test.mjs`). New behaviour ⇒ a test in the matching
+numbered suite. Many tests pin contracts that look like implementation details
+(ladder order, span-shape readings, `MechanismResult.complete`, fold invariance,
+recognition idempotence, honest silence). A simplification that fails an
+existing test is wrong until the test is proven wrong. Sublibraries test
+themselves in `src/{alu,derive,rabitq-ivf}/test/` with zero Sema dependency.
 
 ## 6. Instrumentation — the meter and the rationale ARE the dev surface
 
@@ -143,17 +143,17 @@ instrumentation, and the only ones. Both are read through the public path —
 and the `inspectRationale` callback on `respond`/`respondText`/`respondTurn`.
 
 When a change needs to be seen, measured, or proved, EXTEND THEM: a counter in
-`meter.ts` (the one place a counter name exists — keep its four contracts true),
-a step or note where the mechanism emits it (`src/mind/trace.ts` holds the move
-vocabulary). A gap in instrumentation is a defect IN the instrumentation: close
-it there, once, so the next person sees it too. Never add a parallel channel for
-a single investigation — no ad-hoc logging or timing probes left in `src/`
-(`performance.now()` belongs in `meter.ts`, not at a call site), no private
-per-layer counter where a `meter.ts` field belongs, and no trace channel of your
-own: a callback threaded through a call chain must FEED the rationale, the way
-`GraphSearch`'s `onDerivation` feeds `traceDerivation`. (`store.ts`'s
-`danglingReads`/`compactFailures` and the `console.warn`s that report them
-predate this and stay: session-lifetime HEALTH counters, not per-response work.)
+`meter.ts` (the one place a counter name exists), a step or note where the
+mechanism emits it (`src/mind/trace.ts` holds the move vocabulary). A gap in
+instrumentation is a defect IN the instrumentation: close it there, once, so the
+next person sees it too. Never add a parallel channel for a single investigation
+— no ad-hoc logging or timing probes left in `src/` (`performance.now()` belongs
+in `meter.ts`, not at a call site), no private per-layer counter where a
+`meter.ts` field belongs, and no trace channel of your own: a callback threaded
+through a call chain must FEED the rationale, the way `GraphSearch`'s
+`onDerivation` feeds `traceDerivation`. (`store.ts`'s
+`danglingReads`/`compactFailures` and the `console.warn`s that report them stay:
+session-lifetime HEALTH counters, not per-response work.)
 
 ## 7. Dependencies and licensing
 
@@ -161,8 +161,8 @@ PolyForm Noncommercial 1.0.0 with separate commercial licensing (see
 `LICENSE.md`, `COMMERCIAL-LICENSE.md`, `TRADEMARKS.md`). The library has **no
 runtime dependencies** — pinned by `test/88-dependency-footprint.test.mjs`
 (`dist/src` may import only `node:` builtins and relative paths; `package.json`
-has no `dependencies`). Examples may use dev dependencies lazily via dynamic
-import only on the code path that needs them (`example/train_base` + `hyparquet`
-is the reference). Training corpora: a store retains text verbatim, so upstream
-licences apply in full — NonCommercial and ShareAlike corpora cannot enter a
-trainer; see `DATASETS.md`.
+has no `dependencies`). Examples may use dev dependencies via dynamic import
+only where needed (`example/train_base` + `hyparquet` is the reference).
+Training corpora: a store retains text verbatim, so upstream licences apply in
+full — NonCommercial and ShareAlike corpora cannot enter a trainer; see
+`DATASETS.md`.

package/TRADEMARKS.md

@@ -6,7 +6,6 @@ The following are not licensed under the software license:
 
 - redistribute its algorithmic logic: that is, how algorithms and mathematical
   techniques are combined to develop its machinery;
-- visual identity;
 - project name;
 - logos;
 - icons;

package/dist/src/config.d.ts

@@ -100,6 +100,34 @@ 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
+     *  smallest deposited note browsing will show.  Capacities and budgets only —
+     *  the one material floor (a resolved node must account for W bytes) is
+     *  derived from the geometry, not declared here. */
+    corpusLimitMax: number;
+    corpusClimbs: number;
+    corpusContextsPerClimb: number;
+    corpusSampleProbes: number;
+    corpusPreviewBytes: number;
+    corpusSampleFloorBytes: number;
+    /** Items one rationale step may ITEMISE (the whole field is still counted in
+     *  the step's note).  A capacity of the rationale, not of recall: sharing
+     *  `recallQueryK` meant `new Mind({recallQueryK: 100000})` un-bounded the very
+     *  payload the bound exists for (found by an adversarial review). */
+    rationaleSampleK: number;
     normalizeEpsilon: number;
     cosineEpsilon: number;
     alu: AluConfig;

package/dist/src/config.js

@@ -5,6 +5,14 @@ export const DEFAULT_CONFIG = {
     seed: 42,
     recallQueryK: 12,
     haloQueryK: 12,
+    pivotProbeK: 12,
+    rationaleSampleK: 12,
+    corpusLimitMax: 24,
+    corpusClimbs: 24,
+    corpusContextsPerClimb: 6,
+    corpusSampleProbes: 6000,
+    corpusPreviewBytes: 220,
+    corpusSampleFloorBytes: 12,
     normalizeEpsilon: 1e-12,
     cosineEpsilon: 1e-12,
     alu: {
@@ -44,6 +52,18 @@ export function resolveConfig(opts = {}) {
         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,
+        corpusContextsPerClimb: opts.corpusContextsPerClimb ??
+            DEFAULT_CONFIG.corpusContextsPerClimb,
+        corpusSampleProbes: opts.corpusSampleProbes ??
+            DEFAULT_CONFIG.corpusSampleProbes,
+        corpusPreviewBytes: opts.corpusPreviewBytes ??
+            DEFAULT_CONFIG.corpusPreviewBytes,
+        corpusSampleFloorBytes: opts.corpusSampleFloorBytes ??
+            DEFAULT_CONFIG.corpusSampleFloorBytes,
         normalizeEpsilon: opts.normalizeEpsilon ?? DEFAULT_CONFIG.normalizeEpsilon,
         cosineEpsilon: opts.cosineEpsilon ?? DEFAULT_CONFIG.cosineEpsilon,
         alu: {

package/dist/src/geometry.d.ts

@@ -106,6 +106,27 @@ export declare function dominates(partLen: number, wholeLen: number): boolean;
  *  Consumer: `companyProfile` (mind/learning.ts), which sizes its constituent
  *  sketch at this capacity instead of a visit budget. */
 export declare function profileCapacity(D: number): number;
+/**
+ *  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 declare function consensusFloor(N: number): number;
 /** The coverage bar for the reach (interior) index, when vector-similarity
  *  gating is used.  Returns the concept threshold — the structural midpoint

package/dist/src/geometry.js

@@ -143,6 +143,27 @@ export function dominates(partLen, wholeLen) {
 export function profileCapacity(D) {
     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) {
     return Math.log(N) + 1 / 2;
 }

package/dist/src/meter.d.ts

@@ -152,6 +152,82 @@ export declare class Meter {
     mechanismRuns: number;
     /** Candidates the decider weighed. */
     candidates: number;
+    /** `deriveThrough` yielded — a fact was reached through the subject the query
+     *  never named. */
+    joinFired: number;
+    /** Refused: no key names the entity and the tail together.  (A key that
+     *  resolves but leads nowhere is not "refused" — it is not the relation, so
+     *  the scan simply moves on; there is no counter for a case the loop cannot
+     *  reach.) */
+    joinNoKey: number;
+    /** Refused: the fact contains no entity that leads anywhere. */
+    joinNoEntity: 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
+     *  happened, so "the recursion stopped" and "the recursion never ran" were
+     *  indistinguishable from the counters alone. */
+    recompletes: number;
+    /** Times the reasoner pivoted on a span its answer contains and stepped
+     *  across that fact. */
+    pivotSteps: 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
+     *  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: number;
+    /** 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: number;
+    /** How many spans that remainder consists of (each at least one W window). */
+    postGroundingRemainderSpans: number;
+    /** 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: number;
+    /** 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: number;
+    /** Bytes of the grounding's UNCOVERED material the extension was justified by
+     *  — the union of the spans each step carried a `W`-window of.  The gate
+     *  already computed WHICH span carried it per step and kept only a boolean;
+     *  this is that fact, accumulated.  Read with {@link reasonSteps}: one is the
+     *  price, the other the explanation. */
+    reasonCarriedBytes: number;
+    /** 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: number;
+    /** 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: number;
+    /** `bridge` calls the cover makes assembling connectors (pairwise + n-ary). */
+    coverBridges: number;
+    /** Continuations a CHAIN hop offered the search.  Bounded by the question
+     *  (`ceil(queryLen / W)`) rather than by the corpus's fan-out — measured on a
+     *  hub of degree 1083, offering every continuation grew the chart to 3113 outs
+     *  and cost a 270 MB peak / 256 MB OOM for a two-word question. */
+    chainOffers: number;
+    /** Σ byte-allowance the n-ary interior passes those bridges.  The allowance
+     *  is `middleBytes + (m + 1) * W` — every intermediate answer's bytes plus
+     *  one window of glue per joint — so it is the quantity that grows with a hub
+     *  query's answers, and the first thing to read when the peak moves. */
+    coverAllowanceBytes: number;
     private readonly _phases;
     private readonly _t0;
     /** Every work counter's current value, by name — the snapshot `time`

package/dist/src/meter.js

@@ -149,6 +149,101 @@ export class Meter {
     mechanismRuns = 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
+    // 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
+     *  never named. */
+    joinFired = 0;
+    /** Refused: no key names the entity and the tail together.  (A key that
+     *  resolves but leads nowhere is not "refused" — it is not the relation, so
+     *  the scan simply moves on; there is no counter for a case the loop cannot
+     *  reach.) */
+    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) ───────────────────────────────
+    //
+    // `pivotStep` was observable only through the rationale, and the rationale
+    // perturbs the search (measured).  How far the reasoner hopped is a
+    // BEHAVIOUR, so it needs an untraced view: one counter, incremented where the
+    // step is emitted.
+    /** 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) ────────────────────────
+    //
+    // The cover's `run` is 91% of a hub query's time (`"Hello."`: 2.7 s of 3.0 s)
+    // and holds its ~270 MB peak, and none of it was countable: `searchPushes`
+    // and `candidates` do not see the connector assembly.  These two counters are
+    // the untraced view of it.
+    /** `bridge` calls the cover makes assembling connectors (pairwise + n-ary). */
+    coverBridges = 0;
+    /** Continuations a CHAIN hop offered the search.  Bounded by the question
+     *  (`ceil(queryLen / W)`) rather than by the corpus's fan-out — measured on a
+     *  hub of degree 1083, offering every continuation grew the chart to 3113 outs
+     *  and cost a 270 MB peak / 256 MB OOM for a two-word question. */
+    chainOffers = 0;
+    /** Σ byte-allowance the n-ary interior passes those bridges.  The allowance
+     *  is `middleBytes + (m + 1) * W` — every intermediate answer's bytes plus
+     *  one window of glue per joint — so it is the quantity that grows with a hub
+     *  query's answers, and the first thing to read when the peak moves. */
+    coverAllowanceBytes = 0;
     // ── Phases ──────────────────────────────────────────────────────────────
     _phases = new Map();
     _t0 = performance.now();

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

@@ -75,6 +75,10 @@ export interface ConsensusAnchorTrace {
     rank: number;
     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;
     contributingEvidence: number;