rhachet-roles-ehmpathy 1.1.0 → 1.3.0

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.structs.vector.md

@@ -0,0 +1,112 @@
+# 🧭 .brief: `physics.vector`
+
+## .what
+A **physics vector** is a mathematical object used to represent **quantities that have both magnitude and direction** in physical space.
+It also functions as a **data structure** — encoding directionally relevant information for computation, simulation, and modeling.
+
+---
+
+## 🧩 structure
+
+A vector is defined by:
+
+- **magnitude** → the scalar size of the quantity
+- **direction** → the orientation in space
+- **components** → projections along basis axes (e.g. `x`, `y`, `z`)
+  - written as `v = ⟨vx, vy, vz⟩` or `v = vx î + vy ĵ + vz k̂`
+
+---
+
+## 🧠 examples of vector quantities
+
+| quantity         | description                                 |
+|------------------|---------------------------------------------|
+| **velocity**     | speed + direction of motion                 |
+| **acceleration** | rate of change of velocity (directional)    |
+| **force**        | push or pull with a direction               |
+| **momentum**     | mass × velocity                             |
+| **electric field** | directional force on a unit charge        |
+
+---
+
+## 🔧 operations on vectors
+
+| operation             | meaning                                             |
+|------------------------|-----------------------------------------------------|
+| **addition**          | combine vectors tip-to-tail                         |
+| **subtraction**       | find relative vector between two                   |
+| **scalar multiplication** | scales magnitude, keeps direction            |
+| **dot product**       | projects one vector onto another (returns scalar)   |
+| **cross product**     | finds perpendicular vector (returns vector)         |
+
+---
+
+## 📐 geometric interpretation
+
+Vectors live in a **Euclidean space** (ℝ², ℝ³) and can be visualized as **arrows**:
+
+- **length** of arrow = magnitude
+- **angle** = direction relative to axes
+- operations map to geometric rules (e.g. triangle or parallelogram rule)
+
+---
+
+## 🧮 as a data structure
+
+In computational systems, a vector is a **structured container of values**, optimized for directional computation:
+
+| property           | value                                      |
+|--------------------|--------------------------------------------|
+| **type**           | `Vector` or `Array<number>`                |
+| **arity**          | dimensionality (e.g. 2D, 3D, nD)            |
+| **shape**          | fixed-length tuple of scalars              |
+| **indexing**       | ordered (e.g. `[0] = x`, `[1] = y`)        |
+| **mutability**     | may be mutable (runtime), or immutable     |
+
+Vectors are frequently implemented as:
+
+\`\`\`ts
+type Vector3 = [number, number, number]
+\`\`\`
+
+or with named accessors:
+
+\`\`\`ts
+interface Vector3 {
+  x: number
+  y: number
+  z: number
+}
+\`\`\`
+
+This enables:
+
+- direct algebraic operations (`add`, `dot`, `normalize`, etc.)
+- efficient storage (especially in graphics, physics engines)
+- compatibility with matrix operations and coordinate transforms
+
+---
+
+## ⚠️ important distinctions
+
+- Vectors ≠ scalars — direction matters
+- Coordinate representation is **basis-relative**
+- The vector itself is **basis-invariant**
+
+---
+
+## 🧬 advanced notes
+
+- In relativity: vectors generalize to **4-vectors** (e.g. spacetime)
+- In field theory: **vector fields** assign a vector to each point in space
+- In curved space: vectors live in **tangent spaces** and obey **manifold** rules
+- In graphics and physics engines: vectors are core data primitives — enabling transforms, simulations, and animations
+
+---
+
+## 🧰 summary: dual perspective
+
+| perspective     | usage                                  |
+|------------------|------------------------------------------|
+| **physical**     | represents real-world directional quantity |
+| **computational**| structured data enabling math operations  |

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.coords.1.spherical.md

@@ -0,0 +1,80 @@
+# 🌳 .brief: `concept.treestruct.spherical`
+
+## .why
+use this brief if you want to...
+
+- **understand how abstraction works** in a concept `TreeStruct`, in terms of generality and specificity
+
+- **navigate or manipulate concepts radially** — moving inward toward abstractions or outward toward instances
+
+- **distinguish between different kinds of abstraction**, such as categorical vs functional vs modal
+
+- **identify the semantic axis** a concept belongs to (e.g., “fruit” is a categorical abstraction)
+
+- **structure your knowledge hierarchically** by tracing how concepts generalize along meaningful dimensions
+
+- **design tools or prompts** that rely on structured abstraction (e.g., AI reasoning, taxonomy design, teaching models)
+
+
+## .what
+The `concept.treestruct` models conceptual space using a **spherical coordinate system**, where each concept has both:
+
+- a **radial position** *(aka "abstractive position")*: how abstract or concrete it is
+- an **angular position** *(aka "descriptive position")*: how it varies descriptively from its peers
+
+This structure allows concepts to be organized by both **hierarchical abstraction** and **semantic variation**, enabling multidirectional traversal.
+
+---
+
+## 🧭 dimensions
+
+| spherical axis     | treestruct role                | alias                    | description                                           |
+|--------------------|--------------------------------|--------------------------|-------------------------------------------------------|
+| **radius** `r`     | abstractive hierarchy          | **abstractive position** | inward = more abstract/core<br>outward = more concrete/detail |
+| **inclination** `θ`| categorical differentiation    | **descriptive position** | vertical angular shifts between categories or frames  |
+| **azimuth** `φ`    | sibling/instance differentiation | **descriptive position** | horizontal angular shifts between analogs or variants |
+
+> The angular dimensions (`θ`, `φ`) are both descriptive: they define where the concept sits relative to peers at the same level of abstraction.
+
+---
+
+## 🪜 radial motion: abstraction
+
+Radial motion moves through layers of **conceptual generality**:
+
+- **inward**: toward more universal, abstract ideas
+- **outward**: toward more specific, detailed instances
+
+This defines the **core structure** of the tree — from root abstractions to concrete applications.
+
+---
+
+## 🔀 angular motion: variation
+
+Angular motion explores **alternative expressions** at the same abstractive level:
+
+- **vertical tilt** (`θ`) shifts across **types or categories**
+- **horizontal rotation** (`φ`) shifts across **peer instances or analogies**
+
+These motions describe **semantic diversity**, not hierarchy.
+
+---
+
+## 🌐 structural implications
+
+- The treestruct forms **layers of abstraction** (radial) populated by **rings of descriptive diversity** (angular)
+- Concepts can be:
+  - **grouped** by angular proximity (descriptive similarity)
+  - **traced** by radial lineage (abstractive derivation)
+
+---
+
+## 🌀 navigation
+
+- to **generalize** → move **inward** (more abstract)
+- to **specialize** → move **outward** (more concrete)
+- to **reframe**, **contrast**, or **analogize** → rotate **angularly**
+
+This enables precise, multidimensional navigation of meaning.
+
+---

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.coords.2.abstractive.md

@@ -0,0 +1,59 @@
+# 🧭 .brief: `cog101.concept.treestruct.coords.abstractive`
+
+## .why
+Use this brief if you want to:
+
+- **understand how abstraction works** in a concept `TreeStruct`, especially in terms of generality and specificity
+- **navigate or manipulate concepts radially** — moving inward toward abstractions or outward toward instances
+- **distinguish between different kinds of abstraction**, such as categorical vs functional vs modal
+- **identify the semantic axis** a concept belongs to (e.g., “fruit” is a categorical abstraction)
+- **structure your knowledge hierarchically** by tracing how concepts generalize along meaningful dimensions
+- **design tools or prompts** that rely on structured abstraction (e.g., AI reasoning, taxonomy design, teaching models)
+
+---
+
+## .what
+The **abstractive coordinate** of a concept describes its **radial position** in a `TreeStruct` of meaning — how **general or specific** it is.
+
+This radial motion is called **abstraction**, and moves either:
+- **inward** toward **more general, inclusive** ideas
+- or **outward** toward **more specific, detailed** instances
+
+Every abstraction path follows a **semantic axis** — a distinct dimension of meaning.
+
+---
+
+## 🧱 structure
+
+Each concept has a position along one or more **abstractive semantic axes**.
+Each axis defines a **consistent rule** of generalization.
+
+Examples of such axes:
+
+| axis name        | abstraction path                           | generalizes by...          |
+|------------------|--------------------------------------------|----------------------------|
+| **categorical**  | `"banana"` → `"fruit"` → `"plant"`         | kind or type               |
+| **functional**   | `"spoon"` → `"utensil"` → `"tool"`         | purpose or behavior        |
+| **modal**        | `"can walk"` → `"mobility"` → `"agency"`   | ability or constraint      |
+| **causal**       | `"match"` → `"ignition"` → `"fire source"` | influence or mechanism     |
+| **emotional**    | `"fear"` → `"negative affect"` → `"alert"` | affective tone             |
+| **ontological**  | `"emotion"` → `"neural event"` → `"process"` | being or substance        |
+| **logical**      | `"even number"` → `"divisible by 2"` → `"numeric property"` | provable structure |
+
+---
+
+## 🔁 radial traversal
+
+Abstractive motion is **radial** in the `concept.treestruct`, not lateral.
+Each axis defines a **line of abstraction** from specific to general — i.e., from **leaf** to **trunk**.
+
+- **inward** motion = `<generalize>`: higher-level, more inclusive
+- **outward** motion = `<instantiate>`: more detailed or constrained
+
+---
+
+## 📌 key point example
+> "Category" is not just a label — it's a **semantic abstraction** along the **categorical axis**.
+
+All categories are abstractive.
+But not all abstractions are categorical.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.coords.3.descriptive.md

@@ -0,0 +1,64 @@
+# 🧭 .brief: `cog101.concept.treestruct.coordinates.descriptive`
+
+## .why
+Use this brief if you want to:
+
+- **understand how concepts vary across peers**, not just across levels of abstraction
+- **navigate laterally** within a concept space — across similar-level alternatives
+- **distinguish a concept from its siblings** by highlighting descriptive differences
+- **identify the descriptive axes** a concept can vary along (e.g., flavor, size, style, plausibility)
+- **model variation, contrast, or diversity** within a semantic category
+- **support analogy-making, reframing, or contrastive analysis** between similar ideas
+
+---
+
+## .what
+The **descriptive coordinate** of a concept defines its **angular position** in the `TreeStruct`.
+It captures **how a concept differs from its peers** — not by abstraction, but by **descriptive variation**.
+
+This is an **angular motion**, moving **around the same level** of abstraction.
+
+Where radial abstraction answers “what is this an instance of?”,
+descriptive variation asks “**what kind of this** is it?”
+
+---
+
+## 🧱 structure
+
+Each concept can vary along one or more **descriptive semantic axes**,
+which define the dimensions by which peer concepts differ.
+
+Examples of descriptive axes:
+
+| axis name         | example variations                                | describes...                      |
+|-------------------|---------------------------------------------------|-----------------------------------|
+| **qualitative**   | red / blue / green                                | color                             |
+| **quantitative**  | small / medium / large                            | size                              |
+| **stylistic**     | formal / casual / ironic                          | tone or mode of expression        |
+| **temporal**      | recent / ongoing / historical                     | time-related state                |
+| **systemic**      | part / module / whole                             | structural composition            |
+| **behavioral**    | aggressive / passive / cooperative                | attitude or action pattern        |
+| **plausibility**  | absurd / unlikely / likely / obvious              | perceived believability or realism|
+
+---
+
+## 🔄 angular traversal
+
+Descriptive motion is **lateral** or **angular** — it moves among **peers at the same abstraction level**.
+Think of concepts orbiting the same distance from the core, but **differing in character**.
+
+This enables operations like:
+
+- `<reframe>` — view the same concept from another descriptive lens
+- `<contrast>` — emphasize a difference along one axis
+- `<analogize>` — map lateral structure to a different context
+
+---
+
+## 📌 key point
+> Descriptive motion defines **how** something *is that thing*, not *what* thing it is.
+
+A “banana” and a “mango” are **peers** under the **categorical abstraction** "fruit" —
+but they differ descriptively by flavor, texture, shape, and usage.
+
+Descriptive axes **reveal the variation space** within a category.

package/dist/logic/roles/bhrain/.briefs/cognition/{cog101.cortal.focus.p1.definition.md → cog201.cortal.focus.p1.definition.md}

@@ -3,7 +3,7 @@
 ## .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:
+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`)
@@ -14,19 +14,28 @@ It operates over a **concept.treestruct** (radial RootStruct), using geometric p
 
 ---
 
