@hviana/sema 0.5.7 → 0.5.9

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/geometry.ts

@@ -132,6 +132,29 @@ export function dominates(partLen: number, wholeLen: number): boolean {
  *  recallByResonance trusting a climb anchor, and commitVotes admitting a
  *  further point of attention.  Defined once here so the two can never
  *  drift apart.  Derived from N, never tuned. */
+/** SUPERPOSITION CAPACITY — how many quasi-orthogonal terms one vector can
+ *  carry before an individual term stops being readable.  `√D`.
+ *
+ *  A superposition of m unit signatures has ‖acc‖² ≈ m, so one term's
+ *  contribution to any cosine taken against that vector is ≈ 1/m.  Setting
+ *  that against the representation's own floor {@link estimatorNoise} = 1/√D:
+ *
+ *      1/m < 1/√D   ⟺   m > √D
+ *
+ *  Past √D terms a single shared constituent can no longer move a halo cosine
+ *  above quantisation noise — and because the result is normalized, each extra
+ *  term also shrinks every ALREADY-accepted term toward that floor.  So this is
+ *  not a budget that trades accuracy for time: beyond capacity, more evidence
+ *  makes the representation strictly worse.  It composes with
+ *  {@link significanceBar} (3/√D) as it should — three shared units of √D is
+ *  exactly the significance bar.
+ *
+ *  Consumer: `companyProfile` (mind/learning.ts), which sizes its constituent
+ *  sketch at this capacity instead of a visit budget. */
+export function profileCapacity(D: number): number {
+  return Math.max(1, Math.floor(Math.sqrt(D)));
+}
+
 export function consensusFloor(N: number): number {
   return Math.log(N) + 1 / 2;
 }

package/src/mind/articulation.ts

@@ -7,7 +7,7 @@ import { Vec } from "../vec.js";
 import type { MindContext } from "./types.js";
 import { spliceAll } from "./types.js";
 import { recognise } from "./recognition.js";
-import { contains } from "./traverse.js";
+import { answers, contains } from "./traverse.js";
 import { bestHaloMate } from "./match.js";
 import type { Site } from "./graph-search.js";
 import type { CandidateSpan } from "../derive/src/index.js";
@@ -75,9 +75,23 @@ export async function articulate(
     const found = bestHaloMate(ctx, h, voices, (v) => v.halo);
     if (!found) continue;
     const voice = found.item;
-    if (voice.node === s.payload || contains(ctx, voice.node, s.payload)) {
+    if (
+      voice.node === s.payload || contains(ctx, voice.node, s.payload) ||
+      answers(ctx, voice.node, s.payload)
+    ) {
       continue;
     }
+    // A form spanning the WHOLE answer is not a concept inside the answer to
+    // revoice — substituting it discards the answer and emits the asker's own
+    // words back, which is what a conversational store makes tempting: an
+    // answer and the question it answers keep maximal company, so the whole
+    // answer resonates with the whole query above any concept threshold
+    // (measured on the CONV fixture at 0.809 against 0.516).  Articulation
+    // splices the asker's wording INTO an answer where the same concept
+    // appears; when the "concept" is the entire answer there is nothing left
+    // of it, and "where is it kept now" comes back in place of "it hangs in
+    // madrid".  §5's contract is re-voicing, never replacement.
+    if (s.start === 0 && s.end === answer.length) continue;
     substitutions.set(s.payload, voice.bytes);
   }
   if (substitutions.size === 0) {

package/src/mind/attention.ts

@@ -193,6 +193,12 @@ export interface ConsensusAnchorTrace {
     passesNaturalBreak?: boolean;
     passesConsensusFloor?: boolean;
     pastLeadingSaturation?: boolean;
+    /** Committed because its margin from the dominant is inside the estimator's
+     *  own resolution — the co-dominant band in {@link commitVotes}.  Recorded
+     *  because commit decisions are kept in the exact shape the gates applied
+     *  them: a root admitted this way must never read, in the trace, as one
+     *  that cleared the two vote gates. */
+    tiedWithDominant?: boolean;
     rejectionReasons: AnchorRejectionReason[];
   };
 }
@@ -1703,6 +1709,7 @@ export function commitVotes(
     passesNaturalBreak: boolean | undefined,
     passesConsensusFloor: boolean | undefined,
     pastLeadingSaturation: boolean | undefined,
+    tiedWithDominant: boolean | undefined,
     rejectionReasons: AnchorRejectionReason[],
   ) => {
     if (!td) return;
@@ -1723,6 +1730,7 @@ export function commitVotes(
         passesNaturalBreak,
         passesConsensusFloor,
         pastLeadingSaturation,
+        tiedWithDominant,
         rejectionReasons,
       },
     });
@@ -1738,6 +1746,7 @@ export function commitVotes(
     let passesNaturalBreak: boolean | undefined;
     let passesConsensusFloor: boolean | undefined;
     let pastLeadingSaturation: boolean | undefined;
+    let tiedWithDominant: boolean | undefined;
     const rejectionReasons: AnchorRejectionReason[] = [];
     if (absorbed) {
       status = "overlap";
@@ -1760,7 +1769,49 @@ export function commitVotes(
       } else {
         passesNaturalBreak = vote >= rootCut;
         passesConsensusFloor = vote >= floor;
-        if (passesNaturalBreak && passesConsensusFloor && pastLeading) {
+        // 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
+        // when the ordering moves with the seed.
+        //
+        // The dominant bypasses both vote gates ("it always grounds"); the
+        // runner-up is held to an absolute ln(N)+1/2 floor the dominant never
+        // had to clear.  Which of them gets the exemption is then decided by a
+        // sort over ESTIMATED quantities.  Measured on test/29 D1's corpus,
+        // 60 seeds per D — true separation 0.54s / 0.75s / 1.04s:
+        //
+        //     D      s=1/sqrt(D)   vote SD (estimated anchor)  SD/s   flips
+        //     256    0.0625        0.0561                      0.90   19/60
+        //    1024    0.0313        0.0268                      0.86   12/60
+        //    4096    0.0156        0.0074                      0.48    2/60
+        //
+        // The SD tracks 1/sqrt(D) and the flip rate collapses with it, so the
+        // reordering is the ESTIMATOR's, not the corpus's.  The loser was then
+        // refused by a floor at 1.599 that neither anchor could ever reach
+        // (corpusN 3) — a coin flip decided which single structure the query
+        // was allowed to have settled on.
+        //
+        // THE BAND IS sqrt(k)*s, NOT s.  A vote is a SUM over the anchor's own
+        // contributing regions, so its noise grows as sqrt(k); pricing a summed
+        // margin against one s would be the category error chooseNext's comment
+        // warns about.  k is `regionAxioms`, already in hand; s is
+        // `estimatorNoise(D)`, already derived.  No constant is introduced.
+        // Verified conservative: measured SD/(sqrt(k)*s) never exceeded 0.72.
+        //
+        // BOUNDED BY CONSTRUCTION: admission requires indistinguishability from
+        // an anchor ALREADY admitted, so it can only admit what the ordinary
+        // rule would have admitted had the noise fallen the other way.  It is
+        // N-independent for the same reason — a statement about the estimator,
+        // not about corpus size.
+        const tieBand = Math.sqrt(
+          Math.max(1, regionAxioms.get(point.anchor) ?? 1),
+        ) * estimatorNoise(ctx.store.D);
+        const dominantVote = votesIdf.get(roots[0].anchor) ?? 0;
+        tiedWithDominant = dominantVote - vote < tieBand;
+        if (
+          ((passesNaturalBreak && passesConsensusFloor) || tiedWithDominant) &&
+          pastLeading
+        ) {
           status = "root";
         } else {
           status = "rejected";
@@ -1782,6 +1833,7 @@ export function commitVotes(
           passesNaturalBreak,
           passesConsensusFloor,
           pastLeadingSaturation,
+          tiedWithDominant,
           rejectionReasons,
         );
         continue;
@@ -1795,6 +1847,7 @@ export function commitVotes(
       passesNaturalBreak,
       passesConsensusFloor,
       pastLeadingSaturation,
+      tiedWithDominant,
       rejectionReasons,
     );
     placed.push(point);

package/src/mind/learning.ts

@@ -3,7 +3,7 @@
 //   Learning is DEPOSITION: perceive a stream into a tree and intern every
 //   node.  A fact is an EDGE between node ids; recall traverses edges.
 
-import { Vec } from "../vec.js";
+import { addInto, normalize, Vec, zeros } from "../vec.js";
 import { bindSeat, companySignature, isChunk, Sema } from "../sema.js";
 import type { Input, MindContext } from "./types.js";
 import { changedNodes } from "./types.js";
@@ -15,6 +15,9 @@ import {
   resolve,
 } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
+import { rItem, rNode } from "./trace.js";
+import { hubBound } from "./traverse.js";
+import { dominates, estimatorNoise, profileCapacity } from "../geometry.js";
 import { fold as foldVecs } from "../sema.js";
 
 /** Intern a perceived tree into node ids, bottom-up, sharing equal subtrees.
@@ -233,6 +236,249 @@ export interface DepositReport {
   continuationId?: number;
 }
 
+/** Deterministic priority of a node for bottom-k selection — a fixed integer
+ *  mix of the node id, NOT a function of the config seed.
+ *
+ *  Seed-independence is the point: the sketch is a property of the STORE, so
+ *  two Minds over one store must agree on it, and a rebuilt sketch must match
+ *  a stored one.  (Contrast {@link companySignature}, which is seeded — that is
+ *  the VECTOR, this is only the CHOICE of which vectors to superpose.)
+ *
+ *  Selecting the k smallest priorities makes the sketch a bottom-k sample keyed
+ *  on each constituent's own identity, so a unit shared by two partners is kept
+ *  by BOTH or neither, whatever its depth or position in either fold.  That is
+ *  what removes the traversal-order dependence a visit budget necessarily had. */
+function unitPriority(id: number): number {
+  let h = (id ^ 0x9e3779b9) >>> 0;
+  h = Math.imul(h ^ (h >>> 16), 0x85ebca6b) >>> 0;
+  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+  return (h ^ (h >>> 16)) >>> 0;
+}
+
+/** Whether `n` is a MINIMAL UNIT: a stored branch, at least one fold window
+ *  wide, no constituent of its own at or above W.  Every clause is INTRINSIC —
+ *  a property of the node's own subtree — which is what lets a sketch be stored
+ *  once and stay valid as the corpus grows.  The two corpus-relative readings
+ *  (half-dominance of the PARTNER, and the hub test) are deliberately excluded
+ *  and applied by {@link companyProfile} at pour time. */
+function isMinimalUnit(ctx: MindContext, n: number, W: number): boolean {
+  if (n < 0) return false; // byte atom — fan-in is the alphabet's
+  const kids = ctx.store.get(n)?.kids;
+  if (kids == null) return false; // stored kid-less node: also an atom
+  if (ctx.store.contentLen(n, W) < W) return false;
+  for (const kid of kids) {
+    if (kid >= 0 && ctx.store.contentLen(kid, W) >= W) return false; // composite
+  }
+  return true;
+}
+
+/** The BOTTOM-K CONSTITUENT SKETCH of a node: the `k = profileCapacity(D)`
+ *  minimal units of its subtree with the smallest {@link unitPriority}.
+ *
+ *  COMPOSABLE, WHICH IS WHY IT COSTS NOTHING TWICE.  Bottom-k of a union is
+ *  the bottom-k of the children's bottom-k sets, so a node's sketch is built
+ *  from its kids' sketches and each recursive result is stored on the way out.
+ *  A partner met again reads O(k); an accumulated conversation, where turn k's
+ *  context is a prefix of turn k+1's, reuses every unchanged child and pays
+ *  O(changed) instead of O(context) — the quadratic that made a visit budget
+ *  look necessary in the first place.
+ *
+ *  It is DURABLE DERIVED STATE, not a cache (see Store.sketchGet): a miss must
+ *  cost time only, and this decides which terms enter a halo.  A backend
+ *  without the capability recomputes per pour and loses only the amortisation.
+ *
+ *  Recursion depth is the fold's, O(log_W len), and each level does O(k·arity)
+ *  work, so construction is one pass over the subtree — the same pass the
+ *  deposit that interned it already performed. */
+function constituentSketch(ctx: MindContext, id: number, k: number): number[] {
+  const stored = ctx.store.sketchGet?.(id);
+  if (stored != null) return stored; // [] is a real answer; null is "unknown"
+  const W = ctx.space.maxGroup;
+  const kids = id < 0 ? null : ctx.store.get(id)?.kids;
+  let out: number[];
+  if (kids == null) {
+    out = [];
+  } else {
+    const pool: number[] = [];
+    for (const kid of kids) {
+      if (isMinimalUnit(ctx, kid, W)) pool.push(kid);
+      else if (kid >= 0) {
+        for (const g of constituentSketch(ctx, kid, k)) pool.push(g);
+      }
+    }
+    // Bottom-k by identity, then by id so ties are corpus-determined (§2.1).
+    pool.sort((a, b) => (unitPriority(a) - unitPriority(b)) || (a - b));
+    const seen = new Set<number>();
+    out = [];
+    for (const n of pool) {
+      if (seen.has(n)) continue;
+      seen.add(n);
+      out.push(n);
+      if (out.length >= k) break;
+    }
+  }
+  ctx.store.sketchPut?.(id, out);
+  return out;
+}
+
+/** The COMPANY PROFILE of a partner: its own identity signature superposed
+ *  with the signatures of its RECURRING content-defined constituents.
+ *
+ *  WHY THE WHOLE-PARTNER SIGNATURE ALONE IS NOT ENOUGH.  The distributional
+ *  hypothesis is a claim about TYPES ("occurs near a city name"), but a
+ *  signature keyed on the whole partner's node id records a TOKEN ("occurred
+ *  near node #4711992").  Two nodes are then distributional siblings only when
+ *  their partners are the very same node — and a content-addressed store of
+ *  natural language almost never repeats a whole deposit (measured on the
+ *  trained store: whole-span dedup 0.98×, i.e. effectively none).  So the
+ *  halos of genuine synonyms came out quasi-orthogonal BY CONSTRUCTION: the
+ *  best distributional sibling of "Eiffel Tower" scored 0.146 against a
+ *  concept threshold of 0.516, with its own attested translations absent
+ *  entirely, and the whole concept-hop / articulation / analogy layer was
+ *  inert at corpus scale.  (Re-verified under the store's OWN training seed:
+ *  company signatures key on NODE ID, not the alphabet, so this reading is
+ *  seed-independent and the figures are identical either way.  Worth stating
+ *  because a Mind built with a seed other than the store's makes every GIST
+ *  comparison meaningless while leaving halo comparisons untouched.)
+ *
+ *  WHY THE DESCENT MUST NOT STOP AT DEPTH 1.  Reading only `rec.kids` does
+ *  NOT deliver this.  Cuts are content-defined over a rolling window, so a
+ *  chunk boundary depends on the bytes AROUND a unit: "The Eiffel Tower is in
+ *  Paris" folds to "The Eiffel " + "Tower is in Paris", and "Tour Eiffel dia
+ *  any Paris" to "Tour Eiffel " + "dia any Paris".  The shared unit "Paris"
+ *  is a node in NEITHER — depth-1 profiles of that pair intersect in the
+ *  EMPTY SET, and their halos measured 0.0319 against 0.0416 for an unrelated
+ *  control: no signal at all.  A depth-1 read merely moves the token problem
+ *  from whole-partner identity down to top-level-chunk identity, which for
+ *  full sentences is nearly as rare.  Descending, the same pair shares
+ *  " Paris" and "ffel " while the control still shares nothing — the units
+ *  the distributional hypothesis is actually about.
+ *
+ *  EVERY DEPTH CONTRIBUTES, AND THE RULE MUST NOT DEPEND ON ARRIVAL ORDER.
+ *  The tempting stop rule — descend only while a constituent is corpus-unique,
+ *  stop at the first unit attested in ≥ 2 forms — is wrong, and measurably so.
+ *  Recurrence is a property of the corpus SO FAR: when the first of a pair is
+ *  deposited its shared unit has fan-in 1, so the descent runs past it, and
+ *  only the second partner ever profiles it.  The pair then never meets
+ *  (measured on the fixture above: 0.0165 against a 0.0375 control — still
+ *  nothing).  Whether two synonyms become distributional siblings cannot be
+ *  allowed to depend on which was trained first.  So the walk descends through
+ *  EVERY constituent within its budget and superposes each one that is not a
+ *  hub, at whatever depth it sits.  A partner's own unique chunks contribute
+ *  terms unique to that partner, which dilute but never mislead; the shared
+ *  units contribute the signal.
+ *
+ *  HUBS ARE THE ONE EXCLUSION, read LIMITed as `parentsFirst(n, bound+1)` —
+ *  the store's own exact hub-or-not probe (a result longer than the bound
+ *  means MORE than the bound), never a fan-in-sized read.  A constituent with
+ *  more than √N structural parents is scaffolding by §8.8's bound: " is ",
+ *  "the ".  Superposing it would put a term shared by every deposit into every
+ *  profile, ALL halos would correlate, and the concept threshold's null model
+ *  (unrelated halos at 0 ± 1/√D) that §4.1's hygiene note protects would
+ *  collapse.  It is still DESCENDED into — a hub chunk can contain a rare
+ *  unit — but contributes nothing itself.
+ *
+ *  Byte atoms are skipped in BOTH representations (a negative id and a stored
+ *  kid-less node): an atom's fan-in is the alphabet's, so it can only ever
+ *  read as a hub, and a short partner folding FLAT would otherwise put a
+ *  handful of alphabet signatures into every profile — which is what silenced
+ *  CAST's analogy gate in the first version of this function (measured:
+ *  analogy strength 0.3636 -> 0.2004, "no halo-tier company evidence",
+ *  test/29 C1).
+ *
+ *  A FUNCTION OF THE NODE AND THE CORPUS STATE — stated precisely, because
+ *  the weaker claim is the true one.  The constituents are read from the
+ *  STORE, never from the depositing tree's id map: that map holds only the
+ *  nodes THIS deposit newly interned, so a partner met a second time yielded a
+ *  profile missing exactly those constituents, the exact-partner case fell
+ *  from cosine 1 to 1/√(1+k), and the geometry stopped meaning anything.
+ *  Reading the store fixes that.  It does NOT make the profile permanent: the
+ *  hub test reads fan-in against √N and both grow with training, so a partner
+ *  poured early and again late can profile differently.  That residue is
+ *  confined to the hub EXCLUSION — which terms are dropped as scaffolding —
+ *  and never to which units are found, because the descent itself is now
+ *  order-independent.  The drift is one-directional and benign: a term can
+ *  only ever go from contributing to being excluded as scaffolding.  Replay of
+ *  a fixed training order is bit-identical, so §2.1 holds.  What must not be
+ *  claimed is that a node's profile is fixed for all time; it is fixed given
+ *  the corpus that has been seen.
+ *
+ *  THE NULL MODEL IS OTHERWISE UNTOUCHED (§4.1).  Every term is still a seeded
+ *  function of a NODE IDENTITY, never a gist, so no byte-similarity between
+ *  partners can leak content similarity into distributional similarity.  The
+ *  result is normalized, so ONE episode still pours ONE unit of mass:
+ *  {@link Store.haloMass} keeps counting episodes and every mass-based
+ *  reading is unchanged.  Two partners sharing j of k discriminating
+ *  constituents meet at j/(1+k) — graded evidence, above the 1/√D noise floor
+ *  and below conceptThreshold until the overlap is most of the content, which
+ *  is the semantics "same company" should have.
+ *
+ *  Bounded: at most {@link PROFILE_VISITS} constituents are classified, each
+ *  by ONE LIMITed structural-parent read, so a pour costs O(1) reads in the
+ *  partner's size and performs no scan. */
+function companyProfile(ctx: MindContext, id: number): Vec {
+  const acc = zeros(ctx.space.D);
+  addInto(acc, companySignature(ctx.space, id));
+  const bound = hubBound(ctx);
+  const k = profileCapacity(ctx.space.D);
+  const whole = Math.max(1, ctx.store.contentLen(id));
+  const sketch = constituentSketch(ctx, id, k);
+
+  // The two CORPUS-RELATIVE readings, applied here and never stored: which
+  // terms count as scaffolding moves as N grows, which is the drift documented
+  // above, while the sketch itself must stay intrinsic to remain valid.
+  let accepted = 0, hubDropped = 0, dominating = 0;
+  for (const n of sketch) {
+    const len = ctx.store.contentLen(n, whole);
+    if (dominates(len, whole)) {
+      dominating++;
+      continue;
+    }
+    if (ctx.store.parentsFirst(n, bound + 1).length > bound) {
+      hubDropped++;
+      continue;
+    }
+    addInto(acc, companySignature(ctx.space, n));
+    accepted++;
+  }
+
+  // FALSIFIABILITY.  The claim this function makes is that it stops because the
+  // representation is FULL, never because a budget ran out — so the diagnostics
+  // report the capacity, the mass actually reached, and what the frontier still
+  // held.  `residual` is the evidence NOT superposed; `marginal` is what one
+  // more term would have contributed to a downstream cosine (1/mass), and
+  // `saturated` says whether that had fallen to or below `noiseFloor`.  A run
+  // that reports `saturated: false` with `residual > 0` is this design being
+  // WRONG, not tuning: it would mean readable evidence was dropped.
+  const mass = accepted + 1; // the node's own signature counts
+  const marginal = 1 / mass;
+  const noiseFloor = estimatorNoise(ctx.space.D);
+  ctx.trace?.step(
+    "companyProfile",
+    [rNode(ctx, id, "partner")],
+    [rItem(new Uint8Array(0), "profile", id)],
+    `superposed ${accepted} of ${sketch.length} sketched constituents ` +
+      `(capacity ${k}); marginal ${marginal.toFixed(4)} vs noise floor ` +
+      `${noiseFloor.toFixed(4)}`,
+    undefined,
+    {
+      capacity: k,
+      sketched: sketch.length,
+      accepted,
+      hubDropped,
+      dominating,
+      residual: sketch.length - accepted,
+      mass,
+      marginal,
+      noiseFloor,
+      saturated: sketch.length >= k,
+      stopReason: sketch.length >= k ? "capacity" : "constituents-exhausted",
+      wholeLen: whole,
+    },
+  );
+  return normalize(acc);
+}
+
 /** Ingest a pair (context, continuation) — learn an edge and pour halos.
  *  Returns the deposited root ids (context, continuation) — a pure
  *  read-out; callers that ignore it behave exactly as before. */
@@ -255,14 +501,17 @@ export async function ingestPair(
   await propagateSuffixes(ctx, ctxId, contId);
 
   // Halos pour company SIGNATURES (identity), not gists (content) — see
-  // companySignature in sema.ts.
-  const contSeat = bindSeat(ctx.space, companySignature(ctx.space, contId), 1);
+  // companySignature in sema.ts — as a TYPE-level profile: the partner's own
+  // signature superposed with its discriminating constituents' (see
+  // companyProfile), so company is shared by what partners are MADE OF and
+  // not only by partner identity.
+  const contSeat = bindSeat(ctx.space, companyProfile(ctx, contId), 1);
   for (const part of c.changed) {
     const partId = c.ids.get(part)!;
     await ctx.store.pourHalo(partId, contSeat);
     await ctx.store.pourHalo(
       contId,
-      bindSeat(ctx.space, companySignature(ctx.space, partId), 0),
+      bindSeat(ctx.space, companyProfile(ctx, partId), 0),
     );
   }
   return { ctxId, contId };

package/src/mind/mechanisms/cast.ts

@@ -358,6 +358,38 @@ export async function counterfactualTransfer(
     }
   }
   const isRoot = (id: number) => roots.some((r) => r.anchor === id);
+  // VOICEABLE — a structure whose own learnt content a schema may SPEAK.
+  //
+  // The gate below asks only that the weave TOUCH a committed point.  That is
+  // the right question for MEMBERSHIP — a weave needs uncommitted structure to
+  // compare against; that is what an analogy IS — and the wrong one for
+  // VOICING: satisfied by any committed bystander, it lets every OTHER aligned
+  // point put its own learnt content into the answer while a root that
+  // contributed nothing holds the door open.  The refusal note below already
+  // states the principle — "CAST refuses to transfer through content the climb
+  // itself never settled on" — it was simply never asked of the structure a
+  // schema actually transfers THROUGH.
+  //
+  // Measured on a two-hop question over dialogue filler (N ~ 103,
+  // consensusFloor 5.13): the climb committed ONE root at vote 8.13, and
+  // substitution then voiced a filler deposit at vote 0.15 together with a
+  // second structure at 0.57 — neither committed, both an order of magnitude
+  // below the floor, while the licensing root supplied no bytes at all.
+  //
+  // OR THE QUERY NAMED IT.  Commitment is not the only warrant: a structure the
+  // asker QUOTED is content the query did ask about, whoever the climb settled
+  // on.  The naming test is the one redirection's own `named` list uses — an
+  // aligned run starting at the structure's OPENING bytes (`cs === 0`) — and
+  // NOT merely "has an aligned run", which every weave point has by
+  // construction.  Without this disjunct the gate refuses test/29 B3 ("what if
+  // the capital of France were Lyon?" must answer about Lyon), where the
+  // substitute is named outright and the climb never commits it.  This mirrors
+  // the pairing the comparison gate already makes with
+  // `!rootTrusted && !namedByQuery`.
+  const namedFromOpening = (p: Point): boolean =>
+    p.runs.some((r) => r.cs === 0 && usable(r.qs, r.qe));
+  const voiceable = (p: Point): boolean =>
+    isRoot(p.anchor) || namedFromOpening(p);
   // The weave must touch a COMMITTED point of attention: the dominant
   // structure itself, or another aligned point the climb committed to.
   if (!points.some((p) => isRoot(p.anchor))) {
@@ -540,6 +572,14 @@ export async function counterfactualTransfer(
       if (r.cs < quantum || !usable(r.qs, r.qe)) {
         return null;
       }
+      // The DISPLACED STRUCTURE is what this schema speaks — the answer is its
+      // tail past the seat plus its own continuation — so it must be
+      // voiceable.  Filtered HERE rather than after the argmax so an eligible
+      // structure with less depth still fires the schema, instead of an
+      // ineligible deepest candidate suppressing it outright.  The SUBJECT is
+      // deliberately not gated: `fillerOf` reads the QUERY's own bytes for it,
+      // so it contributes what the asker already said, not learnt content.
+      if (!voiceable(p)) return null;
       const before = beforeOf(p, r);
       if (before === undefined) return null;
       if (r.cs > fillerOf(before.point, before.run).length + quantum) {
@@ -640,7 +680,14 @@ export async function counterfactualTransfer(
   const domNext = ctx.store.nextFirst(dominant.anchor, hubBound(ctx));
   const displaced = domNext
     .every((n) => indexOf(query, read(ctx, n), 0) < 0);
-  if (last !== undefined && last.point !== dominant && displaced) {
+  // The SUBSTITUTE is what redirection speaks — the answer IS `project(last)`,
+  // its own fact — so the same bar applies.  The displaced structure is only
+  // recognised as the slot being overridden and is never voiced, so it is
+  // deliberately not gated here.
+  if (
+    last !== undefined && last.point !== dominant && displaced &&
+    voiceable(last.point)
+  ) {
     const g = await project(ctx, last.point.anchor, qv);
     if (g !== null) {
       ctx.trace?.step(

package/src/mind/mind.ts

@@ -1011,10 +1011,21 @@ export class Mind implements MindContext {
     input: Input | (Input | [Input, Input])[],
     second?: Input,
     onDeposit?: (report: import("./learning.js").DepositReport) => void,
+    /** Witness the DEPOSIT path the way {@link respond}'s callback witnesses
+     *  inference — `companyProfile` reports its saturation diagnostics here.
+     *  Without it the tracer is never constructed and the emit sites cost
+     *  nothing (§ rationale.ts), exactly as on the inference path. */
+    inspectRationale?: InspectRationale,
   ): Promise<(Sema & { id: number }) | undefined> {
     invalidateStructuralCaches(this);
     invalidateJunctionCache(this);
-    return ingest(this, input, second, onDeposit);
+    const prevTrace = this.trace;
+    this.trace = inspectRationale ? new Rationale(inspectRationale) : null;
+    try {
+      return await ingest(this, input, second, onDeposit);
+    } finally {
+      this.trace = prevTrace;
+    }
   }
 
   // ── Extension Surface ────────────────────────────────────────────────────

package/src/mind/reasoning.ts

@@ -52,7 +52,6 @@ export async function reason(
   const qId = pre.queryResolved;
   if (qId !== null && ctx.store.prevCount(qId) > 0) return answer;
 
-  const consumed = new Set<number>();
   // Consume a node and its neighbours for pivot-cycle prevention — CAPPED at
   // the hub bound, via the store's LIMITed edge reads: a common continuation's
   // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
@@ -61,10 +60,68 @@ export async function reason(
   // read order); a pivot suppressed only by a beyond-cap neighbour may now
   // fire — the same visibility trade chooseNext documents.
   const bound = hubBound(ctx);
-  const consumeNode = (id: number | null) => {
+
+  // ANSWERED DIRECTLY — the echo guard's other half, and the same principle:
+  // the QUERY's own position in the graph, not the answer's content, says the
+  // read-out is complete.  Above: the query is itself a learnt CONTINUATION.
+  // Here: the query is a learnt CONTEXT and the grounded answer is one of ITS
+  // OWN continuations.  Either way the question was answered directly and there
+  // is nothing left to chain for.
+  //
+  // Every stopping condition in the loop below judges the ANSWER (`consumed` /
+  // `restatesQuery` / `bytesEqual`); none asks whether the QUESTION was
+  // satisfied.  So a single-hop question whose answer happens to name another
+  // learnt context extends past a correct answer and REPLACES it:
+  //
+  //   asked  "<subj> father"
+  //   hop 1  "The father of <subj> is Ernest I of Anhalt-Dessau."   <- correct
+  //   pivot  "Ernest I of Anhalt-Dessau"                <- a learnt context too
+  //   got    "The date of death of Ernest I of Anhalt-Dessau is 12 June 1516."
+  //
+  // Any store holding a bare-entity context alongside a relation fact has that
+  // shape; it is not exotic.
+  //
+  // Checked ONCE, before the loop, and ahead of BOTH extension branches:
+  // `absorbForward` extends the answer too, and nothing about the defect is
+  // specific to pivoting, so a guard between them would gate one arbitrary half
+  // of the same step.  Hop 0 is also the only hop at which the question can be
+  // answered directly at all — after a hop, `cur` is no longer the query's own
+  // continuation, so re-testing per hop could only cost reads.
+  //
+  // Read from the ANSWER's side (`prevFirst`) rather than the query's
+  // (`nextFirst`).  Same relation, but a CONTEXT's fan-out is hub-sized while
+  // this is one answer's establishing-context fan-in.  Both the resolve and the
+  // reverse read are exactly what hop 0 of the loop below would perform, so
+  // they are computed ONCE here and handed down (`groundedId`, `groundedPrev`)
+  // — the guard then costs nothing when it does not fire.  Stated because the
+  // naive placement does NOT: `resolve` re-folds the answer bytes on every call
+  // (no memo) and `prevFirst` is a direct read (no memo), so a guard that
+  // recomputed them would add one fold plus one √N-bounded read per ask.
+  // The √N cap carries the file-wide visibility trade, and fails SAFE in the
+  // direction that matters: a missed guard costs an over-extended answer, never
+  // a suppressed chain.
+  //
+  // A genuine multi-hop query is not a deposited context at all ("What is the
+  // capital of the country of Eiffel Tower?" resolves to nothing), so this can
+  // never gate a real chain.
+  const groundedId = resolve(ctx, answer);
+  const groundedPrev = groundedId === null
+    ? null
+    : ctx.store.prevFirst(groundedId, bound);
+  if (qId !== null && groundedPrev !== null && groundedPrev.includes(qId)) {
+    return answer;
+  }
+
+  const consumed = new Set<number>();
+  /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
+   *  reuses the guard's, above, instead of re-reading it. */
+  const consumeNode = (
+    id: number | null,
+    prev?: readonly number[],
+  ) => {
     if (id === null) return;
     consumed.add(id);
-    for (const p of ctx.store.prevFirst(id, bound)) consumed.add(p);
+    for (const p of prev ?? ctx.store.prevFirst(id, bound)) consumed.add(p);
   };
   const consumeAll = (id: number | null) => {
     if (id === null) return;
@@ -99,8 +156,10 @@ export async function reason(
   let t: ReturnType<Rationale["enter"]> | undefined;
   const startedFrom = answer;
   for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
-    const curId = resolve(ctx, cur);
-    consumeNode(curId);
+    // Hop 0's `cur` IS `answer`, so the guard above already resolved it and
+    // read its reverse edges — reuse both rather than repeat them.
+    const curId = hop === 0 ? groundedId : resolve(ctx, cur);
+    consumeNode(curId, hop === 0 ? groundedPrev ?? undefined : undefined);
 
     // Forward-absorb: follow only UNCONSUMED continuations.  The gate below
     // checks an unconsumed edge EXISTS, but follow()'s chooseNext knows