@hviana/sema 0.8.2 → 0.8.5

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
@@ -55,13 +55,15 @@ Five invariants. Violate one and the system degrades silently — tests pin them
 | 4 | One cost currency                   | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; `weight = moves + PASS·unaccounted`; compare at `STEP` grade                                            | `docs/architecture/cost-model.md` → `src/mind/graph-search.ts`, `src/derive/`               |
 | 5 | Bounded reads                       | No per-query read grows with N; cap is `hubBound = √N` enforced at the store via `LIMIT` reads, existence probes, and `bytesPrefix` caps               | `docs/architecture/bounded-reads.md` → `src/store.ts`, `src/mind/traverse.ts`               |
 
-Cross-cutting contracts (single-definition, import everywhere): `contentLevels`
-in `src/geometry.ts` is the one boundary rule; `src/mind/canonical.ts` is the
-write/read contract for canonical segmentation; `src/mind/junction.ts` is the
-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.
+Cross-cutting contracts (single-definition, imported everywhere):
+`contentLevels` in `src/geometry.ts` is the one boundary rule;
+`src/mind/derivation.ts` is the closure law; `src/mind/canonical.ts` is the
+canonical segmentation contract; `src/mind/junction.ts` is the shared
+content-addressed ascent; `Precomputed` in `src/mind/pipeline-mechanism.ts` is
+the per-response memo; `src/meter.ts` is the write-only work accounting surface.
+See `docs/INDEX.md` and `factored-machinery.md` for the contract table and
+ownership. Tie-breaks are corpus-determined, not interchangeable
+(`determinism.md`).
 
 ## 3. Where things live
 
@@ -89,15 +91,15 @@ 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
 
 ### Add a grounding mechanism or extension
 
 Implement `PipelineMechanism` (`floor` → admissible bound or `null`; `run` →
-candidates with `bytes`/`accounted`/`moves`/`unexplained` + optional
-`scaffolding`/`complete`). Register via
+candidates with `bytes`/`accounted`/`moves` + optional
+`scaffolding`/`complete`/`used`/`provenance`). 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 +127,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 +144,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 +162,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/README.md

@@ -179,39 +179,16 @@ in the same pass — reasons onward to a separate fact about that painter. Nothi
 in the reply but the painter's own name comes from the question.
 
 ```ts
-// demo.ts — one short session that drives the WHOLE pipeline from one memory.
-
-import { Mind } from "../src/index.js";
-import { SQliteStore } from "../src/store-sqlite.js";
-
-async function main(): Promise<void> {
-  const mind = new Mind({ store: new SQliteStore({ path: ":memory:" }) });
-  const ask = async (q: string) => (await mind.respondText(q)).trim();
-
-  // ── Jot down what we know. Each line is just (context → what follows). ──
-  await mind.ingest([
-    // One relation, shown three times — a pattern taught purely by example:
-    ["The Mona Lisa was painted by Leonardo da Vinci.", "Leonardo da Vinci"],
-    ["The Starry Night was painted by Vincent van Gogh.", "Vincent van Gogh"],
-    [
-      "The Night Watch was painted by Rembrandt van Rijn.",
-      "Rembrandt van Rijn",
-    ],
-    // One stray fact, keyed on a name none of the examples mention:
-    ["Pablo Picasso", "Pablo Picasso co-founded the Cubist movement"],
-  ]);
-
-  // 1) GENERALIZE — apply the learned pattern to an unseen sentence and read out
-  //    the painter, then keep going into what is known about him.
-  console.log(await ask("The Weeping Woman was painted by Pablo Picasso."));
-
-  // 2) COMPUTE — exact arithmetic, grounded right where the notes go silent.
-  console.log(await ask("a museum charges 12*4 for a family ticket"));
-
-  await mind.store.close();
-}
-
-main();
+// demo.ts — a corpus goes in, and the memory is read back out.
+
+import { Mind, SQliteStore } from "../src/index.js";
+
+const mind = new Mind({ store: new SQliteStore({ path: ":memory:" }) });
+await mind.ingest(CORPUS); // (context -> what follows) notes, the deposit shape
+
+mind.sampleCorpus(4); // what the memory HOLDS
+mind.searchCorpusText("Pablo Picasso"); // which notes a question REACHES
+await mind.respond("The Weeping Woman was painted by Pablo Picasso.");
 ```
 
 ```text
@@ -224,7 +201,7 @@ Ask for the receipt instead of the text, and each answer says how it was reached
 the route, and, on request, the complete replayable trace behind it:
 
 ```text
