rhachet-roles-ehmpathy 1.0.0 → 1.1.0

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.treestruct.md

@@ -0,0 +1,85 @@
+# 📚 .brief: TreeStruct
+
+## 🎯 purpose
+to define **TreeStruct** as a general-purpose structural pattern
+and clarify its common usage forms (**RootStruct**, **LeafStruct**) and
+how multiple TreeStructs can safely intersect.
+
+---
+
+## 🌲 TreeStruct — general definition
+
+> A **TreeStruct** is a structural form composed of **nodes** and **directed, acyclic links**,
+> where each node has **at most one parent** per dimension or axis.
+
+- meaning-neutral — not tied to any specific interpretation
+- supports both:
+  - **depth-first** and **breadth-first** traversal
+  - **single-axis** and **multi-axis** expansion (when extended)
+- usable for:
+  - hierarchies
+  - workflows
+  - classification systems
+  - nesting, containment, or flow modeling
+
+---
+
+## 🌱 LeafStruct — axis-limited subset of TreeStruct
+
+> A **LeafStruct** is a TreeStruct used for **top-down**, **axis-constrained** flows,
+> modeled on **branches funneling into leaves**.
+
+- used when structure narrows from a few high-level origins
+- favors **convergence**, **containment**, or **controlled descent**
+
+---
+
+## 🫚 RootStruct — multi-directional subset of TreeStruct
+
+> A **RootStruct** is a TreeStruct used in **bottom-up**, **lateral**, or exploratory growth patterns,
+> modeled on **roots spreading underground**.
+
+- used when structure grows across **many dimensions**
+- often favors **divergence** and **deep local branching**
+- **branches can intersect** and share common nodes, forming a **web-like network** of overlapping subpaths
+
+---
+
+## 🌉 intersecting TreeStructs
+
+> Multiple TreeStructs can **safely intersect**, as long as they each preserve
+> their own **local acyclic structure**.
+
+valid forms of intersection:
+
+1. **shared nodes**
+   - two TreeStructs reference the **same node**
+   - useful for **cross-cutting concerns** or shared entities
+
+2. **embedded subtrees**
+   - one TreeStruct is **nested within** a node of another
+   - allows compound or hierarchical system design
+
+3. **cross-links between trees**
+   - TreeStructs remain independent but reference each other via external links
+   - enables navigation between trees without forming a general graph
+
+> These patterns create a **forest with bridges**: each tree remains intact,
+> but the system supports **inter-tree coordination**.
+
+---
+
+## 🧩 summary
+
+| struct         | metaphor           | shape pattern           | dimensionality     | common use cases                          |
+|----------------|--------------------|--------------------------|--------------------|-------------------------------------------|
+| **TreeStruct**   | neutral tree         | any branching structure   | general-purpose     | workflows, hierarchies, branching systems |
+| **LeafStruct**   | branches → leaves    | top-down narrowing        | narrow (few axes)  | classification, taxonomies, decisions     |
+| **RootStruct**   | roots underground    | bottom-up or lateral      | broad (many axes)  | exploration, divergence, distributed plans|
+
+---
+
+> ✔️ **TreeStruct** is a flexible structural pattern.
+> It supports both **divergent** and **convergent** design through RootStruct and LeafStruct,
+> and can safely **intersect with other TreeStructs** through shared nodes, nesting, or cross-links —
+> as long as **local acyclicity is preserved**.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.definition.md

