rhachet-roles-bhrain 0.1.0

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

package/dist/roles/thinker/briefs/cognition/cog401.questions.1.persp.has.precision.tunable.md

@@ -0,0 +1,80 @@
+# 🎯 .brief: `questions.have.tunable.precision`
+
+## .what
+
+Every **question** describes a **semantic direction** —
+but the **precision** of that direction can be **tuned**.
+
+Some questions are **rough**: they point vaguely, requiring
+multiple reasoning hops to triangulate the target.
+Others are **smooth**: they encode a well-shaped vector
+that lands close to the desired answer in one motion.
+
+> 🧠 question precision determines how directly a question
+> moves you through concept space toward resolution.
+
+---
+
+## 🧭 the question precision spectrum
+
+| precision      | navigation profile                              | example                                        |
+|----------------|--------------------------------------------------|------------------------------------------------|
+| **rough**       | ambiguous direction, high reasoning friction    | “What happened?”                               |
+| **smooth**      | precise semantic vector, lands near the target  | “What internal mechanism triggered the shift at time X?” |
+
+> 📈 you can **tune** a question’s precision by composing it
+> with additional semantic constraints — dimension by dimension.
+
+---
+
+## 🔁 how precision tunes motion
+
+| aspect             | rough question                            | smooth question                              |
+|--------------------|--------------------------------------------|-----------------------------------------------|
+| **direction**       | vague, under-specified                    | well-formed semantic vector                   |
+| **turns needed**    | high — needs multiple follow-up hops      | low — may resolve directly                    |
+| **semantic drift**  | common — prone to misalignment            | rare — motion pre-aligned                     |
+| **agent effort**    | must infer missing context                | can execute in a single step                  |
+
+---
+
+## 🧱 mechanism: refinement = vector composition
+
+You can increase question precision by **composing** it
+across multiple semantic subaxes (e.g. causal, temporal, functional):
+
+### progression example:
+
+1. **rough**
+   “What happened?”
+
+2. **less rough**
+   “What caused it?”
+
+3. **refined**
+   “Why did it happen now?”
+
+4. **smooth**
+   “What internal mechanism triggered this shift at time X relative to Y?”
+
+> 🧩 Each refinement adds another **vector component**,
+> tuning the question into a **more aligned motion**.
+
+---
+
+## 🪞 metaphor
+
+> a **rough question** is like tossing a dart in the dark —
+> it might land somewhere useful, but you’ll need to recalibrate.
+
+> a **smooth question** is like a guided missile —
+> it encodes heading, intent, and target into a single launch.
+
+---
+
+## 🎯 use when you want to:
+
+- model **questions as navigational vectors**
+- improve reasoning efficiency by crafting **pre-aligned asks**
+- teach prompt engineering or self-questioning as **tuning for precision**
+- scaffold rough queries into fluent, high-impact prompts

package/dist/roles/thinker/briefs/cognition/cog401.questions.2.1.primitives.rough._.md

