@hviana/sema 0.8.2 → 0.8.5

package/docs/failures/tempting-but-wrong.md

@@ -1,7 +1,17 @@
 # Tempting but Wrong — 13 Traps
 
 Thirteen shortcuts that look plausible and break an invariant. Each states what
-not to do, why it fails, and what to do instead.
+not to do, why it fails, and what to do instead. **Some things are universal:
+discovering bugs:**
+
+- A bug must be pinned by a test that shows it.
+- This test cannot be accidental; it is subtle and requires deep analysis. That
+  is, it is not the test itself that reveals the bug, but rather the class of
+  errors to which the bug belongs.
+- This is difficult to do because the suite's small synthetic corpus easily
+  leads to accidental bugs, and real-world corpus must not be compromised.
+- Something that happens due to deduplication, a tie-breaking rule, etc., isn't
+  a bug—and that’s a subtle point.
 
 ### 1. `score >= threshold` decides identity
 
@@ -30,8 +40,7 @@ not to do, why it fails, and what to do instead.
 - **WRONG:** Break equal-rank ties by picking the most recently inserted
   edge/node.
 - **WHY:** Tie-breaks must be corpus-determined and stable; last-inserted is
-  recency-dependent and was fixed as a bug (`AGENTS §2` Invariant 1 —
-  first-inserted fallback).
+  recency-dependent (`AGENTS §2` Invariant 1 — first-inserted fallback).
 - **CORRECT:** `guidedFirst`/`chooseNext`/`chooseAmong`: rank then
   first-inserted (lowest node id / `LIMIT 1` insertion order). Pinned by
   `test/03-recall.test.mjs` determinism suites.
@@ -55,8 +64,8 @@ not to do, why it fails, and what to do instead.
   policy is enforced by masking, not pricing (`AGENTS §2` Invariant 4 — One cost
   currency; `docs/architecture/cost-model.md` § Policy is not cost).
 - **CORRECT:** Keep `PASS` dominating; enforce precedence in the caller (e.g.
-  `pipeline.ts` masks recognised sites overlapped by `ComputedResult`). Pinned
-  by `test/04-think.test.mjs` and `test/55-cost-meter.test.mjs`.
+  `cover.ts` masks recognised sites overlapped by `ComputedResult`). Pinned by
+  `test/04-think.test.mjs` and `test/55-cost-meter.test.mjs`.
 
 ### 6. Reimplementing `locate`/`align` inside a mechanism
 

package/docs/harness/gates.md

@@ -3,7 +3,7 @@
 Four executable gates. Each: run the command, check what it guards, follow its
 §.
 
-## 1 — Correctness (all 90 suites)
+## 1 — Correctness (all suites)
 
 ```bash
 npm test
@@ -12,9 +12,9 @@ npm test
 Guards honest silence, determinism, and every pinned contract. Silence:
 unrelated queries ground to nothing (`test/28`, `50`, `56`, `67`, `76`, `84`).
 Determinism: same seed + deposit order + query gives byte-identical answer
-(`test/20`). Every invariant is pinned — a simplification that fails a test is
-wrong until the test is shown wrong. §14–25 (pipeline), §64 (derived
-thresholds), AGENTS.md §2 invariants 1–5.
+(`test/20`). Every invariant is pinned, the closure law included
+(`test/133`–`140`). §14–25 (pipeline), §64 (derived thresholds), AGENTS.md §2
+invariants 1–5.
 
 ## 2 — Work accounting (profiler)
 
@@ -23,9 +23,9 @@ node bench/profile-inference.mjs        # add [n] to limit probes
 node bench/profile-inference.mjs --trace # trace is a debugging aid, not product
 ```
 
-Guards without trace: counters deterministic and diffable between runs; phases
-nest (not disjoint — `think` contains every mechanism phase); shared analyses
-charged to themselves, not to the first toucher; millisecond fields are
+Guards without trace: counters exact and diffable between COLD runs; phases nest
+(not disjoint — each phase is charged by its own layer); shared analyses charged
+to themselves, not to the first toucher; millisecond fields are
 non-deterministic hints only. With `--trace`, recognition idempotence still
 holds (`test/42`). `src/meter.ts`, `docs/architecture/meter.md`, §55,
 `AGENTS.md` §6.

package/docs/mechanisms/cast.md

@@ -12,7 +12,7 @@ schema yields its own candidate and `think`'s single weight comparison picks.
 halo-matched `pre.rec.sites`. The product is `pre.weave()` — `points[]` (each
 with graded `runs[]`) and a per-query-byte `depth[]` (how many structures cover
 that byte). CAST's single-vs-multi test is measured from those runs: a second
-point must add ≥ one perception quantum of coverage the widest point does not.
+point must add ≥ one perception quantum of coverage the widest does not.
 
 ## Gate — weave-local discriminative frame
 
@@ -76,5 +76,5 @@ redirection, or analogical comparison), not from a literal continuation.
 ## Source
 
 `src/mind/mechanisms/cast.ts` (`counterfactualTransfer`, `seatOfNode`,
-`MIN_WEAVE`), `src/mind/match.ts` (`alignGraded`, `project`, `depth`),
+`MIN_WEAVE`, `weave.depth`), `src/mind/match.ts` (`alignGraded`, `project`),
 `src/geometry.ts` (`dominates`), `src/mind/graph-search.ts` (`STEP`).

package/docs/mechanisms/cover.md

@@ -15,9 +15,8 @@ consumes them directly; any site whose bytes overlap a computed span is masked
 - `formRules` follow continuation edges (`GraphSearch.formRules`): each hop
   costs `STEP` (1). Forks across all continuations up to the hub bound;
   disambiguation is distributional, not heuristic.
-- Edge-less forms may hop via a halo sibling (`conceptHop` / `resolveConcepts`
-  in `src/mind/mechanisms/cover.ts`) at `CONCEPT` (10), borrowing a synonym's
-  continuation.
+- Edge-less forms may hop via a halo sibling (`conceptHop` / `resolveConcepts`)
+  at `CONCEPT` (10), borrowing a synonym's continuation.
 
 ## Gate — `leadsSomewhere` (`src/mind/traverse.ts`)
 
@@ -34,8 +33,8 @@ and are filtered during recognition.
 | `PASS`    | 1000 / byte | each unaccounted byte                           |
 | `MICRO`   | 1e-3        | per-byte A* heuristic (`h = (len-right)*MICRO`) |
 
-Mechanism weight is `moves + PASS * unaccounted_bytes`; comparison is at `STEP`
-grade, then by `scaffolding` bytes, then list order.
+The cover reports `moves` (its derivation's discrete work) and `accounted`; the
+ladder prices both.
 
 ## Pre-resolution (`src/mind/mechanisms/cover.ts`)
 

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

@@ -1,44 +1,97 @@
-// 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.
+// 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: Array<[string, string]> = [
+  ["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"],
+];
 
-import { Mind } from "../src/index.js";
-import { SQliteStore } from "../src/store-sqlite.js";
+// 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(): 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. "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<string>();
+    const trace: string[] = [];
+    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();
 }

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.5",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.8.2",
+  "version": "0.8.5",
   "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,23 +155,31 @@ 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;
 }
 
-/** 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: number, D: number): number {
-  return conceptThreshold(D);
-}
-
 // ---- types ----
 
 export interface Folded {

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,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) ────────────────────────
   //

package/src/mind/articulation.ts

@@ -119,7 +119,6 @@ export async function articulate(
     new Map(),
     ans.leaves,
     ans.splits,
-    ans.starts,
     substitutions,
     undefined,
     undefined,