@@ -0,0 +1,115 @@
+# 📘 .brief: concept
+
+## .what
+A **concept** is a mental abstraction that represents a category, pattern, or principle.
+
+- it defines a class of things that share common structure or meaning
+- it serves as a mental placeholder that can apply across situations
+- it enables grouping, comparison, recognition, and symbolic reasoning
+- it is not tied to any single instance but generalizes across many
+
+## .why
+Concepts are foundational to how we think, learn, and communicate.
+
+- they allow us to generalize from specific experiences
+- they reduce cognitive load by compressing recurring patterns
+- they enable symbolic thought and language (e.g. words refer to concepts)
+- they support transfer of learning and abstract reasoning
+- without concepts, perception and memory would remain fragmented and unstructured
+
+## .origin
+All concepts arise through some form of **abstraction** — extracting structure from experience.
+
+- abstraction involves identifying similarities across multiple examples or events
+- concepts may emerge from direct sensory interaction (e.g. learning "hot" from touching a stove)
+- or from social learning (e.g. learning "wedding" by seeing it enacted or described)
+- or from formal instruction (e.g. learning "photosynthesis" in school)
+- in all cases, concept formation requires generalizing beyond the specific to the shared
+
+
+## .traits
+- abstract and generalized
+- not tied to a specific instance
+- formed through experience, reflection, or instruction
+- may be intuitive (e.g. “tree”) or technical (e.g. “prime number”)
+- can vary in granularity or scope (e.g. “animal” vs. “dog”)
+
+## .examples
+
+- **circle** — abstracted from seeing repeated round shapes like wheels, coins, and the sun (perceptual experience)
+- **dog** — formed by generalizing across encounters with different dog breeds and behaviors (direct interaction)
+- **wedding** — abstracted from witnessing or hearing about ceremonies that formalize unions (cultural exposure)
+- **freedom** — distilled from contrasting experiences of constraint vs autonomy (social experience)
+- **justice** — shaped by stories and events involving fairness, consequences, and moral resolution (moral narratives)
+- **prime number** — learned by observing which numbers are divisible only by 1 and themselves (formal instruction)
+- **game** — generalized from diverse activities with rules, goals, and competition (play and observation)
+- **vehicle** — abstracted from tools that enable movement across space (functional abstraction)
+- **tool** — learned by recognizing shared purpose across objects used to modify the environment (goal-oriented use)
+- **emotion** — abstracted by noticing recurring internal states like fear or joy across different contexts (introspective pattern)
+- **government** — formed by generalizing across systems of authority and law in history, media, and education (institutional exposure)
+
+## .relationships
+- a **concept** can be instantiated by specific **examples**
+- concepts serve as nodes in **semantic treestructs**
+  - connected by abstraction paths
+  - higher nodes represent broader, more general concepts
+  - while lower nodes represent more specific subtypes or instances
+
+## .metaphor
+A **concept** is like a mold — many unique shapes can be cast from it, but they all carry its defining structure.
+
+## .struct
+In a **semantic TreeStruct**, each concept is a **node** positioned along dimensions of meaning (e.g. category, function, emotion).
+- "dog" → child of "mammal" → child of "animal"
+- "knife" → child of "cutting tool" → child of "tool"
+
+Concepts can thus be:
+- **abstracted** inward to general types
+- **specialized** outward to specific subtypes
+- **clustered** by similarity
+- **cross-linked** via shared features across branches
+
+## .usecases
+
+### 🧠 cognitive compression & efficiency
+Concepts reduce mental overhead by filtering detail and enabling compact representation.
+
+- **eliminate irrelevant detail** — discard noise and focus on structural features
+- **reduce memory load** — bundle multiple features into a single abstract handle
+- **compose higher constructs** — build layered models from compact mental units
+- **reuse mental structure** — once formed, concepts can be applied across contexts
+- **schema-based learning** — fit new observations into known conceptual frames
+
+### 🔍 perception & attention
+Concepts guide what we notice and how we interpret sensory input.
+
+- **pattern detection** — expose regularities across diverse instances
+- **selective attention** — filter sensory streams for concept-relevant features
+- **domain focusing** — foreground what's signal-bearing in a specific context
+- **comparison and contrast** — highlight similarities and differences between concepts
+
+### 📡 reasoning & inference
+Concepts power generalization, prediction, and higher-order logic.
+
+- **prediction** — infer missing or future information based on conceptual type
+- **analogical mapping** — transfer structure between domains via shared conceptual form
+- **deduction & induction** — structure logical operations through known categories
+- **abstraction chaining** — compose concepts into hierarchical or recursive reasoning models
+
+### 🗣 communication & collaboration
+Concepts enable symbolic representation and shared understanding across minds.
+
+- **symbolic reference** — words, icons, and gestures can point to shared concepts
+- **cultural transmission** — pass conceptual structures across generations or tribes
+- **semantic alignment** — synchronize meaning for collaboration and coordination
+- **efficient memory indexing** — act as anchors that connect memories across time and modality
+
+### 🛠 planning & action
+Concepts shape behavior by structuring intentions, goals, and procedures.
+
+- **goal decomposition** — break down abstract objectives into actionable steps
+- **problem modeling** — frame challenges in terms of known concept structures
+- **tool selection** — choose actions or instruments based on conceptual fit
+- **cognitive scaffolding** — support stepwise planning and skill acquisition with layered abstractions
+
+Concepts function as the **semantic operating system** of cognition — compressing, structuring, and aligning mental operations across perception, memory, communication, and action.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct._.md