+## 🧩 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 **radial concept.treestruct**, where:
+The terrain is a **spherical concept.treestruct**, where:
 
-- nodes = concepts
-- links = semantic relationships (abstraction, specialization, analogy)
+- **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** → inward/outward (abstraction/specialization)
-- **lateral** → semantic neighbors at same depth
-- **angular** → cross-branch analogies and metaphors
+- **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**.
@@ -38,7 +47,7 @@ defining what is **seen**, **resolved**, and **reachable**.
 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.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.
@@ -49,12 +58,13 @@ The shape of your focus is not a perfect ring — it’s an **irregular patch of
 
 ### 🔬 `focal.acuity`
 
-- **what:** semantic resolution per concept node
+- **what:** semantic resolution at the current concept
 - **effect:** fine-grained traits vs holistic blobs
 - **metaphor:** lens sharpness or pixel density
 - **behavior:**
-  - `acuity++` = more traits, subtypes, distinctions
-  - `acuity--` = coarser impressions, general categories
+  - `.attributes++` = sharper external traits
+  - `.substructs++` = clearer internal structure
+  - `acuity--` = surface-only, low-resolution forms
 
 ---
 
@@ -76,37 +86,40 @@ The shape of your focus is not a perfect ring — it’s an **irregular patch of
 - **effect:** surface detail vs multilevel integration
 - **metaphor:** light penetration into a semantic sphere
 - **behavior:**
