rhachet-roles-ehmpathy 1.0.0 → 1.2.0

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.

package/dist/logic/roles/bhrain/.briefs/cognition/cog401.questions.._.md

@@ -0,0 +1,209 @@
+# ❓ .brief: `questions`
+
+## .what
+
+A **question** is not just a request for information —
+it’s a **semantic motion directive** that tells a reasoning system **where to move**
+in concept space, and **how**.
+
+Every question defines a **vector**: a directional push along one or more
+axes of focus (`focal.depth`, `focal.breadth`, `focal.acuity`, etc).
+The **precision** of this motion is **tunable** —
+from **rough**, exploratory paths to **smooth**, composed trajectories.
+
+> 🧠 questions are the **primary mechanism** by which humans and systems
+> describe, steer, and iterate through thought.
+
+---
+
+## 🌿 questions = semantic branches
+
+Within the `concept.treestruct`, each **question** corresponds to a **branch**
+that grows outward from a **berry** (i.e. concept node).
+
+> ❓ To ask a question is to grow a branch from a berry.
+
+A **question branch**:
+
+- starts from a **berry** (your current concept)
+- fans out toward **target berries** (possible answers)
+- may itself be a **question berry** — a node that spawns further branching
+
+This defines traversal:
+
+\`\`\`ts
+🫐 berry --🌿 question--> 🫐 berry
+                    \
+                     └--> 🫐 berry
+\`\`\`
+
+> 🌿 Every question is **applied** to a berry — questions don't float on their own.
+
+---
+
+## 🧭 questions as motion vectors
+
+Every question acts as a **semantic motion vector**
+within the structure of `cortal.focus`.
+
+To function, a question requires:
+
+| requirement         | role                                                            |
+|---------------------|------------------------------------------------------------------|
+| **focus.context**    | interpretive frame (what’s relevant, known, or valued)          |
+| **focus.concept**    | the current berry — the starting point of semantic motion       |
+| **vector.direction** | axis or axes being activated (depth, breadth, acuity, etc.)     |
+| **vector.magnitude** | extent of motion along each axis (e.g. one hop vs full traverse) |
+
+> ❓ A question isn’t just “what do I want to know?”
+> it’s **“how do I want to move from here?”**
+
+> questions initiate **vectorized traversal** through `concept.treestruct`,
+> forming 🌿 **branches** between 🫐 **berries** in meaning space.
+
+
+---
+
+## 🎚️ tunable precision: rough vs smooth
+
+Questions can express **loose** or **refined** motion profiles:
+
+| precision      | motion profile                             | outcome                                 |
+|----------------|---------------------------------------------|------------------------------------------|
+| **rough**       | vague direction, high turn cost            | requires follow-ups to triangulate      |
+| **smooth**      | well-shaped, multidimensional vector       | lands close to resolution in one move   |
+
+> ✏️ **Refining a question = shaping the branch's trajectory**
+> to land on the most relevant berry directly.
+
+> ⚠️ Over-smoothing too early can obscure insight.
+> Sometimes, **rough questions** surface **hidden paths**
+> that polished ones might skip past.
+
+---
+
+## 🧩 .catalog: question roles in semantic motion
+
+This is a **non-exhaustive catalog** of **question roles** —
+each one reflects a distinct **semantic intention** behind a branch:
+
+| role             | description                                         |
+|------------------|-----------------------------------------------------|
+| **exploratory**   | opens new directions, usually rough or vague       |
+| **diagnostic**    | clarifies status or correctness                    |
+| **generative**    | proposes new berries, forks, or possibilities      |
+| **confirmatory**  | seeks verification or resolution                   |
+| **evaluative**    | identifies salience, preference, or value          |
+
+> ✏️ Use roles to model **intent** — *what are you trying to do with this branch?*
+
+---
+
+### 🪜 example progression
+
+\`\`\`ts
+"what happened?"                              // rough
+"what caused it?"                             // smoother
+"what mechanism triggered the change?"        // smoother
+"what internal mechanism triggered the shift at time X?" // smoothest
+\`\`\`
+
+Each step:
+
+- reduces ambiguity
+- embeds more subaxes and constraints
+- grows a **tighter branch** from berry to berry
+
+---
+
+## 🔄 motion types: zig-zag vs direct branch
+
+| path type       | question behavior                        | semantic motion                        |
+|-----------------|-------------------------------------------|----------------------------------------|
+| **rough path**  | chain of subquestions                     | zig-zag branch growth                  |
+| **smooth path** | precomposed vector                        | direct arc toward resolution           |
+
+> 🪜 Rough = “🫐 berry → 🌿 branch → 🫐 berry → 🌿 branch → 🫐 berry”
+> 🎯 Smooth = one well-formed 🌿 branch that hits a 🫐 berry in one shot
+
+---
+
+## 🧬 questions as semantic matrices
+
+Each question can be modeled as a **motion matrix** over focus dimensions:
+
+\`\`\`ts
+question_matrix = [
+  [1, 0, 0, 0],   // generalize
+  [0, 1, 0, 0],   // vary category
+  [0, 0, 0, 1],   // decompose
+]
+\`\`\`
+
+> A **composite question** = pre-multiplied matrix
+> A **question sequence** = chained motion ops (branch hops)
+
+---
+
+## 🌐 berry-branch interaction logic
+
+> A **question alone does nothing** — until applied to a **berry**.
+
+- 🫐 Current focus = a **berry**
+- 🌿 You apply a **question** to it → new branches grow
+- 🫐 Result = new berries reached via traversal
+
+> 🌿 **Branch = the motion.**
+> 🫐 **Berry = the arrival.**
+
+---
+
+## 🌳 traversal integration
+
+The question system works as part of a larger berrybranch model:
+
+- Questions = 🌿 branches (motion operators)
+- Concepts = 🫐 berries (sumptions)
+- Traversal = chaining motion from berry to berry via branches
+
+\`\`\`ts
+🫐 dog
+   └─🌿 what kind?
+        ├─🫐 poodle
+        └─🫐 beagle
+\`\`\`
+
+> Asking = growing.
+> Following = thinking.
+
+---
+
+## 🧠 in practice
+
+Use this framework to:
+
+- write better AI prompts (smooth = direct, rough = divergent)
+- scaffold learning (start rough, refine with learners)
+- model human reasoning paths in structured interfaces
+
+---
+
+## 🎯 use questions to:
+
+- initiate meaningful motion through concept space
+- **grow semantic branches** from your current focus
+- refine vague berries into crisp ones
+- collapse zig-zag chains into elegant semantic arcs
+- teach vectorized thinking through question refinement
+
+---
+
+## 🪞 metaphor recap
+
+> A **rough question** is like bushwhacking through the woods —
+> you navigate by trial, error, and pivoting.
+
+> A **smooth question** is like a clean branch split —
+> it grows exactly where it needs to go.
+
+> 🌿 Ask well, and the tree grows true.

package/dist/logic/roles/bhrain/.briefs/cognition/cog401.questions.1.persp.as.berries.md

@@ -0,0 +1,168 @@
+# 🌳 .brief: concept.traversal.berrybranch
+
+## .what
+
+The `concept.treestruct` is modeled as a **recursive berrybush**, where:
+
+- **🫐 berries** = **sumptions** — traversable concept nodes
+- **🌿 branches** = **questions** — semantic links between berries
+
+This model compresses the mechanics of traversal into a natural metaphor:
+**Thought grows like a plant — with berries connected by branches.**
+
+---
+
+## 🫐 berry: the sumption node
+
+A **berry** is any concept you can **reach**, **hold**, or **sprout from**:
+
+- a **question berry** prompts branching
+- an **assumption berry** proposes something
+- an **observation berry** describes something
+
+All berries are **sumptions** — the unified type of **traversable concept node**.
+
+> 📌 Any berry may be used as a source or target in traversal.
+
+---
+
+## 🌿 branch: the question link
+
+A **branch** is a **semantic link** grown by applying a **question** to a berry:
+
+- enables **motion** in the treestruct
+- may **fan out** to multiple berries
+- can be composed, nested, or recursive
+
+> 📌 Branches are not standalone — they grow from the interaction of a question berry and a source berry.
+
+---
+
+## 🧩 berry types
+
+| type          | icon   | role                            | traversal behavior                              |
+|---------------|--------|----------------------------------|-------------------------------------------------|
+| **question**   | ❓🫐    | prompt for motion                | when applied to another berry, sprouts branches |
+| **assumption** | 🤔🫐    | claim or belief                  | can be questioned or asserted                   |
+| **observation**| 🧿🫐    | descriptive unit (e.g. example)  | can be noticed, patterned, or examined          |
+
+Each is a **node**, not an edge — traversal is **driven by interaction**.
+
+---
+
+## 🌐 semantic growth
+
+\`\`\`txt
+🫐 fruit
+   └─🌿 what are examples?
+        ├─🫐 banana
+        │     └─🌿 what are types?
+        │          ├─🫐 cavendish
+        │          └─🫐 plantain
+        ├─🫐 apple
+        └─🫐 mango
+\`\`\`
+
+- any **berry** can grow **branches**
+- each **branch** leads to other **berries**
+- the tree grows recursively — thought expands outward as questions are applied
+
+---
+
+## 🔁 traversal structure
+
+All semantic motion through the treestruct is modeled as:
+
+\`\`\`txt
+[🫐 berry] --🌿 question--> [🫐 berry]
+                        \
+                         └--[🫐 berry]
+\`\`\`
+
+- no traversal without a question (branch)
+- no node without a sumption (berry)
+
+> 🌿 To move is to follow a branch.
+> 🫐 To arrive is to reach a berry.
+
+---
+
+## 🪄 recursive growth
+
+Since berries can sprout more branches via questions, growth is fractal:
+
+\`\`\`txt
+🫐 banana
+   └─🌿 why is it funny?
+        └─🫐 banana joke
+             └─🌿 what makes a joke?
+                  └─🫐 surprise
+                       └─🌿 surprise of form?
+                            └─🫐 visual pun
+\`\`\`
+
+Each node reached may:
+
+- sprout more branches
+- be reinterpreted via a new question
+- collapse into patterns or abstractions
+
+---
+
+## 🧪 motion logic
+
+- A **question** is not just content — it's a **behavioral operator**
+- Any berry, when combined with a question berry, can **sprout new branches**
+- Semantic motion is **prompted**, not inherent
+
+> The tree only grows when you ask something of it.
+
+---
+
+## 🧠 semantic equivalence
+
+| concept type     | metaphor   | system term | notes                         |
+|------------------|------------|-------------|-------------------------------|
+| question         | 🌿 branch  | `question`  | semantic motion link          |
+| answer           | 🫐 berry   | `sumption`  | resolved node                 |
+| assumption       | 🫐 berry   | `sumption`  | belief node                   |
+| observation      | 🫐 berry   | `sumption`  | descriptive node              |
+| question-as-node | 🫐 berry   | `sumption`  | can also sprout branches      |
+
+---
+
+## 🔧 synonym collapse
+
+For a `ubiqlang`, we collapse synonymic terms into the **preferred primitives**:
+
+| legacy term      | preferred `ubiqlang` |
+|------------------|----------------------|
+| node             | 🫐 berry             |
+| concept          | 🫐 berry             |
+| edge             | 🌿 branch            |
+| link             | 🌿 branch            |
+| sumption         | 🫐 berry             |
+| answer           | 🫐 berry             |
+| fork             | 🫐 berry             |
+| unresolved node  | ❓🫐 question berry   |
+| resolved node    | 🫐 berry             |
+
+This reduces cognitive load and keeps all conceptual motion within a **2-part system**:
+**berries (sumptions)** and **branches (questions)**.
+
+---
+
+## 🔗 integrations
+
+- `cortal.focus` → determines which berries and branches are in focus
+- `concept.gravity` → explains why some berries attract attention
+- `concept.perspectives` → define your center berry
+- `concept.traversal` → describes abstractive vs descriptive branch motion
+
+---
+
+## 🧭 reframe
+
+> 🫐 **Every concept is a berry.**
+> 🌿 **Every question berry can grow a branch.**
+> 🌳 **Traversal is what happens when your questions grow through your berries.**

package/dist/logic/roles/bhrain/.briefs/cognition/cog401.questions.1.persp.as.vectors.md

@@ -0,0 +1,74 @@
+# ❓ .brief: `questions.as.motion.vectors`
+
+## .what
+
+In structured thought, a **question** is not just a request for information —
+it's a **semantic motion vector**: a directive that specifies **where to move**
+in concept space, and **how**.
+
+Each question encodes **both a direction and magnitude** of conceptual motion,
+targeting one or more subaxes of `cortal.focus` with varying intensities.
+
+---
+
+## 🧠 as vector behavior
+
+| component          | role                                                       |
+|--------------------|------------------------------------------------------------|
+| **axis selector**   | identifies which semantic dimension to activate           |
+| **scalar magnitude**| controls how far to move (depth, acuity, breadth)         |
+| **multi-axis blend**| combines motions across multiple subaxes simultaneously   |
+| **origin anchor**   | defines the context/starting concept for traversal        |
+
+---
+
+## 🧭 question as motion directive
+
+A single question may:
+
+- refine a **single subaxis** → “What color is it?” → `focal.breadth.categorical++`
+- trigger a **depth shift** → “What kind of fruit is it?” → `focal.depth.instantiate`
+- increase **acuity** → “What traits make this effective?” → `focal.acuity.attributes++`
+- combine multiple → “Why does it work better than the alternative?”
+  → rotate axis + articulate traits + causal generalization
+
+---
+
+## 🧬 questions as matrix operations
+
+> 🧩 a **set of questions** can be treated as a **semantic transformation matrix**
+> — each row targeting a subaxis, each column encoding vector weights.
+
+\`\`\`ts
+// conceptual state vector = [depth, breadth.axis1, breadth.axis2, acuity.substructs, ...]
+question_matrix = [
+  [1, 0, 0, 0],   // generalize
+  [0, 1, 0, 0],   // vary categorical
+  [0, 0, 0, 1],   // decompose
+]
+
+result = apply(question_matrix, current_focus)
+\`\`\`
+
+> this lets reasoning behave like a **steered transform** —
+> question structure becomes the guidance system for mental motion.
+
+---
+
+## 🪞 metaphor
+
+> a question is a **steering vector** —
+> not just "what you want to know", but **where you want to go**.
+
+- it activates a **direction** in the concept space
+- it scales the **intensity** of traversal
+- it constrains **which dimensions** are in play
+
+---
+
+## 🎯 use this idea when:
+
+- modeling structured reasoning or "tree-of-thought"
+- composing AI agents that interpret or chain questions
+- designing semantic UX interfaces where prompts guide concept shifts
+- tracing how a question shifts focus across multiple axes