@@ -0,0 +1,112 @@
+# 🌲 .brief: concept.treestruct
+
+## .what
+The **concept.treestruct** is a semantic structure where concepts are arranged as interconnected nodes within a **radial RootStruct**, centered on the abstract core: `"concept"`.
+
+Rather than a single hierarchy, the TreeStruct is a **recursive mesh** of intersecting conceptual trees.
+It enables navigation through **abstraction**, **specialization**, **clustering**, and **frame-shifting**, supporting both **structured reasoning** and **creative exploration**.
+
+---
+
+## .why
+This structure enables rich, flexible reasoning:
+
+- models concept space as a **geometry of meaning**
+- supports **semantic traversal** along depth, breadth, and perspective
+- reflects how humans think: by **anchoring**, **zooming**, **shifting**, and **linking**
+- integrates both **objective structure** and **subjective experience**
+
+---
+
+## .directions
+Traversal within the TreeStruct occurs in distinct directions:
+
+- **radial** → abstraction or specialization
+  - inward = more abstract (e.g. `"banana"` → `"fruit"` → `"plant organ"`)
+  - outward = more specific (e.g. `"fruit"` → `"banana"` → `"ripe banana"`)
+
+- **lateral** → peer clustering
+  - shift across neighboring nodes at the same depth
+  - e.g. `"banana"` ↔ `"mango"` ↔ `"apple"`
+
+- **angular** → frame-shifting
+  - shift semantic axis or domain (e.g. taxonomy → function → metaphor)
+  - often includes radial movement as well
+  - e.g. `"knife"` ↔ `"word"` (metaphor: both cut)
+
+> Lateral ≈ angular when angular displacement is small.
+> Angular motion becomes distinct when reframing occurs across axes or domains.
+
+---
+
+## .geometry
+The TreeStruct forms an **infinite radial space**, anchored at `"concept"`. Its topology supports:
+
+- `focal.depth` → radial distance from the core (abstraction level)
+- `focal.breadth` → number of peer or radial options in view
+- `focal.acuity` → level of resolution within the current concept
+
+Traversal is:
+- **continuous** (drifting among neighbors)
+- **recursive** (zooming into sub-structures)
+- **semantic** (paths shaped by meaning, not just structure)
+
+> Thought is not linear — it spirals through this field of meaning.
+
+---
+
+## .metaphor
+Think of the concept.treestruct as a **semantic gravity field**:
+
+- zoom **inward** to distill essence
+- zoom **outward** to expand contextual roles
+- pan **laterally** to compare siblings
+- bend **angularly** to reframe or analogize
+
+> High-gravity concepts shape your local space of thought.
+> You orbit them — or escape them — with effort.
+
+---
+
+## .example
+
+Starting at the concept **“banana”**:
+
+- **radial-in**: `"banana"` → `"fruit"` → `"plant organ"` → `"organic structure"`
+- **radial-out**: `"banana"` → `"ripe banana"` → `"peeled banana"`
+- **lateral**: `"banana"` ↔ `"mango"` ↔ `"pineapple"`
+- **angular**:
+  - `"banana"` ↔ `"banana phone"` (visual pun)
+  - `"banana"` ↔ `"joke"` (slapstick tool)
+  - `"banana"` ↔ `"color yellow"` (perceptual role)
+
+---
+
+## .struct
+The TreeStruct is:
+
+- **recursive** — any node can be a root of a new TreeStruct
+- **intersective** — nodes may appear in multiple trees simultaneously
+- **perspectival** — motion can be described from:
+  - the **universal perspective** (objective coordinates)
+  - the **relative perspective** (anchored focal view)
+  - the **fractal perspective** (nested, overlapping trees)
+
+> Meaning is not contained in a single path — it emerges from intersections.
+
+---
+
+## .notes
+This model integrates with:
+
+- **cortal.focus mechanics**
+  - `focal.depth`, `focal.breadth`, and `focal.acuity`
+- **concept.gravity**
+  - high-gravity nodes anchor navigation and recall
+- **concept.traversal**
+  - radial, lateral, and angular motion as the grammar of thought
+- **concept.lens** *(implied)*
+  - perspectives and domain lenses guide how the structure is explored
+
+> The TreeStruct is not just a model of concepts —
+> it’s a model of how thought moves through them.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.gravity.md

