@hviana/sema 0.5.7 → 0.5.9

package/dist/src/geometry.d.ts

@@ -86,6 +86,26 @@ export declare 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 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

package/dist/src/geometry.js

@@ -121,6 +121,28 @@ export function dominates(partLen, wholeLen) {
  *  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) {
+    return Math.max(1, Math.floor(Math.sqrt(D)));
+}
 export function consensusFloor(N) {
     return Math.log(N) + 1 / 2;
 }

package/dist/src/mind/articulation.js

@@ -4,7 +4,7 @@
 //                using concept (halo) resonance to match the voices.
 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 { coverSequence } from "../derive/src/index.js";
 import { rItem, rNode, traceDerivation } from "./trace.js";
@@ -67,9 +67,22 @@ export async function articulate(ctx, answer, query) {
         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/dist/src/mind/attention.d.ts

@@ -87,6 +87,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[];
     };
 }

package/dist/src/mind/attention.js

@@ -1169,7 +1169,7 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
     const floor = consensusFloor(N);
     const placed = [];
     const roots = [];
-    const recordAnchor = (point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, rejectionReasons) => {
+    const recordAnchor = (point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, tiedWithDominant, rejectionReasons) => {
         if (!td)
             return;
         td.anchors.push({
@@ -1189,6 +1189,7 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
                 passesNaturalBreak,
                 passesConsensusFloor,
                 pastLeadingSaturation,
+                tiedWithDominant,
                 rejectionReasons,
             },
         });
@@ -1204,6 +1205,7 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
         let passesNaturalBreak;
         let passesConsensusFloor;
         let pastLeadingSaturation;
+        let tiedWithDominant;
         const rejectionReasons = [];
         if (absorbed) {
             status = "overlap";
@@ -1229,7 +1231,45 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
             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 {
@@ -1247,11 +1287,11 @@ export function commitVotes(ctx, pooled, sat, regions, regionVoter, N, td, cfg)
                 roots.push(point);
             }
             else {
-                recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, rejectionReasons);
+                recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, tiedWithDominant, rejectionReasons);
                 continue;
             }
         }
-        recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, rejectionReasons);
+        recordAnchor(point, rank, status, dominant, passesNaturalBreak, passesConsensusFloor, pastLeadingSaturation, tiedWithDominant, rejectionReasons);
         placed.push(point);
     }
     traceAttention(ctx, regions, regionVoter, roots, steps, td, cfg ? { ...cfg, naturalBreak: rootCut, consensusFloor: floor } : undefined, ranked);

package/dist/src/mind/learning.js

@@ -2,10 +2,14 @@
 //
 //   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 { addInto, normalize, zeros } from "../vec.js";
 import { bindSeat, companySignature, isChunk } from "../sema.js";
 import { changedNodes } from "./types.js";
 import { inputBytes, perceiveDeposit, 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.
  *  Returns the root node id and a map from tree nodes to their ids.
@@ -188,6 +192,246 @@ async function propagateSuffixes(ctx, src, dst) {
         await ctx.store.link(id, dst);
     }
 }
+/** 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) {
+    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, n, W) {
+    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, id, k) {
+    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;
+    if (kids == null) {
+        out = [];
+    }
+    else {
+        const pool = [];
+        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();
+        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, id) {
+    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. */
@@ -203,12 +447,15 @@ export async function ingestPair(ctx, ctxInput, cont) {
     await ctx.store.link(ctxId, contId);
     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));
+        await ctx.store.pourHalo(contId, bindSeat(ctx.space, companyProfile(ctx, partId), 0));
     }
     return { ctxId, contId };
 }

package/dist/src/mind/mechanisms/cast.js

@@ -301,6 +301,36 @@ export async function counterfactualTransfer(ctx, query, pre) {
         }
     }
     const isRoot = (id) => 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) => p.runs.some((r) => r.cs === 0 && usable(r.qs, r.qe));
+    const voiceable = (p) => 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))) {
@@ -450,6 +480,15 @@ export async function counterfactualTransfer(ctx, query, pre) {
         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;
@@ -534,7 +573,12 @@ export async function counterfactualTransfer(ctx, query, pre) {
     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("projectCounterfactual", [

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

@@ -345,7 +345,12 @@ export declare class Mind implements MindContext {
     /** See {@link import("./learning.js").ingest} — `onDeposit`, when given,
      *  reports each ingested item's deposited root node ids
      *  ({@link DepositReport}); purely observational. */
-    ingest(input: Input | (Input | [Input, Input])[], second?: Input, onDeposit?: (report: import("./learning.js").DepositReport) => void): Promise<(Sema & {
+    ingest(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>;
     private extensionHost;

package/dist/src/mind/mind.js

@@ -644,10 +644,22 @@ export class Mind {
     /** See {@link import("./learning.js").ingest} — `onDeposit`, when given,
      *  reports each ingested item's deposited root node ids
      *  ({@link DepositReport}); purely observational. */
-    async ingest(input, second, onDeposit) {
+    async ingest(input, second, onDeposit, 
+    /** 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) {
         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 ────────────────────────────────────────────────────
     extensionHost() {