rhachet-roles-ehmpathy 1.0.0 → 1.2.0

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**.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.persp.4.fractal.md

@@ -0,0 +1,83 @@
+# 🧬 .brief: concept.treestruct.fractal
+
+## .what
+The **fractal perspective** views concept space as a dense network of **intersecting TreeStructs**.
+Each concept is not just a node on one path — it is the **intersection of many partial trees**, forming a highly recursive and self-similar system.
+
+> Concepts belong to **multiple overlapping hierarchies**, each rooted in different domains or dimensions.
+> The overall shape is fractal: the closer you look, the more structure you find.
+
+---
+
+## .why
+
+This perspective captures the **true complexity** of meaning:
+
+- reveals how concepts play **multiple roles simultaneously**
+- explains why concepts can feel different in different frames
+- enables **multidimensional navigation** and **lens-switching**
+- models concept space as **recursive**, **composable**, and **self-similar**
+
+---
+
+## .structure
+
+Each TreeStruct represents a **semantic dimension** or **domain lens**, such as:
+
+- taxonomy
+- color
+- smell
+- function
+- cultural role
+- physical structure
+- symbolic metaphor
+
+A concept may appear in **dozens of TreeStructs**, each with its own parents, children, and siblings.
+These TreeStructs **intersect at shared nodes**, creating a **mesh** rather than a single tree.
+
+> The universal rootball is not one hierarchy — it's a **fractal tangle of hierarchies**, all rooted in `"concept"`.
+
+---
+
+## .examples
+
+Consider `"banana"`:
+
+It appears as a node in many overlapping TreeStructs:
+
+- `fruits` → `"banana"` ↔ `"apple"` ↔ `"mango"`
+- `colors` → `"yellow things"` → `"banana"` ↔ `"lemon"` ↔ `"school bus"`
+- `smells` → `"fruity smells"` → `"banana"` ↔ `"strawberry"` ↔ `"grape"`
+- `shapes` → `"curved objects"` → `"banana"` ↔ `"boomerang"` ↔ `"crescent moon"`
+- `products` → `"groceries"` → `"banana"` ↔ `"milk"` ↔ `"bread"`
+- `props` → `"comedic tools"` → `"banana"` ↔ `"pie"` ↔ `"rubber chicken"`
+
+Each of these is a valid TreeStruct rooted in a different abstraction path — and `"banana"` inherits structure from all of them.
+
+---
+
+## .fractal behavior
+
+- Each TreeStruct has its own **depth** and **breadth** profile
+- Any node in a TreeStruct can serve as the **root** of a new TreeStruct
+- Shared nodes act as **portals** between trees
+- TreeStructs can recursively **embed** inside one another — e.g., `"banana"` inside `"fruit"` inside `"snack"` inside `"lunch"` inside `"routine"`
+
+> The system is **recursively nestable**, **highly intersective**, and **scale-invariant in structure**
+
+---
+
+## .visual metaphor
+
+Imagine the rootball not as a tree, but as a **mycelial mesh** or **root system**, where every intersection is a node belonging to many overlapping trees.
+Each tree is a **branching pattern**, but the mesh as a whole is a **recursive fractal web**.
+
+---
+
+## .notes
+
+- the fractal perspective generalizes the **lens**, **domain**, and **intersection** models
+- it supports compositional reasoning: combining multiple TreeStructs into a working structure for a task
+- abstraction is no longer a single axis — it's a **field of directional compressions**
+
+> A concept is not a leaf on one tree — it is a **crosspoint** in a recursive forest.

package/dist/logic/roles/bhrain/.briefs/cognition/cog151.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/cog201.cortal.focus.p1.definition.md