@@ -0,0 +1,89 @@
+# 🌌 .brief: concept.gravity
+
+## .what
+**Concept.gravity** describes how certain concepts exert a **semantic pull**, functioning like **gravitational centers** in the conceptual rootball.
+
+These high-gravity concepts act as **anchors for thought**, **starting points for exploration**, or **recurring nodes** that structure how we navigate, remember, and relate ideas.
+
+---
+
+## .why
+
+This model explains:
+
+- why certain concepts are **easier to recall** and return to
+- why traversal often bends toward **familiar or salient ideas**
+- how **working memory** orients around **persistent anchors**
+- why some ideas feel "**central**" while others feel "**orbiting**" or **peripheral**
+
+Concept.gravity offers a cognitive and navigational metaphor for the **structure of attention and recall**.
+
+---
+
+## .properties of gravity
+
+- gravity ≈ **semantic salience**
+- higher-gravity concepts:
+  - are more **memorable**, **central**, or **frequently visited**
+  - act as **attractors** during traversal
+  - may act as **default lenses** when exploring unknown space
+
+- lower-gravity concepts:
+  - require **conscious effort to locate or stabilize**
+  - may be skipped over unless actively sought
+  - often exist in the **shadow** of nearby cores
+
+---
+
+## .examples
+
+- `"dog"` has high gravity in most minds — it's concrete, visual, familiar
+- `"justice"` has abstract gravity — anchoring philosophical clusters
+- `"fruit"` may act as a gravitational lens when exploring `"banana"`, `"apple"`, etc.
+- `"concept"` itself is the universal core — the **black hole** at the center of all abstraction
+
+---
+
+## .gravitational traversal
+
+> Traversal in the rootball is not always linear — it bends toward **nearby gravity wells**.
+
+- when searching, thought often **snaps to the nearest core**
+- if exploring `"knife"`, we might default to `"tool"` or `"weapon"` because of gravitational pull
+- angular or exploratory moves are often **redirected or slowed** by nearby attractors
+
+This explains why:
+- **analogies drift toward known metaphors**
+- **reframing** requires effort — escaping a gravitational frame
+- **local gravity** defines what’s visible in working memory at a time
+
+---
+
+## .thought as traversal
+
+> Thinking can be modeled as **traversal across gravitational fields of concepts**.
+
+- high-gravity concepts act as **navigation hubs**
+- thought often **orbits** or **spirals inward** around a central idea
+- active thought involves **hopping between cores** while holding some in working memory
+- expanding attention requires **venturing past the current pull**, sometimes using angular motion
+
+---
+
+## .working memory & orbiting
+
+- concepts in **working memory** form a **local constellation**
+- one acts as a **primary anchor** — the active lens
+- others **orbit** as nearby or queued concepts
+- **loss of anchor** can cause drift or re-centering
+
+---
+
+## .notes
+
+- gravity is **relative** — depends on thinker, context, and task
+- gravity can shift over time — reinforced concepts gain pull
+- systems can intentionally **bias gravity** (e.g., prompts, education, interfaces)
+
+> High-gravity concepts organize your thoughtspace.
+> Low-gravity ones wait to be discovered — or pulled in.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.persp.1.perspectives.md