-"The Weeping Woman was painted by Pablo Picasso."  →  provenance: cast
+"The Weeping Woman was painted by Pablo Picasso."  →  provenance: cover
     ( structure carried across the three worked examples )
 
 "a museum charges 12*4 for a family ticket"        →  provenance: cover
@@ -233,10 +210,12 @@ the route, and, on request, the complete replayable trace behind it:
 
 > [!NOTE]
 > This is **[example/demo.ts](example/demo.ts)** — run it with `npm run demo`.
-> The first question names a painting Sema was never shown, and asks nothing
-> explicit; what comes back is a fact about Cubism that appears **nowhere** in
-> it. The second is exact, not a plausible-looking guess. Every step traces back
-> to the four notes above.
+> It reads the memory back two ways: `sampleCorpus` browses what it holds, and
+> `searchCorpusText` reports which stored notes a question reaches — exactly, so
+> a question overlapping nothing is answered with a note saying so, never with
+> an invention. The first answer names a painting Sema was never shown and still
+> returns a fact about Cubism that appears **nowhere** in it; the second is
+> computed. Every step traces back to the five notes above.
 
 ---
 

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/example/demo.js

@@ -1,39 +1,90 @@
-// demo.ts — one short session that drives the WHOLE pipeline from one memory.
+// demo.ts — a corpus goes in, and the memory is read back out.
 //
