@hviana/sema 0.5.7 → 0.5.8

package/HOW_IT_WORKS.md

@@ -512,6 +512,73 @@ similarity into _distributional_ similarity, silently shifting the halo null
 model that the concept threshold's derivation (unrelated halos ⇒ cosine 0 ±
 1/√D) depends on.
 
+#### Company must be keyed on types, not tokens
+
+A signature derived from the _whole_ partner's node id records a **token**:
+"occurred next to node #4711992". But the distributional hypothesis is a claim
+about **types**: "occurred next to a city name". On a content-addressed store of
+natural language the difference is fatal, because a whole deposit essentially
+never repeats: on a trained 15.7M-node store, 331,110 trained pairs produced
+325,615 distinct contexts — 98.3% of them unique, so barely one span in sixty
+ever recurs. Two genuine synonyms in different sentences then share no partner
+id at all, and their halos come out quasi-orthogonal _by construction_: the best
+distributional sibling of "Eiffel Tower" measured 0.146 against a concept
+threshold of 0.516, with its own attested translations absent entirely. The
+whole concept-hop, articulation and analogy layer was inert at corpus scale —
+not for want of data, but because the key was too fine.
+
+Sema therefore pours a **company profile**: the partner's own signature
+superposed with the signatures of the partner's _constituents_. Two episodes
+then share halo mass exactly when their partners are **made of** something in
+common, which is what "keeps similar company" was always meant to mean.
+
+Which constituents count is decided by four rules, each one load-bearing:
+
+- **Every depth, not just the partner's children.** 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 child of neither. Reading only
+  the children merely moves the token problem from whole-partner identity down
+  to top-level-chunk identity, which for full sentences is nearly as rare. The
+  descent finds `Paris` and `ffel`; the top level finds nothing.
+- **Never gate on recurrence-so-far.** The tempting rule — descend while a
+  constituent is corpus-unique, stop at the first unit attested twice — is
+  order-dependent: when the _first_ of a pair is deposited its shared unit has
+  been seen once, so the descent runs past it, and only the second partner ever
+  profiles it. Whether two synonyms become siblings must not depend on which was
+  taught first. The hub test below is the one reading that does consult corpus
+  state, and it can only ever remove a term — never decide which units are
+  found.
+- **Nothing narrower than the fold's own window `W`.** Sub-window shards are
+  fragments of a unit, not units; admitting them lets mid-frequency byte
+  coincidences leak company across unrelated domains.
+- **Minimal units only, and nothing that half-dominates the partner.** A
+  constituent that still contains a constituent of its own is a composite, and
+  superposing both counts the same content twice. This matters most for _nested_
+  partners — an accumulated conversation, where turn _k_'s context is a prefix
+  of turn _k+1_'s — which share their large chunks structurally rather than
+  distributionally.
+
+Hubs (more than √N structural parents — Section 8.8) are excluded as
+scaffolding, since a term shared by every deposit would put a common component
+in every profile and collapse the null model the concept threshold depends on.
+Byte atoms are excluded for the same reason: an atom's fan-in is the alphabet's.
+
+The result stays **normalized**, so one episode still pours one unit of mass and
+every mass-based reading is unchanged; and every term is still a seeded function
+of a **node identity**, never a gist, so the hygiene rule above is untouched.
+
+Similarity is **graded and size-relative**: two partners meet in proportion to
+how much of what they are made of they share, so a shared unit inside a long
+partner says less than the same unit inside a short one. This is the honest
+reading of the evidence, not a defect — but it means the layer speaks clearly at
+sentence scale and softly for very long partners. One further honest limit: the
+hub bound is √N, so on a _small_ store almost nothing reads as scaffolding and
+frame words do enter profiles. That is the correct floor for a corpus that
+cannot yet say what discriminates, and it resolves itself as N grows.
+
 Two nodes whose halos are similar have occurred in similar circumstances — they
 are **distributional siblings**: synonyms, paraphrases, items of the same
 category, two names for one thing. Note the complementarity:
@@ -532,6 +599,13 @@ embedding model:
   rule).
 - **Articulation.** An answer is re-voiced in the asker's own vocabulary by
   substituting answer forms with query forms that share a halo (Section 24).
+  Halo similarity alone is not sufficient authority for this: the strongest
+  company any two forms can keep is standing next to each other, so a question
+  and the answer it is answered by are _maximally_ similar distributionally. Two
+  exact-side vetoes keep that from being read as synonymy — a stored
+  continuation edge between the two forms, and a candidate form spanning the
+  _whole_ answer (substituting that is replacement, not re-voicing). Without
+  them, "it hangs in madrid" is faithfully re-voiced as "where is it kept now".
 - **Analogy strength.** Whether two entities are genuinely analogous — the gate
   on counterfactual comparison (Section 18) — is measured by halo similarity,
   directly or through shared siblings (a second-order distributional test).

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/learning.js

@@ -2,10 +2,13 @@
 //
 //   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 { hubBound } from "./traverse.js";
+import { dominates } 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 +191,163 @@ async function propagateSuffixes(ctx, src, dst) {
         await ctx.store.link(id, dst);
     }
 }
+/** How many constituents one profile may VISIT.  A partner's constituent tree
+ *  is O(len/W) nodes, so an uncapped descent would make a pour cost grow with
+ *  the partner's LENGTH — and a partner is a whole deposit, which may be a
+ *  paragraph.  The budget is what keeps a pour O(1) in the input, the property
+ *  that lets {@link companyProfile} claim no new cost class.  It binds only on
+ *  long partners whose constituents are all corpus-unique; the descent's own
+ *  stop rule (below) reaches recurring units far sooner on a trained store. */
+const PROFILE_VISITS = 64;
+/** 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 W = ctx.space.maxGroup;
+    const whole = Math.max(1, ctx.store.contentLen(id));
+    const frontier = [];
+    const seen = new Set([id]);
+    const descend = (n) => {
+        const kids = ctx.store.get(n)?.kids;
+        if (!kids)
+            return;
+        for (const kid of kids)
+            if (!seen.has(kid))
+                frontier.push(kid);
+    };
+    descend(id);
+    for (let visits = 0; visits < PROFILE_VISITS && frontier.length > 0;) {
+        const n = frontier.shift();
+        if (seen.has(n))
+            continue;
+        seen.add(n);
+        visits++;
+        // Atoms in both representations — negative id, or a stored kid-less node.
+        if (n < 0 || ctx.store.get(n)?.kids == null)
+            continue;
+        descend(n);
+        const len = ctx.store.contentLen(n, whole);
+        if (len < W || dominates(len, whole))
+            continue;
+        // MINIMAL units only: a constituent that still has a constituent of its
+        // own at or above W is a composite, and superposing it as well as its
+        // parts would count the same content twice.  Nested partners — an
+        // accumulated conversation, where turn k's context is a prefix of turn
+        // k+1's — share their large chunks structurally rather than
+        // distributionally, so those composites are exactly the terms that make
+        // adjacent turns read as synonyms (measured: consecutive turns at 0.809
+        // and 0.740 against a 0.516 concept threshold).  The smallest units at or
+        // above the fold's own window are the word-sized types company should be
+        // keyed at.
+        const kids = ctx.store.get(n).kids;
+        let composite = false;
+        for (const kid of kids) {
+            if (kid >= 0 && ctx.store.contentLen(kid, W) >= W)
+                composite = true;
+        }
+        if (composite)
+            continue;
+        if (ctx.store.parentsFirst(n, bound + 1).length > bound)
+            continue;
+        addInto(acc, companySignature(ctx.space, n));
+    }
+    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 +363,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/traverse.d.ts

@@ -80,6 +80,24 @@ export declare function hubCap<T>(ctx: MindContext, ids: readonly T[]): readonly
  *  descent.  Used by articulation to keep a voice from revoicing a fragment
  *  OF that voice. */
 export declare function contains(ctx: MindContext, ancestor: number, descendant: number): boolean;