@@ -0,0 +1,88 @@
+# 🧭 .brief: concept.treestruct.perspectives
+
+## .what
+The **concept.treestruct.perspectives** brief defines the **three major ways** of understanding and navigating the concept rootball:
+
+1. **universal perspective** — describes the objective structure of concept space
+2. **relative perspective** — models the thinker’s navigation from a focal anchor
+3. **fractal perspective** — reveals the self-similar, intersective, and recursive nature of meaning
+
+Each perspective emphasizes a different axis of reasoning, but all operate within the same **RootStruct** — the infinite radial space rooted at `"concept"`.
+
+---
+
+## .why
+
+This framing allows us to:
+
+- switch between **absolute location**, **subjective movement**, and **compositional complexity**
+- unify reasoning strategies under one structural system
+- explain paradoxes of abstraction, categorization, and analogy
+- design flexible semantic systems that honor both structure and interpretation
+
+---
+
+## .perspectives
+
+### 🌐 universal perspective
+> The concept rootball as a **fixed semantic structure**
+
+- concepts are **absolute positions** in radial space
+- movement uses **spherical traversal**:
+  - `radial`: abstraction (in), specialization (out)
+  - `lateral`: sibling concepts at same depth
+  - `angular`: axis/domain/frame changes
+- rooted at `"concept"` — all paths converge there
+
+📌 no zoom — only position and displacement
+📌 useful for structural modeling, hierarchy resolution, and axis alignment
+
+---
+
+### 🧭 relative perspective
+> The concept rootball as **experienced from a focal anchor**
+
+- movement defined by **zoom metaphors**:
+  - `<zoomin>`: dive into attributes / internal structure
+  - `<zoomout>`: broaden through context / external relations
+- traversal mechanisms:
+  - `via(attributes)`
+  - `via(neighbors)`
+- abstraction and specification can happen in either direction
+- zoom direction is contextual — not absolute
+
+📌 useful for thought modeling, analogy, and semantic exploration
+📌 the “user interface” for navigating the universal structure
+
+---
+
+### 🧬 fractal perspective
+> The concept rootball as a **recursive tangle of intersecting TreeStructs**
+
+- concepts belong to **many overlapping hierarchies**
+- each dimension (taxonomy, function, color, culture, etc.) forms a **partial tree**
+- concepts are **shared nodes** — crosspoints between branches
+- supports nested reasoning, lens composition, and local-rooted trees
+
+📌 useful for modeling polycategorical meaning, domain lenses, and recursive re-framing
+📌 generalizes the lens and domain models into a single recursive substrate
+
+---
+
+## .summary
+
+| perspective | structure       | motion language     | focus             | root concept |
+|-------------|------------------|----------------------|--------------------|--------------|
+| universal   | absolute radial mesh | radial / lateral / angular | global semantics  | `"concept"` |
+| relative    | zoom-centric view    | `<zoomin>` / `<zoomout>`     | local navigation  | user-defined |
+| fractal     | recursive mesh       | recursive TreeStructs        | intersective roles | multiple |
+
+---
+
+## .notes
+
+- all three perspectives are **valid**, and **mutually compatible**
+- each reveals a different **facet of meaning**
+- together, they support a complete model of **conceptual structure**, **thinking motion**, and **domain intersection**
+
+> Concept space is not flat — it has **structure**, **anchor**, and **recursion**.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.persp.2.universal.md

@@ -0,0 +1,82 @@
+# 🌐 .brief: concept.treestruct.universal
+
+## .what
+The **universal perspective** views concept space as a single, infinite **RootStruct** — the **concept rootball** — where all concepts are nodes radiating outward from a single absolute core: `"concept"`.
+
+This frame treats concepts as having **absolute positions** in a shared structure. Motion is described using **spherical traversal**, not relative zoom.
+
+---
+
+## .why
+This perspective provides:
+
+- an objective map of the semantic universe
+- a consistent reference for abstraction, specialization, and analogy
+- a substrate for intersecting TreeStructs to safely coexist
+- a gravitational pull toward core ideas like `"concept"`, `"thing"`, or `"entity"`
+
+---
+
+## .structure
+
+The concept rootball is modeled as an **infinite spherical structure**:
+
+- **radial axis** = abstraction level
+  - inward = more abstract
+  - outward = more specific
+- **lateral plane** = peers at the same level of abstraction
+- **angular displacement** = movement across semantic axes or domains
+
+Each concept node is positioned by:
+- `focal.depth` → how far it is from the core
+- `focal.breadth` → how wide its local context is (peer connections)
+- `focal.acuity` → how precisely it is resolved at that layer
+
+---
+
+## .traversal
+
+All movement is defined by spherical geometry:
+
+- **radial**: toward the core (abstraction) or away from it (specialization)
+- **lateral**: across sibling nodes at the same depth (e.g., `"dog"` ↔ `"cat"`)
+- **angular**: between different axes or domains (e.g., `"knife"` ↔ `"word"`)
+
+> When angular displacements are small, **lateral ≈ angular**.
+> When crossing domains or axes, **angular motion becomes distinct**, often involving metaphor or re-framing.
+
+---
+
+## .examples
+
+- `"dog"` → `"mammal"` → `"animal"` → `"organism"` → `"concept"`
+  → radial inward (abstraction)
+
+- `"dog"` → `"herding dog"` → `"border collie"` → `"tri-colored border collie"`
+  → radial outward (specialization)
+
+- `"dog"` ↔ `"cat"` ↔ `"rabbit"`
+  → lateral traversal
+
+- `"dog"` ↔ `"companion"` ↔ `"servant"` ↔ `"vehicle"`
+  → angular traversal across roles and metaphors
+
+---
+
+## .core
+
+The root of the universal TreeStruct is the concept: `"concept"`.
+
+All conceptual paths — regardless of starting point or traversal method — ultimately collapse inward toward this root via abstraction.
+
+> The rootball is not a hierarchy — it's a multi-branching **semantic continuum**, with a gravitational center of meaning.
+
+---
+
+## .notes
+
+- This perspective is **agnostic to the thinker** — it describes the structure itself, not how it is navigated
+- It enables semantic alignment across domains via shared radial reference
+- All relative and lens-based perspectives operate **within** this structure
+
+> This is not how we think — it is **where** we think.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.persp.3.relative.md