-// We give Sema a handful of plain notes, then ask things that no single note
-// answers. The headline query is the third one: from three worked examples Sema
-// learns the shape of "X was painted by Y", lifts the painter out of a sentence
-// it has NEVER seen, and then — in the same pass — reasons forward to a separate
-// fact about that painter. The reply contains no word from the question. That is
-// retrieval, generalization, and reasoning composing as a single act, with every
-// step traceable back to the notes behind it.
-import { Mind } from "../src/index.js";
-import { SQliteStore } from "../src/store-sqlite.js";
+// Sema is given a small corpus of plain notes, each one the shape every deposit
+// has: a context, and what follows it. Then the memory is read two ways — what
+// it HOLDS (`sampleCorpus`), and which of its notes a question REACHES
+// (`searchCorpusText`). Both run through the same content-addressed machinery an
+// answer uses (src/mind/corpus.ts); nothing is indexed and nothing is written.
+//
+// The search addresses content EXACTLY, not by keyword: a question reaches a
+// note when it shares chunk-aligned content with it, so a question with no such
+// overlap is reported as exactly that — a STATE, rendered by the text layer
+// (`CorpusTextResult.note`), never as prose the engine invented.
+//
+// The last act is two ordinary answers, each with its derivation streamed as it
+// unfolds, the PROVENANCE that names the route it grounded on, and the work it
+// cost read off the meter: the rationale and the meter ARE the explanation
+// surface (AGENTS.md §6).
+import { decodeText, formatReport, Mind, SQliteStore } from "../src/index.js";
+// One relation shown three times — a pattern taught purely by example — plus a
+// stray fact keyed on a name none of the examples mention.
+const CORPUS = [
+    ["The Mona Lisa was painted by Leonardo da Vinci.", "Leonardo da Vinci"],
+    ["The Starry Night was painted by Vincent van Gogh.", "Vincent van Gogh"],
+    [
+        "The Night Watch was painted by Rembrandt van Rijn.",
+        "Rembrandt van Rijn",
+    ],
+    ["Pablo Picasso", "Pablo Picasso co-founded the Cubist movement"],
+    ["The Weeping Woman was painted by Pablo Picasso.", "Pablo Picasso"],
+];
+// Questions the corpus can address, and one it cannot — the honest miss.
+const QUERIES = [
+    "The Mona Lisa was painted by Leonardo da Vinci.",
+    "Pablo Picasso",
+    "xylophone",
+];
+// One question answered by composing across the notes, and one answered by
+// computing: the two routes the corpus search does not take.
+const ASKS = [
+    "The Weeping Woman was painted by Pablo Picasso.",
+    "a museum charges 12*4 for a family ticket",
+];
 async function main() {
-    const mind = new Mind({ store: new SQliteStore({ path: ":memory:" }) });
-    const ask = async (q) => (await mind.respondText(q)).trim();
-    // ── Jot down what we know. Each line is just (context → what follows). ──
-    await mind.ingest([
-        // One relation, shown three times — a pattern taught purely by example:
-        ["The Mona Lisa was painted by Leonardo da Vinci.", "Leonardo da Vinci"],
-        ["The Starry Night was painted by Vincent van Gogh.", "Vincent van Gogh"],
-        [
-            "The Night Watch was painted by Rembrandt van Rijn.",
-            "Rembrandt van Rijn",
-        ],
-        // One stray fact, keyed on a name none of the examples mention:
-        ["Pablo Picasso", "Pablo Picasso co-founded the Cubist movement"],
-    ]);
-    // 1) GENERALIZE — apply the learned pattern to an unseen sentence and read out
-    //    the painter. "Pablo Picasso" was never given as an answer; Sema locates it
-    //    by analogy to the three examples.
-    console.log(await ask("The Weeping Woman was painted by Pablo Picasso."));
-    // → "Pablo Picasso co-founded the Cubist movement"
-    //   …and, having found the painter, it KEEPS GOING: the name bridges into the
-    //   one fact it holds about him. The answer appears in no word of the question.
-    // 2) COMPUTE — exact arithmetic, grounded right where the notes go silent.
-    console.log(await ask("a museum charges 12*4 for a family ticket"));
-    // → "48"
+    const mind = new Mind({
+        store: new SQliteStore({ path: ":memory:" }),
+        profile: true,
+    });
+    await mind.ingest(CORPUS);
+    // 1) WHAT THE MEMORY HOLDS — real pairs, browsed, no query and no random draw.
+    console.log("— the corpus, as the memory holds it —");
+    for (const p of mind.sampleCorpus(4).pairs) {
+        console.log(`  ${decodeText(p.context)}  →  ${decodeText(p.continuation)}`);
+    }
+    // 2) SEARCH — which stored notes does a question reach? A question that
+    //    addresses the corpus answers with pairs; one that shares nothing with it
+    //    answers with a note saying so.
+    for (const q of QUERIES) {
+        const r = mind.searchCorpusText(q, 3);
+        console.log(`\n— "${q}" —  ${r.resolved} resolved / ${r.reached} reached`);
+        if (r.note !== undefined)
+            console.log(`  ${r.note}`);
+        for (const p of r.pairs) {
+            console.log(`  ${p.context}  →  ${p.continuation}  (${p.matchedBytes} matched)`);
+        }
+    }
+    // 3) ANSWERS, WITH THEIR DERIVATION — the same pipeline, read as data. Steps
+    //    repeat (recognise re-enters under every mechanism that needs it), so each
+    //    distinct mechanism-and-note is printed once, in the order it first ran.
+    for (const q of ASKS) {
+        const seen = new Set();
+        const trace = [];
+        const r = await mind.respond(q, (s) => {
+            const line = `${s.mechanism.join(" › ")}${s.note ? ` — ${s.note}` : ""}`;
+            if (seen.has(line))
+                return;
+            seen.add(line);
+            trace.push(`${"  ".repeat(Math.max(0, s.mechanism.length - 1))}${line}`);
+        });
+        console.log(`\n— "${q}" —  ${r.provenance ?? "no answer"}`);
+        console.log(`  ${decodeText(r.bytes).trim()}`);
+        console.log("— how —");
+        for (const s of trace)
+            console.log(s);
+        if (mind.lastCost !== null) {
+            console.log(`— what it cost —\n${formatReport(mind.lastCost)}`);
+        }
+    }
     await mind.store.close();
 }
 main();

package/dist/src/config.d.ts