@@ -0,0 +1,99 @@
+# 🧩 .brief: `questions.primitive.rough`
+
+## .what
+
+**Core primitive questions** are the most basic forms of inquiry —
+deep, language-universal prompts that initiate motion along a **rough semantic vector**.
+
+Each one points toward a major axis of thought (e.g. cause, time, actor)
+without specifying directionality or precision.
+They are **composable** — refined over time to form smooth, structured questions.
+
+> 🧠 think of them as **semantic compass taps** —
+> minimal cues that orient thought, not define its route.
+
+---
+
+## 🧭 properties of primitive rough questions
+
+| trait                | value                                                  |
+|----------------------|--------------------------------------------------------|
+| **underspecified**   | lacks constraints, context-sensitive                  |
+| **dimensional**      | maps to a core semantic axis                         |
+| **refinable**        | can be composed into smooth multi-axis questions      |
+| **ubiquitous**       | appears in nearly all reasoning chains                |
+
+---
+
+## 🧩 catalog of primitive rough questions
+
+| form             | intent / function                    | initiates motion along...                        |
+|------------------|---------------------------------------|--------------------------------------------------|
+| **what?**         | identity, content, category          | `acuity.attributes++`, `depth.instantiate`        |
+| **why?**          | cause, justification                 | `breadth.causal++`, `depth.abstract++`            |
+| **how?**          | method, process, structure           | `acuity.substructs++`, `breadth.functional++`     |
+| **when?**         | time, sequence                       | `breadth.temporal++`                              |
+| **where?**        | location, spatial relation           | `breadth.spatial++`                               |
+| **who?**          | agent, subject                       | `breadth.subjective++`                            |
+| **which?**        | comparison, selection                | `breadth.categorical++`, `acuity++`               |
+| **what if...?**   | hypothetical variation               | `breadth.categorical++` + `depth.instantiate`     |
+| **what’s next?**  | temporal progression                 | `breadth.temporal++` + `depth.instantiate`        |
+| **what matters?** | priority, salience, value judgment   | `acuity.attributes++` + relevance weighting        |
+
+---
+
+## 🔁 example: question refinement chain
+
+\`\`\`ts
+// start rough
+"why?"
+
+→ refine:
+"why did it happen?"
+
+→ compose:
+"why did it happen now?"
+
+→ smooth:
+"what causal mechanism triggered the change in X at time Y?"
+\`\`\`
+
+Each stage increases:
+- dimensional specificity
+- semantic alignment
+- likelihood of landing directly on the answer
+
+---
+
+## 🪞 metaphor
+
+> primitive rough questions are like **bare intentions**:
+> they point, not plot.
+>
+> a **rough question** is a starting spark —
+> a **smooth question** is a guided strike.
+
+
+---
+
+## 🧠 relationship to `interrogative.primitives`
+
+This catalog is grounded in the theory of **semantic primes** (from NSM),
+which proposes that all human languages share a small set of **universal concepts**
+used to express questions. These deep forms remain consistent
+even when surface syntax differs.
+
+Primitive rough questions are:
+- **linguistically universal** (e.g. *who*, *what*, *why*, etc.)
+- **semantically foundational** (each targets a distinct axis of thought)
+- **structurally minimal** (they can stand alone, or be composed)
+
+---
+
+## 🎯 use when you want to:
+
+- seed structured thought with minimal scaffolding
+- model the **first-hop motion** in a reasoning chain
+- teach how composition sharpens semantic precision
+- map natural language queries to motion primitives
+- reconstruct the deep structure beneath question forms

package/dist/roles/thinker/briefs/cognition/cog401.questions.2.1.primitives.rough.interrogative.md

@@ -0,0 +1,108 @@
+# ❓ .brief: `interrogative.primitives`
+
+## .what
+
+**interrogative primitives** are the **universal, semantic building blocks**
+that underlie all question forms across human languages.
+
+They serve as the **deep structure** of inquiry —
+basic cognitive intents like *"what is it?"*, *"who did it?"*, or *"I want to know"*,
+which are **expressed in different surface forms** depending on the language or system.
+
+In structured reasoning systems (like `cortal.focus`), interrogative primitives
+are also used as **motion triggers** — initiating semantic traversal
+across specific focus axes (e.g. breadth, depth, acuity).
+
+---
+
+## 🌐 linguistic foundation
+
+This concept draws from **Natural Semantic Metalanguage (NSM)** theory,
+which identifies **semantic primes** — universal concepts
+that exist in all languages and are irreducible.
+
+| theory term        | role in questioning                                      |
+|--------------------|----------------------------------------------------------|
+| **semantic prime** | the irreducible core meaning (e.g. *"something?"*)        |
+| **interrogative primitive** | universal questioning intent (e.g. *"I want to know X"*) |
+| **deep structure** | the underlying conceptual frame of the question           |
+| **surface structure** | the language-specific form used to express it           |
+
+> ✨ Despite variation in syntax, **all languages ask the same kinds of questions**
+> — using different tools to express the same deep conceptual needs.
+
+---
+
+## 🧩 catalog of interrogative primitives
+
+| primitive     | intent                        | NSM gloss             | maps to motion along...                    |
+|---------------|-------------------------------|------------------------|---------------------------------------------|
+| `what`        | identity, content, definition | “something?”           | `acuity.attributes++`, `depth.instantiate`  |
+| `why`         | cause, reason                 | “because...”           | `breadth.causal++`, `depth.abstract++`      |
+| `how`         | method, mechanism             | “in what way?”         | `acuity.substructs++`, `breadth.functional++` |
+| `when`        | time, stage                   | “at what time?”        | `breadth.temporal++`                        |
+| `where`       | space, location               | “in what place?”       | `breadth.spatial++`                         |
+| `who`         | agent, subject                | “someone?”             | `breadth.subjective++`                      |
+| `which`       | selection, contrast           | “which one?”           | `breadth.categorical++`, `acuity++`         |
+| `what if`     | possibility, variation        | “maybe something?”     | `breadth.categorical++` + `depth.instantiate` |
+| `what’s next` | temporal progression          | “then what?”           | `breadth.temporal++` + `depth.instantiate`  |
+
+> 🧠 these are not just English words — they reflect **core cognitive forms**
+> that show up in every language’s deep semantic structure.
+
+---
+
+## 🔄 interrogatives as motion triggers
+
+In the `cortal.focus` system, each interrogative primitive
+can be interpreted as a **semantic motion vector** —
+a directive to shift focus along a particular axis of thought.
+
+> e.g.
+> “why?” → generalize causally
+> “how?” → decompose structurally
+> “what?” → articulate traits or instantiate
+
+---
+
+## 🧬 precision and composition
+
+Primitive questions are often **rough** — initiating motion but underspecified.
+They can be **refined** or **composed** into **smoother** asks
+that encode more direction and scope.
+
+| progression example |
+|---------------------|
+| “why?” → “why did it happen?” → “what underlying mechanism caused it to shift at time X?” |
+
+> 📈 Smoother questions = tighter alignment to the answer space
+
+---
+
+## 🌍 language diversity, semantic unity
+
+| language    | "what"   | "who"     | "where"   |
+|-------------|----------|-----------|-----------|
+| English     | what     | who       | where     |
+| Spanish     | ¿qué?    | ¿quién?   | ¿dónde?   |
+| Japanese    | なに (nani) | だれ (dare) | どこ (doko) |
+
+> 🌐 Despite grammatical variation, **the same interrogative primitives persist**
+> — reflecting the **shared conceptual skeleton** of human inquiry.
+
+---
+
+## 🪞 metaphor
+
+> interrogative primitives are like **universal levers**:
+> every human uses them to reach, reveal, and resolve meaning —
+> no matter the language, system, or medium.
+
+---
+
+## 🎯 use when you want to:
+
+- model the **core cognitive forms** behind all questions
+- trace how questions **initiate motion** in structured thought systems
+- scaffold natural language queries into semantic motion vectors
+- teach or design interfaces for **language-agnostic inquiry**

package/dist/roles/thinker/briefs/cognition/cog401.questions.2.1.primitives.rough.why.[article].md

@@ -0,0 +1,55 @@
+# 🧩 .brief: `motion.why`
+
+## .what
+**`motion.why`** is the **traversal motion** of asking *“why”*.
+it is a semantic vector that seeks explanation, pulling thought beyond *what is* toward *what underlies*.
+this motion unfolds across **two fundamental axes**:
+
+- **causal** — tracing **cause → effect**
+- **rationale** — structuring **given → then**
+
+---
+
+## 🎯 goal
+- uncover both the **mechanics** of events and the **logic** of reasoning
+- link phenomena to their **causal chains** and **argument structures**
+- equip reasoning with **factual clarity** (causal) and **logical clarity** (rationale)
+
+---
+
+## 📐 axes of motion
+
+### 1. **causal axis**
+**orientation**: retrospective, backward-seeking — from observed effect to its antecedent cause.
+
+| slot     | description | example |
+|----------|-------------|---------|
+| **.cause** | the antecedent condition or trigger | the belt snapped |
+| **.effect** | the resulting outcome observed | the machine stopped |
+
+**causal traversal:** “why did the machine stop?” →
+- .cause = belt snapped
+- .effect = machine stopped
+
+---
+
+### 2. **rationale axis**
+**orientation**: prospective, logical — from premises given to conclusions drawn.
+
+| slot     | description | example |
+|----------|-------------|---------|
+| **.given** | the stated premise, reason, or assumption | all machines must pass safety checks |
+| **.then** | the **claimed conclusion** that follows | therefore, we run maintenance checks |
+
+**rationale traversal:** “why do we run maintenance checks?” →
+- .given = all machines must pass safety checks
+- .then = therefore, we run maintenance checks
+
+---
+
+## 🔑 notes
+- **causal** = mechanical sequence: **.cause → .effect**
+- **rationale** = logical sequence: **.given → .then**
+- together, they span both:
+  - **factual clarity** (what caused what)
+  - **logical clarity** (what follows from what)

package/dist/roles/thinker/briefs/cognition/cog401.questions.2.2.composite.smooth._.md

@@ -0,0 +1,83 @@
+# 🧩 .brief: `questions.composite.smooth`
+
+## .what
+
+**Smooth composite questions** are refined interrogatives
+built by **composing and compressing** multiple rough question primitives
+into a single, focused vector of semantic motion.
+
+They encapsulate **multi-dimensional curiosity** — traversing
+several axes of `cortal.focus` at once with **precision and intent**.
+
+> 🧠 from compass taps to guided strikes —
+> smooth questions are sharpened instruments of thought.
+
+---
+
+## 🧭 how it works
+
+- start with **rough primitive** (e.g. `why?`, `how?`, `what?`)
+- compose intermediate context (e.g. agent, mechanism, constraint)
+- compress into one **high-bandwidth** query
+
+### motion profile:
+
+\`\`\`ts
+<smooth_question> = <compress>(<compose>([rough primitives]))
+\`\`\`
+
+---
+
+## 🔁 example refinements
+
+### example 1
+\`\`\`ts
+["what?", "where?"]
+→ "what is it?"
+→ "what is it doing here?"
+→ "why is this object located in this place?"
+\`\`\`
+
+### example 2
+\`\`\`ts
+["why?", "how?", "when?"]
+→ "why did it happen?"
+→ "how did it happen when it did?"
+→ "what triggered the event X at time Y?"
+\`\`\`
+
+### example 3
+\`\`\`ts
+["who?", "how?", "what?"]
+→ "who made this?"
+→ "how did they make it?"
+→ "what method did person Z use to produce item Y?"
+\`\`\`
+
+---
+
+## 📦 compositional traits
+
+| trait                | description                                               |
+|----------------------|-----------------------------------------------------------|
+| **dimensional**       | combines multiple focus axes (e.g. depth, acuity, breadth) |
+| **guided**            | implies specific direction and target concept             |
+| **answer-aligned**    | frames a question in a way that leads toward resolution   |
+| **compressible**      | folds complex semantics into a single query               |
+
+---
+
+## 🪞 metaphor
+
+> composite questions are like **targeted darts** —
+> weighted, guided, and crafted for speed and direction.
+
+> they begin as **question clouds**, then compress into **focused payloads**.
+
+---
+
+## 🎯 use when you want to:
+
+- guide AI or human reasoning toward **specific answers**
+- compress a chain of rough questions into a single structured ask
+- model how thought iterates from vague curiosity to crisp articulation