rhachet-roles-ehmpathy 1.0.0 → 1.1.0

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/cog101.cortal.focus.p1.definition.md

@@ -0,0 +1,182 @@
+# 🎯 .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** (radial 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.
+
+---
+
+## 🌐 where is focus?
+
+The terrain is a **radial concept.treestruct**, where:
+
+- nodes = concepts
+- links = semantic relationships (abstraction, specialization, analogy)
+- space = infinite, recursive, intersective
+
+From your **anchor concept**, you emit a cone of attention shaped by:
+
+- **radial** → inward/outward (abstraction/specialization)
+- **lateral** → semantic neighbors at same depth
+- **angular** → cross-branch analogies and metaphors
+
+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` → lateral 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 per concept node
+- **effect:** fine-grained traits vs holistic blobs
+- **metaphor:** lens sharpness or pixel density
+- **behavior:**
+  - `acuity++` = more traits, subtypes, distinctions
+  - `acuity--` = coarser impressions, general categories
+
+---
+
+### 🔭 `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++` = more layers (inward and/or outward)
+  - `depth--` = tighter slice around your current layer
+  - relative to anchor; **not** fixed universal depth
+
+---
+
+## 📐 compositional tradeoffs
+
+\\```text
+focal.depth × focal.acuity² ∝ focal.breadth²
+\\```
+
+This expresses how **cognitive focus** is a constrained beam:
+
+- high acuity = more semantic pixels per node
+- high breadth = more nodes in view
+- high depth = more layers stacked
+
+You can’t max all three without overload or blur.
+
+---
+
+### 🎛️ cognitive tuning patterns
+
+- `depth++` + `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:
+
+- `<zoomin><abstract>` → "banana" → "fruit" → "organism"
+- `<zoomout><broaden>` → "banana" ↔ "mango" ↔ "apple"
+- `<zoomin><specify>` → "banana" → "peeled banana" → "sliced banana"
+- `<rotate><reframe>` → "banana" ↔ "crescent shape" ↔ "moon"
+
+Focus behaves like a **steerable beam** — shaped by intent, strategy, and available structure.
+
+---
+
+## 🧪 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
+
+---
+
+### 🌐 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.traversal` → the modes of movement: inward, lateral, radial
+- `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/cog101.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

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.cortal.focus.p2.acuity.md

@@ -0,0 +1,107 @@
+# 🔬 .brief: cortal.focal.acuity
+
+## .what
+**cortal.focal.acuity** governs the **semantic resolution** of each concept in focus — how **granular**, **fine-differentiated**, and **multi-dimensional** the concept representation is.
+
+It determines how **much inner detail** your focus resolves per concept node within the radial `concept.treestruct`.
+
+---
+
+## 🧠 how it works
+
+Acuity controls the **grain of resolution** across semantic traits:
+
+- `acuity++` → high resolution
+  - many dimensions: features, subtypes, conditions, histories
+  - e.g. for [concept:"hammer"]: `head.mass`, `handle.material`, `strike.radius`
+
+- `acuity--` → low resolution
+  - coarse, holistic representations
+  - e.g. just “thing you hit with”
+
+It operates **independently** of:
+- `focal.depth`: how many concept layers are stacked
+- `focal.breadth`: how many neighbors are viewed
+
+---
+
+## 🔦 metaphor: optical focus
+
+- high acuity = **sharp lens**
+  - captures fine semantic edges and attributes
+  - like increasing megapixels on a single node
+
+- low acuity = **blurry filter**
+  - sees only general shape or role
+  - useful for fast scanning or abstract reasoning
+
+---
+
+## 📐 composition tradeoff
+
+```
+focal.depth × focal.acuity² ∝ focal.breadth²
+```
+
+Because acuity is squared, it's **computationally expensive** — high acuity costs high breadth or very limited depth without overload.
+
+---
+
+## 🧪 examples
+
+### 🐶 [concept:"dog"]
+
+- `acuity--`: “a furry animal that barks”
+- `acuity++`:
+  - `breed.type`, `coat.pattern`, `jaw.structure`, `training.history`, `social.role`
+
+---
+
+### 🔋 [concept:"battery"]
+
+- `acuity--`: “thing that stores energy”
+- `acuity++`:
+  - `electrode.material`, `charge.curve`, `form.factor`, `voltage.stability`, `temp.range`
+
+---
+
+### 🪚 [concept:"handsaw"]
+
+- `acuity--`: “tool for cutting”
+- `acuity++`:
+  - `tooth.pitch`, `blade.flex`, `grip.material`, `cut.style`, `pull.push.orientation`
+
+---
+
+## 🎯 why acuity matters
+
+High acuity enables:
+
+- **precise design thinking**
+- **deep diagnosis**
+- **feature-based comparison**
+
+Low acuity supports:
+
+- **rapid categorization**
+- **abstraction and generalization**
+- **semantic compression**
+
+---
+
+## 🔁 dynamic behavior
+
+Acuity is often **modulated** as you move between tasks:
+
+- zoom in = `acuity++` to analyze fine traits
+- zoom out = `acuity--` to generalize or jump layers
+
+Acuity can also vary **per neighbor** during lateral traversal — some concepts may be crisp, others fuzzy.
+
+---
+
+## 🧰 use it for:
+
+- **design**, **diagnosis**, **teaching**, **modeling**
+- any task that benefits from distinguishing between **subtle features** or **internal structure**
+

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.cortal.focus.p2.breadth.md

@@ -0,0 +1,118 @@
+# 🌐 .brief: cortal.focal.breadth
+
+## .what
+**cortal.focal.breadth** defines the **angular sweep** of attention around a concept anchor in the `concept.treestruct`, determining how many **neighbor concepts** are held in focus at a given semantic depth.
+
+Unlike a perfect ring, this breadth is a **selective and shaped patch** of concept space — it may be symmetrical or irregular, depending on salience, familiarity, or intent.
+
+---
+
+## 🌀 relative geometry
+
+From the **relative perspective**, breadth expands **around** your current anchor concept.
+
+- **breadth** includes a set of **neighbor concepts** at the same semantic depth
+- the inclusion shape is **not uniform** — it can be lopsided, sparse, or clustered
+- this creates an **irregular band** of peer concepts, shaped by relevance or recognition
+
+> e.g. from [concept:"banana"], `breadth++` might include [concept:"apple"], [concept:"plantain"], [concept:"mango"], skipping [concept:"fig"] entirely
+
+---
+
+## ↔️ traversal behavior
+
+| operation     | effect                                         |
+|---------------|------------------------------------------------|
+| `breadth++`   | adds more **neighbor concepts** to the shape   |
+| `breadth--`   | contracts the included set                     |
+
+---
+
+## 🔦 metaphor: shaped spotlight
+
+Your focus acts like a **spotlight beam**, projecting outward across a semantic layer.
+But rather than lighting a perfect cone, it traces a **contoured patch** — a shape defined by:
+
+- cognitive salience
+- current intent
+- available attention
+- memory activation
+
+---
+
+## 🧠 why it matters
+
+**Breadth** empowers:
+
+- **semantic comparison**
+- **pattern triangulation**
+- **category discovery**
+- **exploration across peer variations**
+
+But it must be composed carefully with **depth** and **acuity** to avoid:
+
+- overload
+- drift
+- incoherent jumps
+
+---
+
+## 📈 compositional tradeoff
+
+```
+focal.depth × focal.acuity² ∝ focal.breadth²
+```
+
+As breadth grows:
+
+- it taxes depth and acuity
+- it risks blurring or dilution
+- but it also enables richer relational context
+
+---
+
+## 🧭 traversal spectrum
+
+- **tight breadth** → local siblings only
+- **medium breadth** → neighboring subtypes, cousins
+- **wide breadth** → cross-domain links or analogies
+
+At extreme angles, `breadth` borders **angular traversal**, crossing semantic axes (e.g., from [concept:"dog"] to [concept:"vehicle"] by metaphor).
+
+---
+
+## 🧪 examples
+
+### 🐶 anchor: [concept:"dog"]
+
+- `breadth--`: only [concept:"dog"]
+- `breadth++`: [concept:"dog"], [concept:"cat"], [concept:"rabbit"], [concept:"ferret"]
+
+→ note: may **favor mammals**, exclude reptiles, skip obscure species
+
+---
+
+### 🍌 anchor: [concept:"banana"]
+
+- `breadth--`: just [concept:"banana"]
+- `breadth++`: [concept:"apple"], [concept:"plantain"], [concept:"mango"], maybe [concept:"dates"]
+
+→ shaped by **culinary familiarity** or **visual similarity**
+
+---
+
+### 🛠️ anchor: [concept:"screwdriver"]
+
+- `breadth--`: only [concept:"mechanical screwdriver"]
+- `breadth++`: [concept:"torx driver"], [concept:"allen key"], skips [concept:"impact driver"]
+
+→ shaped by **use case**, **manual vs powered**, or **available knowledge**
+
+---
+
+## 🧭 use it to:
+
+- **cluster neighbors**
+- **contrast category members**
+- **explore semantically nearby ideas**
+- **triangulate relationships**

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.cortal.focus.p2.depth.md

@@ -0,0 +1,121 @@
+# 🕳️ .brief: cortal.focal.depth
+
+## .what
+**cortal.focal.depth** defines the **radial thickness** of semantic layers surrounding a concept, measured within the `concept.treestruct` from a **relative anchor**.
+
+It reflects how many layers of meaning — both more abstract and more specific — are simultaneously in view, relative to the current center of thought.
+
+---
+
+## 📐 relative geometry
+
+In the **relative perspective**, attention radiates outward from an anchor concept — forming a **radial shell** through the surrounding concept space:
+
+- `focal.depth` defines **how thick** that shell is
+- traversal still follows **universal abstraction**:
+  - **inward** = more abstract
+  - **outward** = more specific
+- but the **frame of reference** is **local**:
+  - depth is measured “**around**” the anchor
+
+> from [concept:"banana"], a thick depth might include [concept:"fruit"] (inward) and [concept:"plantain"] (outward)
+
+---
+
+## 🔦 metaphor: beam of attention
+
+Imagine a **beam of focus** radiating from your current anchor:
+
+- it slices through surrounding layers of the TreeStruct
+- the **thickness** of that slice is `focal.depth`
+- one direction reaches **inward** toward abstraction
+- the other moves **outward** toward specialization
+
+This beam defines which semantic layers are cognitively lit up — and how far in both directions your reasoning stretches.
+
+---
+
+## ↕️ directional behavior (universal semantics)
+
+```
+depth.inward++   → include more abstract concepts
+depth.outward++  → include more specific concepts
+depth.inward--   → trim inner abstraction
+depth.outward--  → trim edge specificity
+```
+
+These movements are **semantic**, not spatial — they follow the **universal axis of abstraction** regardless of your anchor point.
+
+---
+
+## 📊 thickness vs precision
+
+- `depth++` → more layers included
+- `depth--` → thinner slice around anchor
+
+Choose based on your cognitive goal:
+
+| Use Case                  | Strategy                         |
+|---------------------------|----------------------------------|
+| Pattern → implementation  | `depth++` for vertical span      |
+| Local precision task      | `depth--` for focus              |
+| Core essence only         | `depth.inward--`                 |
+| Fine-grain edge only      | `depth.outward--`                |
+
+---
+
+## 📈 compositional interaction
+
+```
+focal.depth × focal.acuity² ∝ focal.breadth²
+```
+
+This geometric relation constrains focus:
+
+- the deeper your shell, the finer your acuity must be reduced to maintain clarity across a wide breadth
+- you can’t go **deep, wide, and sharp** all at once — without tradeoffs
+
+---
+
+## 🧠 examples
+
+### 🐶 anchor: [concept:"dog"]
+
+- `depth.inward++`:
+  [concept:"mammal"] → [concept:"animal"] → [concept:"organism"]
+- `depth.outward++`:
+  [concept:"golden retriever"] → [concept:"service retriever"] → [concept:"autism-assist retriever"]
+
+---
+
+### 🛠️ anchor: [concept:"hammer"]
+
+- `depth.inward++`:
+  [concept:"hand tool"] → [concept:"manual implement"] → [concept:"mechanical device"]
+- `depth.outward++`:
+  [concept:"claw hammer"] → [concept:"rubber-handled claw hammer"] → [concept:"ergonomic demolition hammer"]
+
+---
+
+## 🧰 radial composition behavior
+
+```
+focal.depth++
+⇒ depth.inward++ && depth.outward++
+⇒ [concept:"dog"] ←→ [concept:"autism-assist retriever"]
+```
+
+```
+focal.depth--
+⇒ depth.inward-- && depth.outward--
+⇒ only [concept:"dog"]
+```
+
+---
+
+## 🧭 use when you need:
+
+- **multilevel semantic perspective**
+- **vertical reasoning chains**
+- **semantic scaffolding**
+- **narrative abstraction control**