@@ -100,6 +100,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

package/dist/src/config.js

@@ -5,6 +5,7 @@ export const DEFAULT_CONFIG = {
     seed: 42,
     recallQueryK: 12,
     haloQueryK: 12,
+    pivotProbeK: 12,
     rationaleSampleK: 12,
     corpusLimitMax: 24,
     corpusClimbs: 24,
@@ -51,6 +52,7 @@ 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,

package/dist/src/geometry.d.ts

@@ -106,17 +106,28 @@ 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;
-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
- *  (~0.5 at D=1024) where two forms are "more similar than not."
+/**
+ *  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.
  *
- *  Currently UNUSED in the hot training path: interior nodes are indexed
- *  unconditionally (hash-cons dedup bounds the index naturally).
- *  Post-hoc structural compaction ({@link Store.compactContentIndex})
- *  replaces runtime coverage gating with a batch pass that removes
- *  structurally-isolated entries.  Derived, never tuned. */
-export declare function coverageBar(_maxGroup: number, D: number): number;
+ *  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;
 export interface Folded {
     tree: Sema;
     /** Byte length of the subtree — carried incrementally so the stable-prefix

package/dist/src/geometry.js

@@ -143,21 +143,30 @@ 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;
 }
-/** The coverage bar for the reach (interior) index, when vector-similarity
- *  gating is used.  Returns the concept threshold — the structural midpoint
- *  (~0.5 at D=1024) where two forms are "more similar than not."
- *
- *  Currently UNUSED in the hot training path: interior nodes are indexed
- *  unconditionally (hash-cons dedup bounds the index naturally).
- *  Post-hoc structural compaction ({@link Store.compactContentIndex})
- *  replaces runtime coverage gating with a batch pass that removes
- *  structurally-isolated entries.  Derived, never tuned. */
-export function coverageBar(_maxGroup, D) {
-    return conceptThreshold(D);
-}
 // ---- folding ----
 //
 // The river fold is a hierarchical prefix network: each level contracts

package/dist/src/meter.d.ts

@@ -162,9 +162,71 @@ export declare class Meter {
     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;
+    /** Bytes of the question's REMAINDER a step CONSUMED — the drop the law's own
+     *  `advance` makes when a declared move carries the material it accounts for.
+     *  Read with {@link reasonSteps} and {@link reasonCarriedBytes}: carrying is
+     *  the engagement, this is the consumption, and before it the second was
+     *  invisible. */
+    closureDrainedBytes: number;
+    /** Bytes of the question the grounding PRICED but whose material its answer does
+     *  NOT carry, at or above one quantum — the debt the construction leaves for the
+     *  walk to pay by carrying it.  Zero means the grounding's coverage is honest:
+     *  everything it priced is either held by the answer or under the W floor. */
+    groundingWithheldBytes: 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

package/dist/src/meter.js

@@ -166,6 +166,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) ───────────────────────────────
     //
     // `pivotStep` was observable only through the rationale, and the rationale
@@ -175,6 +181,62 @@ 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;
+    /** Bytes of the question's REMAINDER a step CONSUMED — the drop the law's own
+     *  `advance` makes when a declared move carries the material it accounts for.
+     *  Read with {@link reasonSteps} and {@link reasonCarriedBytes}: carrying is
+     *  the engagement, this is the consumption, and before it the second was
+     *  invisible. */
+    closureDrainedBytes = 0;
+    /** Bytes of the question the grounding PRICED but whose material its answer does
+     *  NOT carry, at or above one quantum — the debt the construction leaves for the
+     *  walk to pay by carrying it.  Zero means the grounding's coverage is honest:
+     *  everything it priced is either held by the answer or under the W floor. */
+    groundingWithheldBytes = 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)

package/dist/src/mind/articulation.js

@@ -96,7 +96,7 @@ export async function articulate(ctx, answer, query) {
             s.end,
         ])),
     ]);
-    const solved = ctx.search.cover(answer.length, voicedSites, new Map(), ans.leaves, ans.splits, ans.starts, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+    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 segs = solved && solved.segs;
     tArtCover?.done(segs === null
         ? []