-  - `depth++` = more layers (inward and/or outward)
+  - `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
-  - relative to anchor; **not** fixed universal depth
+  - depth is **relative** to anchor, not a fixed universal level
 
 ---
 
 ## 📐 compositional tradeoffs
 
-\\```text
+\`\`\`
 focal.depth × focal.acuity² ∝ focal.breadth²
-\\```
+\`\`\`
 
-This expresses how **cognitive focus** is a constrained beam:
+This expresses the tradeoff between **vertical integration**, **horizontal scope**, and **local resolution**:
 
-- high acuity = more semantic pixels per node
-- high breadth = more nodes in view
-- high depth = more layers stacked
+- `depth` = radial span of abstraction/specialization
+- `breadth²` = angular sweep of peer concepts
+- `acuity²` = pixel density per concept
 
-You can’t max all three without overload or blur.
+> Holding any two constant requires tradeoff with the third.
+> You can’t max all three without overload or blur.
 
 ---
 
 ### 🎛️ cognitive tuning patterns
 
-- `depth++` + `acuity--` → broad but imprecise vertical insight
+- `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.
+→ Adjust based on whether you're scanning, designing, comparing, teaching, etc.
 
 ---
 
@@ -114,12 +127,38 @@ You can’t max all three without overload or blur.
 
 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"