@@ -0,0 +1,106 @@
+# 🧭 .brief: concept.treestruct.relative
+
+## .what
+The **relative perspective** is a way of navigating the concept rootball from the standpoint of a **focal anchor** — a specific concept that frames all motion.
+
+From this position, traversal is interpreted through **zoom metaphors** (`<zoomin>`, `<zoomout>`) and proceeds via either:
+- **attributes** (internal features and structure)
+- **neighbors** (external context and related concepts)
+
+This model captures the experience of **thinking through** a concept — expanding, refining, abstracting, or reframing it locally.
+
+---
+
+## .why
+This perspective allows:
+
+- flexible conceptual movement without needing global coordinates
+- support for local reasoning, reframing, and analogy
+- expressive control over **zoom**, **detail**, and **contextual scope**
+- modeling thought as **exploration**, not just location
+
+---
+
+## .mechanisms
+
+Traversal in the relative perspective combines two dimensions:
+
+### 🔀 mechanism of motion:
+- `via(attributes)` → inward-facing — explores internal structure
+- `via(neighbors)` → outward-facing — explores external associations
+
+### 🎛 zoom direction:
+- `<zoomin>` → dive deeper into a concept's composition
+- `<zoomout>` → step back into its surrounding context
+
+📌 These are metaphors: zoom direction is not absolute — it’s **anchored to the focal concept**.
+
+---
+
+## .example traversal: `"banana"`
+
+Each semantic operation below is illustrative — not exhaustive:
+
+### 🧠 abstraction
+
+- `<zoomin><abstract>.via(attributes)`
+  `"banana"` → `"fruit"` → `"plant organ"` → `"organic structure"`
+
+- `<zoomout><abstract>.via(neighbors)`
+  `"banana"` → `"apple"` ↔ `"mango"` → `"snack"` → `"food"` → `"thing"`
+
+---
+
+### 🎯 specification
+
+- `<zoomin><specify>.via(attributes)`
+  `"banana"` → `"ripe banana"` → `"peeled banana"` → `"sliced banana"`
+
+- `<zoomout><specify>.via(neighbors)`
+  `"banana"` → `"banana phone"` ↔ `"banana peel"` ↔ `"banana stand"`
+
+---
+
+### 🌐 broadening
+
+- `<zoomin><broaden>.via(attributes)`
+  `"banana"` → `"contains potassium"` ↔ `"is soft"` ↔ `"is curved"`
+
+- `<zoomout><broaden>.via(neighbors)`
+  `"banana"` → `"pineapple"` ↔ `"pear"` ↔ `"papaya"` ↔ `"guava"`
+
+---
+
+## .relativity of zoom direction
+
+> **Zoom direction is always relative to the focal anchor.**
+
+Examples:
+- `"molecule"` is **outward** from `"atom"`, but **inward** from `"protein"`
+- `"snack"` is **outward** from `"banana"`, but **inward** from `"lunch"`
+
+There is no contradiction — only a **change in frame**.
+What defines direction is **semantic proximity to the chosen center**, not absolute position.
+
+---
+
+## .relation to universal structure
+
+- the relative perspective **operates within** the universal rootball
+- but it interprets motion through **subjective zoom**, not spherical coordinates
+- zoom-based motion may be radial, lateral, or angular in universal terms — but those distinctions are not necessary locally
+
+> All relative paths, no matter how they begin, will eventually **converge inward** toward the universal root: `"concept"`.
+
+---
+
+## .notes
+
+- relative perspective is ideal for:
+  - everyday thinking
+  - analogical reasoning
+  - exploration of unfamiliar domains
+- the focal anchor acts like a **semantic lens** — shaping how the local region of the rootball is viewed and explored
+
+> Thinking is not positionless.
+> It always starts **somewhere**.