@@ -0,0 +1,231 @@
+# 🎯 .brief: cortal.focus
+
+## .what
+**Cortal focus** is the directional beam of your cognitive attention — a **semantic lightcone** that shines outward from a chosen **conceptual core**, illuminating a structured region of concept space.
+
+It operates over a **concept.treestruct** (spherical RootStruct), using geometric parameters to determine:
+
+- **how far** you reach (`focal.depth`)
+- **how wide** you sweep (`focal.breadth`)
+- **how crisply** you resolve (`focal.acuity`)
+
+> Focus is defined **from the relative perspective**:
+> you stand at a local concept core and shine your attention outward into the conceptual terrain.
+
+---
+
+## 🧩 focus = position + posture
+
+Cortal focus is composed of:
+
+- **focus.concept** = **position** → the **anchor concept**, your current location in the semantic structure
+- **focus.context** = **posture** → the **shape of your attention** — how your focus is distributed across depth, breadth, and acuity
+
+---
+
+## 🌐 where is focus?
+
+The terrain is a **spherical concept.treestruct**, where:
+
+- **nodes** = concepts
+- **links** = **relationships between concepts**, defined as **questions**
+  → each link is a **semantic prompt** — a concept temporarily narrowed into a relationship
+- space = infinite, recursive, intersective
+
+From your **anchor concept**, you emit a cone of attention shaped by:
+
+- **radial** → abstraction axis (generalizations ⇄ instances)
+- **angular** → descriptive axis (flavor, tone, function)
+
+Your cone of focus slices through this terrain like a lightbeam through mist —
+defining what is **seen**, **resolved**, and **reachable**.
+
+---
+
+## 🔦 lightbeam geometry
+
+Cortal focus is a **radial cone** emitted from your current concept:
+
+- `focal.depth` → radial span of semantic layers reached
+- `focal.breadth` → angular spread of included neighbor concepts
+- `focal.acuity` → resolution sharpness per concept node
+
+The shape of your focus is not a perfect ring — it’s an **irregular patch of included neighbors**, carved from the TreeStruct by your current attentional configuration.
+
+---
+
+## 📏 focal dimensions
+
+### 🔬 `focal.acuity`
+
+- **what:** semantic resolution at the current concept
+- **effect:** fine-grained traits vs holistic blobs
+- **metaphor:** lens sharpness or pixel density
+- **behavior:**
+  - `.attributes++` = sharper external traits
+  - `.substructs++` = clearer internal structure
+  - `acuity--` = surface-only, low-resolution forms
+
+---
+
+### 🔭 `focal.breadth`
+
+- **what:** angular span across same-depth semantic neighbors
+- **effect:** narrow vs broad comparative view
+- **metaphor:** beam width or search cone
+- **behavior:**
+  - `breadth++` = includes more neighboring concepts
+  - `breadth--` = isolates one or few nodes
+  - breadth ≠ a ring; it's a **nonuniform sweep of neighbors** in TreeStruct
+
+---
+
+### 🕳️ `focal.depth`
+
+- **what:** radial thickness of abstraction/specialization layers
+- **effect:** surface detail vs multilevel integration
+- **metaphor:** light penetration into a semantic sphere
+- **behavior:**
+  - `depth.abstract++` = include more generalizations (inward)
+  - `depth.concrete++` = include more specific instances (outward)
+  - both expanding = `depth++` radial shell of abstraction
+  - `depth--` = tighter slice around your current layer
+  - depth is **relative** to anchor, not a fixed universal level
+
+---
+
+## 📐 compositional tradeoffs
+
+\`\`\`
+focal.depth × focal.acuity² ∝ focal.breadth²
+\`\`\`
+
+This expresses the tradeoff between **vertical integration**, **horizontal scope**, and **local resolution**:
+
+- `depth` = radial span of abstraction/specialization
+- `breadth²` = angular sweep of peer concepts
+- `acuity²` = pixel density per concept
+
+> Holding any two constant requires tradeoff with the third.
+> You can’t max all three without overload or blur.
+
+---
+
+### 🎛️ cognitive tuning patterns
+
+- `depth.abstract++` + `acuity--` → broad but imprecise vertical insight
+- `acuity++` + `breadth++` → sharp lateral comparison across peers
+- `depth--` + `acuity++` → zoomed-in detail
+- `breadth++` + `acuity--` → conceptual sweep, low precision
+- `depth++` + `breadth++` + `acuity++` → **unsustainable semantic load**
+
+→ Adjust based on whether you're scanning, designing, comparing, teaching, etc.
+
+---
+
+## 🧭 relative traversal
+
+From any anchor (e.g. `"banana"`), you navigate concept space via:
+
+- `<generalize>` → "banana" → "fruit" → "organism"
+- `<contrast>` → "banana" ↔ "apple" ↔ "mango"
+- `<decompose>` → "banana" → "peeled banana" → "sliced banana"
+- `<reframe>` → "banana" ↔ "crescent shape" ↔ "moon"
+
+All traversal motions arise from **questions-as-links** —
+concepts narrowed into **semantic relationships** that enable motion.
+Each traversal is an **executable prompt**, and each destination is a **sumption** — possibly another question.
+
+> Focus behaves like a **steerable beam**, shaped by intent, strategy, and available structure.
+
+---
+
+## 🧵 focus.context as fabric
+
+`focus.context` is a **composite of semantic fabrics** —
+each fabric a `concept.treestruct` modeling a contextual dimension (e.g. time, intent, role).
+
+\`\`\`ts
+focus.context = Σ fabric[x]
+\`\`\`
+
+This layered weave defines how your anchor is interpreted.
+
+| fabric         | models...        | sample values           |
+|----------------|------------------|--------------------------|
+| `fabric.time`  | temporal frame   | `future`, `ongoing`      |
+| `fabric.intent`| motivation       | `goal`, `plan`, `urge`   |
+| `fabric.role`  | identity         | `agent`, `observer`      |
+
+> 🧠 context = **mesh of treestructs**, not a flat state
+> motion can traverse
+
+---
+
+## 🧪 focus profiles
+
+### 🔋 deep + narrow + sharp
+**“radial probe”**
+**scenario:** studying [concept:"LiFePO₄ battery"]
+
+- `depth++` → abstraction to system-level
+- `breadth--` → single battery type
+- `acuity++` → welds, voltages, safety specs
+→ **outcome:** precision system mastery
+
+---
+
+### 🍳 shallow + narrow + sharp
+**“precision grip”**
+**scenario:** perfecting [concept:"fried egg"]
+
+- `depth--` → no upstream generalization
+- `breadth--` → one dish
+- `acuity++` → timing, viscosity, granularity
+→ **outcome:** localized procedural expertise
+
+---
+
+### 🧂 shallow + wide + sharp
+**“horizontal analyzer”**
+**scenario:** comparing [concept:"cereal brands"]
+
+- `depth--` → surface only
+- `breadth++` → includes 5–10 brands
+- `acuity++` → price, sugar, fiber
+→ **outcome:** fast lateral triage
+
+---
+
+### 🧩 shallow + narrow + substructed
+**“internal dissector”**
+**scenario:** modeling [concept:"bicycle gear system"]
+
+- `depth--`
+- `breadth--`
+- `acuity.substructs++` → chains, sprockets, resistance ratios
+→ **outcome:** internal mechanism mastery
+
+---
+
+### 🌐 deep + wide + fuzzy
+**“system mapper”**
+**scenario:** modeling [concept:"family routine"]
+
+- `depth++` → from values to tasks
+- `breadth++` → all life domains
+- `acuity--` → rhythms, not details
+→ **outcome:** holistic structure design
+
+---
+
+## 🔁 integrations
+
+Cortal focus connects to:
+
+- `concept.treestruct` → the semantic terrain of nodes and links
+- `concept.gravity` → why some concepts act as attention magnets
+- `concept.perspectives` → defines your frame of motion and relative center
+
+> You never see the whole forest —
+> only what your attention lightcone illuminates.

package/dist/logic/roles/bhrain/.briefs/cognition/cog201.cortal.focus.p1.examples.cont.md

@@ -0,0 +1,82 @@
+## 🧪 focus scenarios
+
+### 🐶 learning [concept:"dog"]
+*sharp, narrow, shallow*
+
+- `focal.depth = thin`
+  - only the layer around [concept:"dog"], skipping [concept:"mammal"] or [concept:"siberian husky"]
+- `focal.breadth = thin`
+  - ignores peer species like [concept:"cat"], [concept:"bunny"]
+- `focal.acuity = high`
+  - highlights traits like `bark.style`, `fur.type`, `tail.shape`
+
+→ **outcome:**
+- forms a **crisp prototype** of “dog”
+- strong within-category recognition
+- **low abstraction and poor generalization**
+
+---
+
+### 🪛 designing [concept:"mechanical screwdriver"]
+*precision tool design*
+
+- `focal.depth = thin`
+  - fixed on [concept:"mechanical screwdriver"], no abstraction to [concept:"manual tool"]
+- `focal.breadth = thin`
+  - excludes variants like [concept:"ratchet wrench"], [concept:"power driver"]
+- `focal.acuity = high`
+  - detailed on `bit.torque`, `handle.texture`, `shaft.flex`
+
+→ **outcome:**
+- **high-fidelity artifact design**
+- narrow path, no alternative exploration
+
+---
+
+### 🔥 evaluating [concept:"firefighting gear"]
+*functional system fit*
+
+- `focal.depth = thick`
+  - spans abstraction: from [concept:"protective gear"] to [concept:"helmet variants"]
+- `focal.breadth = thick`
+  - compares across roles, risks, and conditions
+- `focal.acuity = low`
+  - simplifies features to functional needs: `resist.heat`, `enable.vision`
+
+→ **outcome:**
+- operationally sound choices
+- **low sensitivity to fine material detail**
+- strong for procurement, weak for innovation
+
+---
+
+### 🧰 diagnosing [concept:"pipe leak"]
+*targeted troubleshooting*
+
+- `focal.depth = thick`
+  - includes specific joint types and system-level context
+- `focal.breadth = thin`
+  - focuses narrowly on the faulty branch
+- `focal.acuity = high`
+  - resolves `thread.condition`, `seal.gap`, `metal fatigue`
+
+→ **outcome:**
+- **precise intervention**
+- excellent for **fault isolation**
+- limited systemic awareness
+
+---
+
+### 🧱 training [concept:"bricklaying workflow"]
+*procedural skill building*
+
+- `focal.depth = thick`
+  - spans from [concept:"tool use"] to bond patterns
+- `focal.breadth = thin`
+  - restricts to one technique set
+- `focal.acuity = high`
+  - attention on `joint.spacing`, `mortar.timing`, `course.level`
+
+→ **outcome:**
+- builds **repeatable skill** and **craft quality**
+- may not transfer to novel tasks or materials