+- `<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`      |
 
-Focus behaves like a **steerable beam** — shaped by intent, strategy, and available structure.
+> 🧠 context = **mesh of treestructs**, not a flat state
+> motion can traverse
 
 ---
 
@@ -158,6 +197,17 @@ Focus behaves like a **steerable beam** — shaped by intent, strategy, and avai
 
 ---
 
+### 🧩 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"]
@@ -175,7 +225,6 @@ 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 —

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

@@ -0,0 +1,134 @@
+# 🔬 .brief: `cortal.focal.acuity`
+
+## .what
+**cortal.focal.acuity** governs the **semantic resolution** of each concept in focus —
+how **granular**, **precisely attributed**, and **internally resolved** the concept representation is.
+
+It determines how much **inner detail** your focus resolves per concept node within the spherical `concept.treestruct`.
+
+---
+
+## 🧠 how it works
+
+Acuity controls resolution across **two semantic layers**:
+
+- `.attributes` — surface traits, labels, and descriptive features
+- `.substructs` — internal parts, components, or embedded structures
+
+Both can be modulated independently or jointly depending on the task.
+
+#### acuity scale:
+
+- `acuity++` → high resolution
+  - many dimensions resolved: features, internals, edge cases
+  - e.g. for [concept:"hammer"]:
+    - `.attributes`: `head.mass`, `handle.material`, `grip.type`
+    - `.substructs`: `core.fusion`, `shock.channeling.structure`
+
+- `acuity--` → low resolution
+  - coarse, holistic representations
+  - e.g. just “thing you hit with”
+
+Acuity operates **independently** of:
+- `focal.depth`: how many layers of abstraction are included
+- `focal.breadth`: how many peer concepts are viewed
+
+---
+
+## 🔦 metaphor: optical focus
+
+- high acuity = **sharp lens**
+  - captures semantic edges, traits, and inner systems
+  - like increasing megapixels on a single node
+
+- low acuity = **blurry filter**
+  - sees general shape, label, or purpose
+  - useful for rapid categorization or zoomed-out navigation
+
+---
+
+## 📐 composition tradeoff
+
+\```
+focal.depth × focal.acuity² ∝ focal.breadth²
+\```
+
+Because acuity is squared, it's **computationally expensive** —
+high acuity demands either larger breadth or shallower depth to avoid overload.
+
+---
+
+## 🧪 examples
+
+### 🐶 [concept:"dog"]
+
+- `acuity--`: “a furry animal that barks”
+- `acuity++`:
+  - `.attributes`: `breed.type`, `coat.pattern`, `jaw.structure`
+  - `.substructs`: `muscle.groups`, `nervous.pathways`, `behavior.protocols`
+
+---
+
+### 🔋 [concept:"battery"]
+
+- `acuity--`: “thing that stores energy”
+- `acuity++`:
+  - `.attributes`: `form.factor`, `charge.curve`, `voltage.stability`
+  - `.substructs`: `anode.stack`, `electrolyte.channel`, `thermal.fuse.logic`
+
+---
+
+### 🪚 [concept:"handsaw"]
+
+- `acuity--`: “tool for cutting”
+- `acuity++`:
+  - `.attributes`: `tooth.pitch`, `blade.length`, `grip.material`
+  - `.substructs`: `core.flex.strata`, `fastener.joints`, `multi-bevel.edge`
+
+---
+
+## 🎯 why acuity matters
+
+High acuity enables:
+
+- **precise design and modeling**
+- **deep diagnosis and troubleshooting**
+- **attribute-based comparison or distinction**
+
+Low acuity supports:
+
+- **rapid categorization**
+- **abstract reasoning and compression**
+- **broad or shallow semantic navigation**
+
+---
+
+## 🔁 dynamic behavior
+
+Acuity is often **modulated during traversal**:
+
+- zoom in = `acuity++` to analyze traits and internals
+- zoom out = `acuity--` to generalize or jump layers
+
+It can also **vary per node**:
+- some neighbors are sharp and detailed
+- others remain fuzzy or holistically interpreted
+
+---
+
+## ⚠️ caution: over-acuity
+
+Overfocusing can lead to:
+
+- irrelevant micromanagement
+- detail overload
+- failure to generalize
+
+Use acuity **intentionally** — zoom in with purpose, zoom out with perspective.
+
+---
+
+## 🧰 use it for:
+
+- **design**, **diagnosis**, **teaching**, **analysis**
+- any task that requires distinguishing between **subtle traits** or **complex internal structures**