@hviana/sema 0.5.6 → 0.5.8

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.6",
+  "version": "0.5.8",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.5.6",
+  "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