rhachet-roles-ehmpathy 1.13.0 → 1.13.1

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

@@ -1,132 +0,0 @@
-# 🌊 .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

@@ -1,106 +0,0 @@
-# 🧩 .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

@@ -1,105 +0,0 @@
-# 🧪 .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

@@ -1,209 +0,0 @@
-# ❓ .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.