rhachet-roles-bhrain 0.1.0

package/dist/roles/thinker/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/roles/thinker/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/roles/thinker/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/roles/thinker/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.