rhachet-roles-ehmpathy 1.15.13 → 1.15.15

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

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

@@ -1,168 +0,0 @@
-# 🌳 .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/bhrain/briefs/cognition/cog401.questions.1.persp.as.vectors.md

@@ -1,74 +0,0 @@
-# ❓ .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/bhrain/briefs/cognition/cog401.questions.1.persp.has.precision.tunable.md

@@ -1,80 +0,0 @@
-# 🎯 .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/bhrain/briefs/cognition/cog401.questions.2.1.primitives.rough._.md

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