rhachet-roles-ehmpathy 1.1.0 → 1.3.0

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.acuity.md

@@ -0,0 +1,94 @@
+# 🎯 .brief: `focus.motion.acuity`
+
+## .what
+
+`focal.acuity` motion controls how **finely detailed** your mental frame becomes —
+zooming in to surface nuanced traits, or zooming out to smooth and compress them.
+
+it governs the **resolution** of the concept in focus — whether you're
+seeing just the headline, or peering into the full texture of attributes and substructure.
+
+---
+
+## 🧭 properties
+
+| trait                  | value                                           |
+|------------------------|-------------------------------------------------|
+| **axis type**          | scalar — sharpens or softens a fixed concept    |
+| **subaxes**            | `.attributes`, `.substructs`                    |
+| **anchor**             | concept remains constant                        |
+| **motion direction**   | inward (sharpen), outward (blur)                |
+| **effect**             | affects how much detail is cognitively present  |
+| **breadth unlocked**   | sharper acuity reveals more variation options   |
+
+---
+
+## 🔹 primitives
+
+| primitive        | subaxis           | motion             | description                                     |
+|------------------|--------------------|---------------------|------------------------------------------------|
+| `<articulate>`    | `.attributes++`    | enrich description  | surface observable traits or qualities          |
+| `<compress>`      | `.attributes--`    | reduce description  | flatten or simplify descriptive richness        |
+| `<decompose>`     | `.substructs++`    | reveal parts        | expose internal structure or components         |
+| `<encompose>`     | `.substructs--`    | encapsulate         | bind a structured whole as a single coherent form |
+
+> 🧠 attribute motion focuses on **surface features**,
+> while substruct motion reveals or hides **internal components**.
+
+---
+
+## 🧩 comparison
+
+| mode            | motion            | cognitive effect                               | metaphor                    |
+|------------------|--------------------|--------------------------------------------------|------------------------------|
+| `articulate`     | `.attributes++`    | zoom in to enrich with qualities               | sharpen the image            |
+| `compress`       | `.attributes--`    | zoom out to simplify or abstract traits        | blur out the details         |
+| `decompose`      | `.substructs++`    | zoom in to reveal internal parts               | open the casing              |
+| `encompose`      | `.substructs--`    | zoom out to treat as a single unit             | wrap it up                   |
+
+---
+
+## 🪞 metaphor
+
+> acuity is like turning the **focus dial** of a camera lens —
+> high acuity reveals textures, facets, and joints;
+> low acuity leaves you with silhouettes or simplified shapes.
+
+---
+
+## 🧪 examples
+
+\`\`\`ts
+// articulate attributes
+concept = [banana]
+articulate → [curved], [yellow], [edible], [tropical]
+
+// compress description
+compress → [fruit], [sweet thing]
+
+// decompose structure
+concept = [email]
+decompose → [header], [body], [footer]
+
+// encompose back
+encompose([header, body, footer]) → [email]
+\`\`\`
+
+---
+
+## 💡 interaction with breadth and depth
+
+- high acuity enables **variation** along more breadth axes (more traits revealed)
+- low acuity hides those options (smoother shell)
+- some **depth motions** require prior decomposition to be meaningful
+
+> e.g. you can’t vary the `"head"` of an `"email"` if you haven’t decomposed it first.
+
+---
+
+## 🎯 use when you want to:
+
+- control **how much detail** you’re actively considering
+- expose or abstract **inner parts** of a concept
+- simplify mental load by compressing attributes
+- prepare for operations like variation, substitution, or explanation

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.breadth.md

@@ -0,0 +1,114 @@
+# 🧱 .brief: `focus.motion.primitives.breadth`
+
+## .what
+
+These are the **atomic breadth motions** — irreducible, driftless focus shifts
+that operate **angularly** within a constant `focal.depth` shell.
+
+Each primitive traverses **descriptive subaxes** of the current depth shell
+without modifying abstraction level, focal anchor, or acuity.
+
+> 🧠 they explore **variation across** peers, not **abstraction beyond** them
+> — motion is angular, not radial.
+
+---
+
+## 🧭 properties
+
+| trait              | requirement                                                |
+|--------------------|------------------------------------------------------------|
+| **angular only**   | no radial depth shift — shell remains constant             |
+| **single subaxis** | operates on one `.breadth.[axis]` at a time                |
+| **driftless**      | causes no collateral effect on depth or acuity             |
+| **irreducible**    | cannot be decomposed into smaller semantic motions         |
+| **anchor-locked**  | focal anchor remains constant throughout                   |
+| **reversible**     | typically has an inverse (e.g., invert polarity)           |
+
+---
+
+## 🔹 primitive: `<vary>`
+
+This is the **core atomic motion** across breadth:
+It **selects a lateral peer** of the anchor concept along a descriptive subaxis.
+
+\`\`\`ts
+<vary.axis++> // shift to neighbor at same depth, along .breadth.axis
+\`\`\`
+
+- requires an **explicit subaxis** (e.g., categorical, temporal, emotional)
+- never modifies `focal.depth` or the anchor itself
+- reversible by repeating or stepping back
+
+---
+
+### 🔸 subtypes of `<vary>`
+
+| subtype     | behavior                                      | motion type              | example                                        |
+|-------------|-----------------------------------------------|---------------------------|------------------------------------------------|
+| `<shift>`    | lateral peer switch on same subaxis           | `.breadth.axis++`         | `"apple"` → `"pear"` (categorical)             |
+| `<rotate>`   | reorient focus to a **different subaxis**     | `.breadth.axis → alt.axis`| `"car"` (function) → `"car"` (temporal)        |
+| `<invert>`   | polarity flip along the current subaxis       | `.breadth.axis±180°`      | `"honesty"` → `"deceit"` (moral)               |
+
+> 🧠 `<invert>` is an **extreme variation** — jumping to the opposite end of a trait spectrum.
+
+---
+
+## 🧪 examples
+
+\`\`\`ts
+// categorical → temporal
+concept = [banana]
+breadth.categorical++ → [mango], [apple]
+rotate → breadth.temporal++ → [green banana], [ripe banana]
+
+// functional → temporal
+concept = [car]
+breadth.functional++ → [sedan], [SUV], [truck]
+rotate → breadth.temporal++ → [vintage car], [modern car]
+
+// material → affective
+concept = [shirt]
+breadth.material++ → [cotton], [wool], [polyester]
+rotate → breadth.affective++ → [comfortable shirt], [itchy shirt]
+
+// categorical → spatial
+concept = [music]
+breadth.categorical++ → [jazz], [rock], [classical]
+rotate → breadth.spatial++ → [live music], [studio recording]
+
+// invert (temperature)
+concept = [hot coffee] → [iced coffee]
+
+// invert (lighting)
+concept = [daylight] → [nighttime]
+
+// invert (motion)
+concept = [open door] → [closed door]
+\`\`\`
+
+---
+
+## 🚫 not primitives
+
+The following are **composite maneuvers**, not atomic motions:
+
+- `<compare>` → combines `<vary>`, `<articulate>`, `<cluster>`, `<generalize>`
+- `<extend>` → chains breadth + analogy + depth shift
+- `<gather>` → aggregates concepts via memory, not lateral motion
+
+---
+
+## 🪞 metaphor
+
+> breadth primitives are like **spinning in place on the dome**
+> of your semantic depth shell — viewing the anchor concept
+> through different **semantic windows**, not zooming in or out.
+
+---
+
+## 🎯 use when you want to:
+
+- explore **alternative forms** or roles of a concept
+- **contrast peers** without leaving abstraction layer
+- **rotate interpretive frames** across semantic axes
+- perform **clean lateral variation** in structured thought

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.breadth.vary.md

@@ -0,0 +1,105 @@
+# 🌀 .brief: `focus.motion.vary`
+
+## .what
+`<vary>` is a **breadth primitive** that explores **semantic alternatives**
+by shifting focus **laterally** across a single **descriptive axis**
+within the shell of the current `focal.depth`.
+
+it reveals **contrast**, **alternatives**, and **variation**
+without abstracting inward or instantiating outward —
+it stays entirely within the current abstraction layer,
+but sweeps across one **semantic subaxis** (e.g. color, time, function).
+
+---
+
+## 🧭 traits
+
+| trait              | value                                             |
+|--------------------|---------------------------------------------------|
+| **axis**           | `focal.breadth.[subaxis]`                         |
+| **depth shift**    | ❌ none — operates within shell produced by depth |
+| **acuity needed**  | optional — depends on trait detail                |
+| **anchor shift**   | ❌ — anchor remains fixed                         |
+| **motion type**    | atomic primitive                                  |
+| **composable**     | ✅ may chain to yield comparison or contrast       |
+
+---
+
+## 🔹 primitive subtypes of `<vary>`
+
+| subtype        | behavior                                              | example                                      |
+|----------------|--------------------------------------------------------|----------------------------------------------|
+| `<rotate>`      | switch to adjacent semantic subaxis                   | vary by time instead of function              |
+| `<invert>`      | jump to polar opposite along current axis             | `"love"` → `"hate"` (valence axis)           |
+
+> 🔁 note: `<extend>` is **not** a primitive — it chains variation + analogy + depth shift
+
+---
+## 🧪 examples
+
+---
+
+### 🔄 `<rotate>` — semantic axis change
+
+`<rotate>` shifts focus **laterally** within the **same focal.depth shell**
+by switching to a **different semantic subaxis** — revealing a new frame
+of variation without changing the level of abstraction.
+
+\`\`\`ts
+// categorical → temporal
+concept = [banana]
+breadth.categorical++ → [mango], [apple]
+rotate → breadth.temporal++ → [green banana], [ripe banana]
+
+// functional → temporal
+concept = [car]
+breadth.functional++ → [sedan], [SUV], [truck]
+rotate → breadth.temporal++ → [vintage car], [modern car]
+
+// material → affective
+concept = [shirt]
+breadth.material++ → [cotton], [wool], [polyester]
+rotate → breadth.affective++ → [comfortable shirt], [itchy shirt]
+
+// categorical → spatial
+concept = [music]
+breadth.categorical++ → [jazz], [rock], [classical]
+rotate → breadth.spatial++ → [live music], [studio recording]
+\`\`\`
+
+> reorients focus to a **new descriptive axis** — like turning a kaleidoscope
+> to view the same core through a different semantic lens.
+
+---
+
+### 🔄 `<invert>` — polarity reversal
+
+`<invert>` performs a **reversal** along a single semantic axis —
+flipping a concept to its **opposite pole** while remaining
+in the same depth layer and under the same descriptive axis.
+
+\`\`\`ts
+// temperature axis
+concept = [hot coffee] → [iced coffee]
+
+// lighting axis
+concept = [daylight] → [nighttime]
+
+// motion axis
+concept = [open door] → [closed door]
+
+// power axis
+concept = [lamp on] → [lamp off]
+\`\`\`
+
+> reveals **conceptual contrast** by jumping across a polarity line —
+> the same trait, inverted in meaning, function, or state.
+
+---
+
+## 🎯 use when you want to:
+
+- uncover peers along a single descriptive axis
+- inspect interpretive alternatives
+- reveal polarity or contrasting lenses
+- prime a comparison, contrast, or reframing maneuver

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.depth.md

@@ -0,0 +1,132 @@
+# 🌊 .brief: `focus.motion.depth`
+
+## .what
+
+`focal.depth` motion describes **radial traversal** through a semantic `concept.treestruct`,
+shifting **inward** toward abstraction or **outward** toward instantiation.
+
+it governs how **general or specific** your current frame of focus is —
+zooming along the axis of **inclusion vs. expression**, **type vs. example**,
+**concept vs. case**.
+
+---
+
+## 🧭 properties
+
+| trait                  | value                                           |
+|------------------------|-------------------------------------------------|
+| **axis type**          | radial — moves coreward or leafward            |
+| **subaxes**            | `.abstract`, `.concrete`                        |
+| **anchor**             | the focal concept changes across layers        |
+| **motion direction**   | inward (generalize), outward (instantiate)     |
+| **depth shell**        | determines the available `.breadth` space      |
+| **structure required** | must exist within a hierarchical concept tree  |
+
+---
+
+## 🔹 primitives
+
+| primitive         | motion               | description                                      |
+|-------------------|----------------------|--------------------------------------------------|
+| `<generalize>`     | `.abstract++`        | move inward to a more general abstraction        |
+| `<instantiate>`    | `.concrete++`        | move outward to a more specific form or example  |
+
+> 🔁 radial motion is **reversible** — generalizing back from a case,
+> or instantiating downward from a type.
+
+---
+
+## 🧭 directional reasoning flows
+
+`focal.depth` motion underlies two major forms of structured thought:
+
+| direction       | alias names               | description                                                        | common use cases                               |
+|------------------|----------------------------|----------------------------------------------------------------------|------------------------------------------------|
+| **core → out**   | `coreout`, `top-down`      | instantiate from abstract structure toward concrete examples         | design, deduction, system planning             |
+| **edge → in**    | `edgein`, `bottom-up`      | generalize from concrete instances toward underlying abstraction     | synthesis, analysis, theory-building           |
+
+> 💡 these flows may cycle in reasoning loops:
+> coreout to explore consequences, edgein to revise structure.
+
+---
+
+## 🧩 catalog of abstraction dimensions
+
+radial motion can follow different **abstractive axes**,
+each governing a distinct kind of generalization logic.
+
+this catalog defines **example paths** for common abstraction types:
+
+| abstractive axis | abstraction path                          | generalizes by...         |
+|------------------|--------------------------------------------|---------------------------|
+| **categorical**  | `"banana"` → `"fruit"` → `"plant"`         | kind or type              |
+| **functional**   | `"spoon"` → `"utensil"` → `"tool"`         | purpose or behavior       |
+| **potential**    | `"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 |
+
+> 🧠 each axis defines a **directional context** for `<generalize>` or `<instantiate>` —
+> all share the same radial geometry, but vary in **semantic framing**.
+
+---
+
+## 🪞 metaphor
+
+> depth motion is like **zooming through layers of meaning** —
+> from wide organizing categories (roots),
+> down into rich, detailed examples (leaves).
+
+- `<generalize>` = zoom coreward toward the **core pattern**
+- `<instantiate>` = zoom edgeward toward a **surface case**
+
+---
+
+## 🧪 examples
+
+\`\`\`ts
+// categorical
+concept = [banana]
+generalize → [fruit] → [plant]
+instantiate → [ripe banana], [green banana]
+
+// functional
+concept = [email]
+generalize → [communication tool] → [information utility]
+instantiate → [newsletter email], [password reset email]
+
+// causal
+concept = [spark]
+generalize → [ignition] → [fire mechanism]
+instantiate → [spark from lighter], [spark plug]
+
+// potential
+concept = [can walk]
+generalize → [mobility]
+instantiate → [walk across street], [walk with limp]
+\`\`\`
+
+---
+
+## 💡 interaction with breadth
+
+> `focal.depth` determines the **shell** you're in.
+> within that shell, `focal.breadth` defines your **angle of variation**.
+
+\`\`\`ts
+// depth determines shell
+concept = [fruit]       // abstraction shell
+instantiate → [banana]  // outer shell
+    ↳ vary (breadth.categorical++) → [mango], [apple]
+\`\`\`
+
+---
+
+## 🎯 use when you want to:
+
+- change **how general or specific** the concept in focus is
+- zoom in to inspect real-world instances
+- zoom out to find higher-order patterns
+- choose an abstraction path that matches your reasoning need
+- reason top-down (`coreout`) or bottom-up (`edgein`) through structure

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.2.motion.composites._.md

@@ -0,0 +1,106 @@
+# 🧩 .brief: `focus.motion.composite`
+
+## .what
+A **composite motion** is a named maneuver in `cortal.focus`
+that combines **multiple focus primitives** or transformations
+into a meaningful, higher-order traversal behavior.
+
+While **primitives** operate along a single axis,
+**composites** blend motions — often spanning breadth, acuity, or depth —
+to express richer cognitive intents like *elaborate*, *diagnose*, or *zoomout*.
+
+---
+
+## 🧬 classification of motion variants
+
+| kind            | example             | motion profile                          | composite? |
+|-----------------|---------------------|------------------------------------------|------------|
+| **primitive**   | `<compress>`        | `.attributes--`                          | ❌ no      |
+| **composite**   | `<elaborate>`       | `.breadth++` + `.acuity++`               | ✅ yes     |
+| **structural**  | `<zoomout><$x>`     | framework wrapper for composite behavior | ✅ yes     |
+| **strategic**   | `<diagnose>`        | dynamic chaining of tailored composites  | ✅ yes     |
+
+---
+
+### 🔖 types of composites
+
+| type            | definition                                                                 |
+|------------------|---------------------------------------------------------------------------|
+| **composite**     | hard-coded combination of primitives into a single maneuver               |
+| **structural**    | meta-wrappers that organize or sequence other motions                    |
+| **strategic**     | smart composites that adapt motion chains based on context or input      |
+
+---
+
+## 🛠 how to identify a composite
+
+A motion is composite if it:
+
+- involves **multiple axis transformations**
+- expresses **intent** beyond a single adjustment
+- can be **broken down** into identifiable primitive steps
+
+---
+
+## 🎨 examples
+
+### Composite
+
+\`\`\`ts
+<elaborate>[concept:"contract"]
+=
+  <zoom>[concept:"contract"]
+→ <vary>
+→ <highlight>
+→ [concept:"contract, clause-level detail"]
+\`\`\`
+
+### Structural
+
+\`\`\`ts
+<zoomout>(<compare>, <generalize>)[concept:"vehicle"]
+=
+  <compare>[concept:"vehicle"]
+→ <generalize>
+→ [concept:"transport system"]
+\`\`\`
+
+### Strategic
+
+\`\`\`ts
+<diagnose>[concept:"customer issue"]
+=
+  contextually chooses:
+    → <zoom>[concept]
+    → <contrast>[concept]
+    → <summarize>
+\`\`\`
+
+---
+
+## 🧭 usage in traversal grammar
+
+All composite motions follow the `distilisys.grammar.traversal` pattern:
+
+\`\`\`ts
+<composite>(<$submechs>)[concept.in]
+=
+  <step1>[concept.in]
+→ <step2>
+→ ...
+→ [concept.out]
+\`\`\`
+
+This enables:
+
+- **explicit chaining**
+- **declarative behavior**
+- **composable reasoning**
+
+---
+
+## 🧩 related briefs
+
+- `.brief: cortal.focus`
+- `.brief: focus.motion.primitives`
+- `.brief: distilisys.grammar.traversal`

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.2.motion.composites.grammar.md

@@ -0,0 +1,105 @@
+# 🧪 .brief: `distilisys.grammar.traversal`
+
+## .what
+This grammar defines how **semantic traversal maneuvers**
+are expressed using structured, declarative forms in `distilisys`.
+
+Each maneuver is a **semantic operator** that acts on a focused [concept],
+optionally delegates to internal mechanisms, and produces a transformed [concept] output.
+
+---
+
+## 🧭 general structure
+
+Traversal motions follow this canonical pattern:
+
+\`\`\`ts
+<mechanism>(...<$varmech>)[concept.in]
+=
+   <mech1>[concept.in]
+  → <mech2>
+  → ...
+  → [concept.out]
+\`\`\`
+
+---
+
+### 🔤 component roles
+
+| symbol               | meaning                                                                 |
+|----------------------|-------------------------------------------------------------------------|
+| `<mechanism>`        | the high-level traversal operator (e.g. `<vary>`, `<compare>`, `<extend>`) |
+| `(...<$varmech>)`    | optional list of internal mechanisms used within the traversal           |
+| `[concept.in]`       | the anchor [concept] to traverse from                                    |
+| `[concept.out]`      | the resolved or discovered [concept] result                              |
+| `→`                  | sequence of intermediate semantic transformations                        |
+
+---
+
+## 🎨 examples
+
+### 1. simple traversal
+
+\`\`\`ts
+<extend>()[concept:"apple"]
+=
+  <compare>[concept:"apple"]
+→ <vary>
+→ [concept:"green apple"]
+\`\`\`
+
+- compares `"apple"` to discover dimensions
+- varies along one to produce `"green apple"`
+
+---
+
+### 2. structured with variant mechanisms
+
+\`\`\`ts
+<expand>(<extend>, <research>)[concept:"tool"]
+=
+  <extend>[concept:"tool"]
+→ <research>
+→ <collect>
+→ [concepts:"tool variants"]
+\`\`\`
+
+- performs `<extend>` and `<research>` as broadening actions
+- gathers results into a collective output
+
+---
+
+### 3. compositional traversal (explicit chain only)
+
+Compositional use **must be expressed via arrow chaining** —
+**not via nested expressions** like `<foo>(<bar>(...))`.
+
+✅ valid:
+
+\`\`\`ts
+<extend>[concept:"apple"]
+→ <compare>
+→ [concept:"variation axis"]
+\`\`\`
+
+🚫 invalid:
+
+\`\`\`ts
+<compare>(<extend>[concept:"apple"])
+\`\`\`
+
+Nested calls violate the structural clarity of traversal grammar.
+All motion flows should be **explicitly sequenced** via `→`.
+
+---
+
+## 🎯 purpose
+
+This grammar enables:
+
+- **structured traversal declarations**
+- **multi-step breakdown** of semantic motion
+- **clear chaining** of mechanism → output
+
+It promotes **modular reasoning**, **compositional clarity**,
+and explainable semantic workflows within the `cortal.focus` model.