+/** Whether a continuation edge joins the two forms, in either direction —
+ *  the EXACT half's veto on calling them synonyms.
+ *
+ *  Halos measure company, and the strongest company any two forms can keep is
+ *  standing next to each other: a question and its answer co-occur in every
+ *  episode that taught the pair, so their halos SHOULD be similar, and on a
+ *  conversational store they are (measured on the CONV fixture: consecutive
+ *  turns at 0.809 against a 0.516 concept threshold).  A gate reading halo
+ *  cosine alone therefore reads adjacency as synonymy and revoices an answer
+ *  in the words of the question it answers — "it hangs in madrid" spliced back
+ *  into "where is it kept now".  The distributional layer cannot tell the two
+ *  relations apart, because to it they are the same observation; the exact
+ *  half can, for free, because it stored the edge.  §4.1's division of labour
+ *  exactly: approximate proposes, exact decides.
+ *
+ *  Read LIMITed in both directions at the hub bound — a common continuation's
+ *  fan-in is corpus-sized, and no single decision may scale with it. */
+export declare function answers(ctx: MindContext, a: number, b: number): boolean;
 /** The best-scoring item by cosine against `query`, among items scoring at
  *  or above `threshold` — the shared arg-max every Pattern-A "which of these
  *  resonates best" decision reduces to.  `strict` picks the tie-break a

package/dist/src/mind/traverse.js

@@ -490,6 +490,30 @@ export function contains(ctx, ancestor, descendant) {
     }
     return false;
 }
+/** Whether a continuation edge joins the two forms, in either direction —
+ *  the EXACT half's veto on calling them synonyms.
+ *
+ *  Halos measure company, and the strongest company any two forms can keep is
+ *  standing next to each other: a question and its answer co-occur in every
+ *  episode that taught the pair, so their halos SHOULD be similar, and on a
+ *  conversational store they are (measured on the CONV fixture: consecutive
+ *  turns at 0.809 against a 0.516 concept threshold).  A gate reading halo
+ *  cosine alone therefore reads adjacency as synonymy and revoices an answer
+ *  in the words of the question it answers — "it hangs in madrid" spliced back
+ *  into "where is it kept now".  The distributional layer cannot tell the two
+ *  relations apart, because to it they are the same observation; the exact
+ *  half can, for free, because it stored the edge.  §4.1's division of labour
+ *  exactly: approximate proposes, exact decides.
+ *
+ *  Read LIMITed in both directions at the hub bound — a common continuation's
+ *  fan-in is corpus-sized, and no single decision may scale with it. */
+export function answers(ctx, a, b) {
+    const bound = hubBound(ctx);
+    if (ctx.store.hasNext(a) && ctx.store.nextFirst(a, bound).includes(b)) {
+        return true;
+    }
+    return ctx.store.hasNext(b) && ctx.store.nextFirst(b, bound).includes(a);
+}
 // ── Edge disambiguation (Section 6) ──────────────────────────────────────
 /** The best-scoring item by cosine against `query`, among items scoring at
  *  or above `threshold` — the shared arg-max every Pattern-A "which of these

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

package/package.json

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

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/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,8 @@ import {
   resolve,
 } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
+import { hubBound } from "./traverse.js";
+import { dominates } from "../geometry.js";
 import { fold as foldVecs } from "../sema.js";
 
 /** Intern a perceived tree into node ids, bottom-up, sharing equal subtrees.
@@ -233,6 +235,156 @@ export interface DepositReport {
   continuationId?: number;
 }
 
+/** How many constituents one profile may VISIT.  A partner's constituent tree
+ *  is O(len/W) nodes, so an uncapped descent would make a pour cost grow with
+ *  the partner's LENGTH — and a partner is a whole deposit, which may be a
+ *  paragraph.  The budget is what keeps a pour O(1) in the input, the property
+ *  that lets {@link companyProfile} claim no new cost class.  It binds only on
+ *  long partners whose constituents are all corpus-unique; the descent's own
+ *  stop rule (below) reaches recurring units far sooner on a trained store. */
+const PROFILE_VISITS = 64;
+
+/** 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 W = ctx.space.maxGroup;
+  const whole = Math.max(1, ctx.store.contentLen(id));
+  const frontier: number[] = [];
+  const seen = new Set<number>([id]);
+  const descend = (n: number) => {
+    const kids = ctx.store.get(n)?.kids;
+    if (!kids) return;
+    for (const kid of kids) if (!seen.has(kid)) frontier.push(kid);
+  };
+  descend(id);
+  for (let visits = 0; visits < PROFILE_VISITS && frontier.length > 0;) {
+    const n = frontier.shift()!;
+    if (seen.has(n)) continue;
+    seen.add(n);
+    visits++;
+    // Atoms in both representations — negative id, or a stored kid-less node.
+    if (n < 0 || ctx.store.get(n)?.kids == null) continue;
+    descend(n);
+    const len = ctx.store.contentLen(n, whole);
+    if (len < W || dominates(len, whole)) continue;
+    // MINIMAL units only: a constituent that still has a constituent of its
+    // own at or above W is a composite, and superposing it as well as its
+    // parts would count the same content twice.  Nested partners — an
+    // accumulated conversation, where turn k's context is a prefix of turn
+    // k+1's — share their large chunks structurally rather than
+    // distributionally, so those composites are exactly the terms that make
+    // adjacent turns read as synonyms (measured: consecutive turns at 0.809
+    // and 0.740 against a 0.516 concept threshold).  The smallest units at or
+    // above the fold's own window are the word-sized types company should be
+    // keyed at.
+    const kids = ctx.store.get(n)!.kids!;
+    let composite = false;
+    for (const kid of kids) {
+      if (kid >= 0 && ctx.store.contentLen(kid, W) >= W) composite = true;
+    }
+    if (composite) continue;
+    if (ctx.store.parentsFirst(n, bound + 1).length > bound) continue;
+    addInto(acc, companySignature(ctx.space, n));
+  }
+  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 +407,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/traverse.ts

@@ -558,6 +558,35 @@ export function contains(
   return false;
 }
 
+/** Whether a continuation edge joins the two forms, in either direction —
+ *  the EXACT half's veto on calling them synonyms.
+ *
+ *  Halos measure company, and the strongest company any two forms can keep is
+ *  standing next to each other: a question and its answer co-occur in every
+ *  episode that taught the pair, so their halos SHOULD be similar, and on a
+ *  conversational store they are (measured on the CONV fixture: consecutive
+ *  turns at 0.809 against a 0.516 concept threshold).  A gate reading halo
+ *  cosine alone therefore reads adjacency as synonymy and revoices an answer
+ *  in the words of the question it answers — "it hangs in madrid" spliced back
+ *  into "where is it kept now".  The distributional layer cannot tell the two
+ *  relations apart, because to it they are the same observation; the exact
+ *  half can, for free, because it stored the edge.  §4.1's division of labour
+ *  exactly: approximate proposes, exact decides.
+ *
+ *  Read LIMITed in both directions at the hub bound — a common continuation's
+ *  fan-in is corpus-sized, and no single decision may scale with it. */
+export function answers(
+  ctx: MindContext,
+  a: number,
+  b: number,
+): boolean {
+  const bound = hubBound(ctx);
+  if (ctx.store.hasNext(a) && ctx.store.nextFirst(a, bound).includes(b)) {
+    return true;
+  }
+  return ctx.store.hasNext(b) && ctx.store.nextFirst(b, bound).includes(a);
+}
+
 // ── Edge disambiguation (Section 6) ──────────────────────────────────────
 
 /** The best-scoring item by cosine against `query`, among items scoring at

package/test/76-type-level-company.test.mjs

@@ -0,0 +1,342 @@
+// 76 — TYPE-LEVEL COMPANY (the halo pour's constituent profile).
+//
+// What is under test is ONE claim: two forms become distributional siblings
+// when their partners are MADE OF a shared content unit, even though the
+// partners share no node at the top of the fold.  That is the difference
+// between a halo keyed on a TOKEN ("occurred next to node #4711992") and one
+// keyed on a TYPE ("occurred next to something containing 'Paris'").
+//
+// WHY THESE TESTS CANNOT PASS BY ACCIDENT.  Every positive assertion is paired
+// with a NEGATIVE CONTROL drawn from the same fixture, trained in the same
+// store, of the same shape and comparable length — so a change that merely
+// made all halos correlate (the null model collapsing) fails the control
+// instead of passing the positive.  Every bar is DERIVED from D, never tuned:
+// `significanceBar` (3/√D) for "this is not chance" and `conceptThreshold` for
+// "these are the same concept".  And T1 computes, in-test, the fact that makes
+// the whole file a test of the constituent descent rather than of halos in
+// general: the two partners' depth-1 constituent sets are DISJOINT, so a
+// profile reading only `rec.kids` has literally nothing in common to find.
+//
+// WHAT EACH TEST IS, STATED HONESTLY.  T1 and T2 are the CAPABILITY tests:
+// run against the previous depth-1 profile they fail, on the capability
+// assertion itself and not on a precondition — measured -0.0086 against the
+// 0.0938 bar, while the fixture's own preconditions still passed, so the
+// failure is the missing capability and nothing else.  T3, T4 and T5 pass
+// under BOTH implementations by construction: they are not evidence for the
+// capability, they are the invariants it must not buy itself with, and each
+// one pins a regression this work actually hit — the null model collapsing
+// when the descent superposed scaffolding, mass tracking constituents instead
+// of episodes, and the profile being read from the deposit's id map instead
+// of the store.  Claiming all five as proof of the capability would be false;
+// dropping the three would leave the two unfalsifiable.
+//
+// WHAT IS DELIBERATELY NOT TESTED HERE, AND WHY.  A sixth test asserting that
+// company GRADES with shared content (more shared units => more company) was
+// written and removed: it is false as stated.  Cosine normalizes by profile
+// size, so a pair sharing 3 constituents out of a larger profile scores BELOW
+// a pair sharing 1 out of a smaller one — measured at 0.085 against 0.111,
+// consistently across all four seeds.  The design's own `shared / (1 + k)`
+// reading is size-RELATIVE, and asserting the absolute form encodes a law the
+// system does not obey.  Testing the relative form from outside would require
+// re-deriving the profile's term-selection rules inside the test, which makes
+// the test a mirror of the implementation and worthless as a check on it.
+//
+// Also untested, and a real limitation rather than an oversight: on a store
+// this small the hub bound √N is large enough that frame scaffolding is not
+// excluded, so short partners sharing only a frame do keep some company.  That
+// is the documented honest floor — a corpus that cannot yet say what
+// discriminates — but it means these fixtures must share genuine CONTENT
+// units, which T1 now asserts rather than assumes.
+//
+// Each test pins a DIFFERENT rule.  Deleting any one of them lets a specific,
+// named regression back in; none of them subsumes another.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  conceptThreshold,
+  cosine,
+  Mind,
+  significanceBar,
+} from "../dist/src/index.js";
+
+const D = 1024;
+const BAR = significanceBar(D); // 3/√D — above chance
+const enc = new TextEncoder();
+
+// Company signatures key on NODE ID, not on the alphabet, so a seeded
+// keyring cannot be what makes these comparisons come out — but that is an
+// argument, and the capability tests below check it instead, across seeds.
+const SEEDS = [7, 1, 42, 99];
+const newMind = (seed = 7) => new Mind({ seed, D });
+const idOf = (m, s) => m.resolve(enc.encode(s));
+const haloOf = (m, s) => {
+  const id = idOf(m, s);
+  return id === null || id === undefined ? null : m.store.halo(id);
+};
+
+/** The halo read must work at all before any comparison means anything.  A
+ *  missing halo silently makes every cosine below unreachable, and a broken
+ *  one makes them meaningless — this is the control whose absence has voided
+ *  whole investigations on this codebase. */
+const assertHaloControl = (m, cues) => {
+  for (const c of cues) {
+    const h = haloOf(m, c);
+    assert.ok(h, `CONTROL: no halo poured for ${JSON.stringify(c)}`);
+    assert.ok(
+      Math.abs(cosine(h, h) - 1) < 1e-9,
+      `CONTROL: halo of ${JSON.stringify(c)} is not self-identical`,
+    );
+  }
+};
+
+/** The continuation a cue was trained with, as a node id. */
+const partnerOf = (m, cue) => m.store.next(idOf(m, cue))[0];
+
+/** Depth-1 constituents — what a profile reading only `rec.kids` would see. */
+const depth1 = (m, node) => new Set(m.store.get(node)?.kids ?? []);
+
+/** Every constituent reachable below `node`, to a depth the fold cannot
+ *  exceed for these fixtures — what the descent can see. */
+const deepConstituents = (m, node, depth = 6, out = new Set()) => {
+  if (depth === 0) return out;
+  for (const k of m.store.get(node)?.kids ?? []) {
+    if (k < 0) continue;
+    out.add(k);
+    deepConstituents(m, k, depth - 1, out);
+  }
+  return out;
+};
+
+const intersect = (a, b) => [...a].filter((x) => b.has(x));
+
+// ═══════════════════════════════════════════════════════════════════════════
+// T1 — THE CAPABILITY, with its own impossibility proof for the old rule.
+//
+// Two sentences in different languages that both mention Paris.  Content-
+// defined cuts put the shared unit in DIFFERENT top-level chunks:
+//   "The Eiffel Tower is in Paris"  ->  "The Eiffel " · "Tower is in Paris"
+//   "Tour Eiffel dia any Paris"     ->  "Tour Eiffel " · "dia any Paris"
+// so their depth-1 constituents are disjoint — asserted below, not assumed.
+// ═══════════════════════════════════════════════════════════════════════════
+test("T1: partners sharing a unit BELOW the top of the fold keep company", async () => {
+  for (const seed of SEEDS) {
+    const m = newMind(seed);
+    await m.ingest([
+      ["cue_en", "The Eiffel Tower is in Paris"],
+      ["cue_mg", "Tour Eiffel dia any Paris"],
+      ["cue_zz", "Bananas are grown in humid climates"],
+    ]);
+    assertHaloControl(m, ["cue_en", "cue_mg", "cue_zz"]);
+
+    const pEn = partnerOf(m, "cue_en");
+    const pMg = partnerOf(m, "cue_mg");
+
+    // THE IMPOSSIBILITY PROOF.  A profile built from `rec.kids` alone sees these
+    // sets and nothing else; they do not intersect, so no depth-1 rule — however
+    // weighted, however filtered — can make these two partners share a term.
+    // This test therefore measures the DESCENT, not halos in general.
+    assert.equal(
+      intersect(depth1(m, pEn), depth1(m, pMg)).length,
+      0,
+      "fixture no longer exercises the descent: the two partners now share a " +
+        "depth-1 constituent, so a depth-1 profile could pass T1 as well",
+    );
+    // And the units the descent is supposed to find must actually be there —
+    // AND be eligible to become profile terms.  A fixture whose only shared
+    // constituents are sub-window shards or frame scaffolding measures frame
+    // similarity while reading like a content test; one was written during this
+    // work and passed for exactly that wrong reason.  The shared unit must be
+    // at least the fold's own window wide.
+    const W = m.space.maxGroup;
+    const shared = intersect(
+      deepConstituents(m, pEn),
+      deepConstituents(m, pMg),
+    );
+    assert.ok(
+      shared.some((n) => m.store.contentLen(n, W) >= W),
+      `fixture is broken: the partners share no constituent of at least W=${W} ` +
+        `bytes, so nothing they share can enter a profile`,
+    );
+
+    const related = cosine(haloOf(m, "cue_en"), haloOf(m, "cue_mg"));
+    const control = cosine(haloOf(m, "cue_en"), haloOf(m, "cue_zz"));
+
+    assert.ok(
+      related >= BAR,
+      `seed ${seed}: partners sharing a content unit must keep measurable ` +
+        `company: got ${related.toFixed(4)}, need >= ${
+          BAR.toFixed(4)
+        } (3/sqrt(D))`,
+    );
+    // The control is what makes the line above falsifiable: without it, a
+    // regression that made EVERY halo correlate would pass.
+    assert.ok(
+      control < BAR,
+      `seed ${seed}: partners sharing nothing must stay at chance: got ` +
+        `${control.toFixed(4)}, need < ${
+          BAR.toFixed(4)
+        } — null model collapsed`,
+    );
+    await m.store.close();
+  }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// T2 — ORDER INDEPENDENCE.
+//
+// The tempting stop rule ("descend while a constituent is corpus-unique, stop
+// at the first one attested twice") passes T1 in exactly one training order
+// and fails in the other: when the FIRST partner is poured its shared unit has
+// fan-in 1, so the descent runs past it and only the second partner ever
+// profiles it.  Whether two forms become siblings must not depend on which was
+// taught first.
+// ═══════════════════════════════════════════════════════════════════════════
+test("T2: company does not depend on which partner was taught first", async () => {
+  const measure = async (first, second, seed) => {
+    const m = newMind(seed);
+    await m.ingest([
+      [first[0], first[1]],
+      [second[0], second[1]],
+      ["cue_zz", "Bananas are grown in humid climates"],
+    ]);
+    assertHaloControl(m, ["cue_en", "cue_mg", "cue_zz"]);
+    return {
+      related: cosine(haloOf(m, "cue_en"), haloOf(m, "cue_mg")),
+      control: cosine(haloOf(m, "cue_en"), haloOf(m, "cue_zz")),
+    };
+  };
+  const EN = ["cue_en", "The Eiffel Tower is in Paris"];
+  const MG = ["cue_mg", "Tour Eiffel dia any Paris"];
+
+  for (const seed of SEEDS) {
+    const forward = await measure(EN, MG, seed);
+    const reverse = await measure(MG, EN, seed);
+
+    for (const [name, r] of [["forward", forward], ["reverse", reverse]]) {
+      assert.ok(
+        r.related >= BAR,
+        `seed ${seed} ${name} order: shared-unit company must survive ` +
+          `training order — got ${r.related.toFixed(4)}, need >= ` +
+          `${BAR.toFixed(4)}`,
+      );
+      assert.ok(
+        r.control < BAR,
+        `seed ${seed} ${name} order: control must stay at chance, got ` +
+          `${r.control.toFixed(4)}`,
+      );
+    }
+  }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// T3 — THE NULL MODEL SURVIVES.
+//
+// The failure mode opposite to T1's: a descent that superposed everything it
+// walked past would put terms shared by every deposit into every profile, and
+// ALL halos would correlate.  That regression passes T1 handsomely.  Here a
+// population of mutually unrelated partners must stay mutually at chance —
+// and, because it is the same store, T1's positive is re-checked against this
+// population's own noise level rather than against a bar alone.
+// ═══════════════════════════════════════════════════════════════════════════
+test("T3: unrelated partners stay mutually at chance", async () => {
+  const m = newMind();
+  const FACTS = [
+    ["c1", "Volcanoes erupt when magma reaches the surface"],
+    ["c2", "The violin has four strings tuned in fifths"],
+    ["c3", "Penguins are flightless birds of the southern seas"],
+    ["c4", "Concrete gains strength for weeks after it is poured"],
+    ["c5", "The abacus was used for arithmetic in many cultures"],
+    ["c6", "Lightning heats the air it passes through"],
+  ];
+  await m.ingest(FACTS);
+  assertHaloControl(m, FACTS.map((f) => f[0]));
+
+  let worst = -1, worstPair = "";
+  for (let i = 0; i < FACTS.length; i++) {
+    for (let j = i + 1; j < FACTS.length; j++) {
+      const c = cosine(haloOf(m, FACTS[i][0]), haloOf(m, FACTS[j][0]));
+      if (c > worst) {
+        worst = c;
+        worstPair = `${FACTS[i][0]}~${FACTS[j][0]}`;
+      }
+    }
+  }
+  assert.ok(
+    worst < BAR,
+    `unrelated partners must not keep company: worst pair ${worstPair} at ` +
+      `${worst.toFixed(4)}, need < ${BAR.toFixed(4)}.  A profile that ` +
+      `superposes scaffolding makes every halo correlate.`,
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// T4 — ONE EPISODE POURS ONE UNIT OF MASS.
+//
+// The profile is normalized precisely so that enriching it cannot inflate the
+// evidence it represents: `haloMass` counts EPISODES, and every mass-based
+// reading in the system (recall's corroboration counts, the disambiguation
+// tiers) depends on that staying true.  A profile that forgot to normalize
+// would pass T1 and T3 and silently re-weight the whole distributional layer.
+// ═══════════════════════════════════════════════════════════════════════════
+test("T4: enriching the profile does not inflate halo mass", async () => {
+  const m = newMind();
+  await m.ingest([
+    // A partner with MANY constituents, and one with very few — if mass
+    // tracked constituent count instead of episodes, these would differ.
+    ["rich", "The quick brown fox jumps over the lazy dog beside the river"],
+    ["lean", "Ice melts"],
+  ]);
+  assertHaloControl(m, ["rich", "lean"]);
+
+  const massRich = m.store.haloMass(idOf(m, "rich"));
+  const massLean = m.store.haloMass(idOf(m, "lean"));
+  assert.equal(
+    massRich,
+    massLean,
+    `halo mass must count episodes, not constituents: a 59-byte partner ` +
+      `poured ${massRich} against a 9-byte partner's ${massLean}`,
+  );
+  assert.equal(massRich, 1, `one episode must pour exactly one unit of mass`);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// T5 — THE PROFILE IS A FUNCTION OF THE STORE, NOT OF THE DEPOSIT.
+//
+// The constituents must be read from the STORE.  Read instead from the
+// depositing tree's id map — which holds only the nodes THIS deposit newly
+// interned — and a partner met a SECOND time profiles differently from the
+// first, because its subtrees are already stored and therefore absent from the
+// map.  The exact-partner case then falls from cosine 1 to 1/sqrt(1+k) and the
+// geometry stops meaning anything.  Two cues sharing the SAME partner are the
+// direct probe: their halos must be identical, whatever else changed between
+// the two deposits.
+// ═══════════════════════════════════════════════════════════════════════════
+test("T5: the same partner profiles identically on every episode", async () => {
+  const m = newMind();
+  const PARTNER = "Paris is the capital city of France";
+  await m.ingest([
+    ["first", PARTNER],
+    // An unrelated deposit in between, so the second pour happens against a
+    // store that has grown and a tree whose subtrees are all already interned.
+    ["filler", "Sandstone forms from compressed grains"],
+    ["second", PARTNER],
+  ]);
+  assertHaloControl(m, ["first", "second"]);
+
+  const same = cosine(haloOf(m, "first"), haloOf(m, "second"));
+  assert.ok(
+    same > 1 - 1e-6,
+    `two cues sharing one partner must have identical halos: got ` +
+      `${same.toFixed(6)}.  The profile is being read from the deposit's id ` +
+      `map rather than from the store.`,
+  );
+  // Falsifiability: identical halos must not be an artefact of ALL halos in
+  // this store being identical.
+  const different = cosine(haloOf(m, "first"), haloOf(m, "filler"));
+  assert.ok(
+    different < conceptThreshold(D),
+    `control: a different partner must not yield the same halo, got ` +
+      `${different.toFixed(4)}`,
+  );
+});