rhachet-roles-ehmpathy 1.1.0 → 1.2.0

package/dist/logic/roles/bhrain/.briefs/cognition/cog401.questions.2.2.composite.smooth.examples.md

@@ -0,0 +1,101 @@
+## 🧪 .examples: `questions.composite.smooth`
+
+Each example begins with **primitive rough questions**,
+then shows how **compositional refinement** leads to a smooth, precise query.
+
+> 🧠 think of this as:
+> \`\`\`ts
+> smooth = compress(compose([rough questions]))
+> \`\`\`
+
+---
+
+### 📍 Example 1 — temporal cause
+
+**Rough primitives:**
+- "why?"
+- "when?"
+- "what?"
+
+\`\`\`ts
+→ "why?"
+→ "why did it happen?"
+→ "why did it happen when it did?"
+→ "what triggered the event X at time Y?"
+\`\`\`
+
+> 📦 combines `breadth.causal++` + `breadth.temporal++` + `depth.instantiate`
+
+---
+
+### 🛠️ Example 2 — actor and method
+
+**Rough primitives:**
+- "who?"
+- "how?"
+- "what?"
+
+\`\`\`ts
+→ "who made this?"
+→ "how did they make it?"
+→ "what method did person Z use to produce item Y?"
+\`\`\`
+
+> 📦 combines `breadth.subjective++` + `acuity.substructs++` + `breadth.functional++`
+
+---
+
+### 🧭 Example 3 — location and identity
+
+**Rough primitives:**
+- "what?"
+- "where?"
+
+\`\`\`ts
+→ "what is it?"
+→ "what is it doing here?"
+→ "why is this object located in this place?"
+\`\`\`
+
+> 📦 combines `acuity.attributes++` + `breadth.spatial++` + `breadth.causal++`
+
+---
+
+### 🧪 Example 4 — hypothetical reasoning
+
+**Rough primitives:**
+- "what?"
+- "what if...?"
+- "how?"
+
+\`\`\`ts
+→ "what if we changed X?"
+→ "what would happen if we changed X?"
+→ "how would changing X affect outcome Y?"
+\`\`\`
+
+> 📦 combines `breadth.categorical++` + `depth.instantiate` + `breadth.functional++`
+
+---
+
+### 🧰 Example 5 — value and decision
+
+**Rough primitives:**
+- "what?"
+- "which?"
+- "what matters?"
+
+\`\`\`ts
+→ "what are the options?"
+→ "which option matters most?"
+→ "what decision is best given criteria Z?"
+\`\`\`
+
+> 📦 combines `breadth.categorical++` + `acuity.attributes++` + salience reasoning
+
+---
+
+## 🪄 pattern
+
+> Each smooth question acts as a **semantic vector shortcut**
+> — a compressed form of its constituent interrogative path.

package/dist/logic/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.1.primitives._.md

@@ -0,0 +1,134 @@
+# 🧠 .brief: `cortal.assemblylang.primitives`
+
+## .what
+
+The `cortal.assemblylang` defines **three primitive instructions**
+that form the **core execution model** of structured cognition.
+
+Each primitive acts on both:
+
+- **`focus.concept`** → the current semantic anchor (🫐)
+- **`focus.context`** → the surrounding attentional posture (🔦)
+
+| primitive      | function class         | system analogue           |
+|----------------|------------------------|----------------------------|
+| **`<steer>`**   | control flow           | `JMP`, `CALL`, `branch`    |
+| **`<think>`**   | content transformation | `ADD`, `ALU`, `logic`      |
+| **`<recall>`**  | memory movement        | `MOV`, `LOAD`, `STORE`     |
+
+> all structured cognition compiles down to combinations of these **execution-grade primitives**.
+
+---
+
+## 🛤️ `<steer>` — procedural structure
+
+`<steer>` defines the **execution shape** of semantic motion.
+
+It shapes both **where attention is anchored** and **how it flows**.
+Each subtype depends on a **semantic question** to resolve its path.
+
+| subtype     | structure     | description                                |
+|-------------|----------------|---------------------------------------------|
+| `<route>`   | sequential      | fixed-step chains                          |
+| `<cycle>`   | looping         | repeats until a question resolves          |
+| `<fanout>`  | parallel        | explores multiple branches simultaneously  |
+| `<choice>`  | conditional     | dispatches based on resolved label         |
+| `<await>`   | suspended       | waits until an answer becomes available    |
+
+> semantic flow = `<steer>` (motion structure) × `question` (direction vector)
+
+---
+
+## 🧠 `<think>` — semantic transformation
+
+`<think>` performs conceptual computation by applying `focus.motion.primitives`.
+It transforms concept traits, reframes posture, or synthesizes new focus states.
+
+| mode          | subtype       | description                                |
+|---------------|----------------|---------------------------------------------|
+| deterministic | `<compute>`    | applies logic, filters, or rules            |
+| generative    | `<imagine>`    | synthesizes analogies, variations, or shifts|
+
+> only `<think>` supports **multi-axis**, **compositional** focus motion.
+
+---
+
+## 💾 `<recall>` — semantic memory I/O
+
+`<recall>` handles conceptual memory:
+loading, saving, or swapping complete focus states (concept + context).
+
+| operation | direction | role                                        |
+|-----------|-----------|---------------------------------------------|
+| `<save>`  | write     | stores the current focus for later use      |
+| `<load>`  | read      | restores a previously stored focus          |
+| `<swap>`  | both      | exchanges two stored concepts or states     |
+
+> memory layers may include: local working memory, long-term schema, caches, or external stores.
+
+---
+
+## 🔬 comparison matrix
+
+| feature                    | `<steer>` | `<think>` | `<recall>` |
+|----------------------------|-----------|-----------|------------|
+| alters `focus.concept`     | ✅         | ✅         | ✅        |
+| alters `focus.context`     | ✅         | ✅         | ✅        |
+| governs motion structure   | ✅         | ⛔         | ⛔        |
+| performs content mutation  | ⛔         | ✅         | ⛔        |
+| enables memory persistence | ⛔         | ⛔         | ✅        |
+
+---
+
+## 🧠 example composition
+
+\`\`\`ts
+<route>([
+  <save>("initial"),
+  <think>(<decompose>[bike]),
+  <choice>({
+    condition: ask("what kind of failure?"),
+    options: {
+      mechanical: <imagine>(...),
+      electrical: <compute>(...)
+    }
+  }),
+  <load>("initial"),
+  <think>(<reframe>(...)),
+  <save>("solution")
+])
+\`\`\`
+
+- `<steer>` defines the **flow**
+- `<think>` evolves **content and posture**
+- `<recall>` manages **state persistence**
+
+---
+
+## 📐 metaphorical lens
+
+| primitive     | beam metaphor              | machine analogue          |
+|---------------|-----------------------------|----------------------------|
+| `<steer>`     | moves beam origin + flow    | program counter, jump      |
+| `<think>`     | reshapes beam and direction | ALU, logic unit            |
+| `<recall>`    | loads/saves beam presets    | memory, stack, cache       |
+
+---
+
+## 🔩 design principles
+
+- these primitives are **irreducible execution units**
+- all higher-level reasoning compiles to combinations of these three
+- each affects both **content** and **posture**
+- true composition emerges via interleaved use
+
+---
+
+## 🔁 related briefs
+
+- [`cortal.execution.assemblylang.steer`](./assemblylang.steer.md)
+- [`cortal.execution.assemblylang.think`](./assemblylang.think.md)
+- [`cortal.execution.assemblylang.recall`](./assemblylang.recall.md)
+- [`cortal.focus`](./cortal.focus.md)
+- [`focus.motion.primitives`](./focus.motion.primitives.md)
+- [`questions`](./questions.md)

package/dist/logic/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.1.primitives.recall.md

@@ -0,0 +1,149 @@
+# 💾 .brief: `cortal.execution.assemblylang.recall`
+
+## .what
+
+`<recall>` operations handle **conceptual memory** —
+the ability to **load**, **save**, or **swap** information across reasoning steps.
+
+They interact with both:
+
+- **`focus.context.memory`** → the thread-local stash of concepts, claims, or state
+- **external stores** → domain memory, concept maps, or semantic caches
+
+> `<recall>` is the **I/O system** of structured thought —
+> enabling **retrieval**, **storage**, and **reuse** of mental content.
+
+---
+
+## 💾 memory types
+
+| memory layer        | accessed by `<recall>` | contents                                |
+|---------------------|------------------------|------------------------------------------|
+| `focus.context.memory` | ✅                  | local trace of concepts or claims        |
+| long-term knowledge | ✅                    | persistent domain concepts, schemas      |
+| working cache       | ✅                    | transient partial answers or inputs      |
+| external artifacts  | ✅                    | files, documents, prompts, past actions  |
+
+---
+
+## 🧠 recall = semantic memory I/O
+
+| op         | direction | description                             |
+|------------|-----------|-----------------------------------------|
+| `<save>`   | write     | stores current state (concept or context) |
+| `<load>`   | read      | restores previously saved or known content |
+| `<swap>`   | both      | exchanges in-focus concept with another   |
+
+---
+
+## 🧠 what can be recalled?
+
+| target          | example                        | notes                                 |
+|------------------|-------------------------------|----------------------------------------|
+| concepts         | `[concept:"banana"]`           | semantic node                         |
+| paths            | `banana → fruit → plant`       | conceptual chains                     |
+| claims           | `[claim:"fruit is edible"]`    | inference units                       |
+| contexts         | `.focus.context`               | restore attention posture             |
+| motions          | motion primitive sequences     | saved thinking routines               |
+| generated ideas  | imagined or computed concepts  | outputs of `<think>`                  |
+
+---
+
+## 🧩 example usage
+
+### 🔹 `<save>`
+
+\`\`\`ts
+<save>({
+  concept: [banana],
+  label: "current"
+})
+\`\`\`
+
+- stores the current anchor and its associated context under a label
+
+---
+
+### 🔹 `<load>`
+
+\`\`\`ts
+<load>("current")
+→ [banana]
+\`\`\`
+
+- retrieves the previously saved concept + context and reactivates focus
+
+---
+
+### 🔹 `<swap>`
+
+\`\`\`ts
+<swap>({
+  from: "current",
+  to: "analogy_candidate"
+})
+\`\`\`
+
+- swaps two memory slots or concept anchors
+
+---
+
+## 🔁 example flow
+
+\`\`\`ts
+<route>([
+  <save>("problem"),
+  <steer>(...),
+  <load>("problem"),
+  <think>(<imagine>(...)),
+  <save>("hypothesis")
+])
+\`\`\`
+
+- persist a concept for reference
+- move away via `<steer>`
+- reload when needed
+- evolve via `<think>`
+- store the new output for future logic
+
+---
+
+## 🔄 distinction from `<think>` and `<steer>`
+
+| op         | changes concept? | changes context? | structural flow? | persistent effect? |
+|------------|------------------|------------------|------------------|---------------------|
+| `<steer>`   | ✅                | maybe            | ✅ yes           | ⛔ ephemeral         |
+| `<think>`   | ✅ or no          | ✅                | ⛔               | ⛔ unless saved      |
+| `<recall>`  | ✅                | ✅                | ⛔               | ✅ stores/loads      |
+
+> `<recall>` is not computation or traversal —
+> it's **data movement** within or across the semantic runtime.
+
+---
+
+## 🧱 semantic analogy
+
+| assembly op   | `<recall>` equivalent         |
+|---------------|-------------------------------|
+| `MOV`         | `<load>` or `<save>`          |
+| `PUSH` / `POP`| context save/restore          |
+| `XCHG`        | `<swap>`                      |
+| `LOAD` / `STORE` | memory access              |
+
+---
+
+## 📌 integration
+
+- `<recall>` enables **stateful reasoning**
+- supports **repetition**, **reference**, **comparison**, **planning**
+- all coreops (`<steer>`, `<think>`, `<recall>`) can share memory
+
+---
+
+## 🔁 related briefs
+
+- [`cortal.focus`](./cortal.focus.md)
+- [`focus.motion.primitives`](./focus.motion.primitives.md)
+- [`cortal.execution.instructionset`](./instructionset.md)
+- [`cortal.execution.assemblylang.steer`](./assemblylang.steer.md)
+- [`cortal.execution.assemblylang.think`](./assemblylang.think.md)

package/dist/logic/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.1.primitives.steer.md

@@ -0,0 +1,146 @@
+# 🛤️ .brief: `cortal.execution.assemblylang.steer`
+
+## .what
+
+`<steer>` operations are the **procedural control structures** of structured thought —
+they determine **how** reasoning flows from one concept to another.
+
+But unlike low-level machine instructions that jump to fixed addresses,
+cognitive `<steer>` ops depend on **semantic resolution** —
+which means they must intersect with **questions**.
+
+> `<steer>` = how to move
+> `question` = where to move
+
+---
+
+## 🧠 dual-layer model
+
+| layer                 | function                      | analogy                           |
+|-----------------------|-------------------------------|------------------------------------|
+| **`<steer>`**         | procedural flow control        | `JMP`, `CALL`, `IF`, `LOOP`        |
+| **`question`**        | semantic address resolution    | symbolic pointer / jump condition |
+
+---
+
+## 🧭 semantic execution
+
+All `<steer>` operations rely on **questions** to determine motion targets.
+
+- `<route>` steps → defined by a question per step
+- `<cycle>` loops → governed by a question that acts as a guard
+- `<fanout>` branches → determined by a generative question
+- `<choice>` forks → chosen via evaluative question
+- `<await>` suspends → until a query is answerable
+
+---
+
+## 🪜 example
+
+\`\`\`ts
+<route>([
+  ask("what failed?"),
+  imagineFix(),
+  ask("how can it be tested?")
+])
+\`\`\`
+
+- the **steer structure** is a `route`
+- the **steps** are chosen via **semantic questions**
+- each question grows 🌿 **branches from the current 🫐 berry**
+
+---
+
+## 🔄 interaction model
+
+| role             | mechanism                 | description                                   |
+|------------------|---------------------------|-----------------------------------------------|
+| **vector**        | `question`                | defines semantic motion direction             |
+| **motion pattern**| `<steer>` op              | determines flow structure (route, loop, etc)  |
+| **anchor**        | `focus.concept`           | current semantic location                     |
+| **landing**       | result of `question`      | target concept (resolved berry)               |
+
+---
+
+## 🧬 example intersections
+
+### `<choice>`
+
+\`\`\`ts
+<choice>({
+  condition: ask("what kind of problem is this?"),
+  options: {
+    mechanical: solveMechanical(),
+    electrical: solveElectrical()
+  }
+})
+\`\`\`
+
+→ question resolves a **label** → steer dispatches to that **branch**
+
+---
+
+### `<cycle>`
+
+\`\`\`ts
+<cycle>({
+  step: ask("is the design correct?"),
+  until: answer("yes")
+})
+\`\`\`
+
+→ **repeats traversal** until a **question is resolved**
+
+---
+
+### `<fanout>`
+
+\`\`\`ts
+<fanout>({
+  branches: ask("what alternative solutions exist?")
+})
+\`\`\`
+
+→ parallel branches are grown **from a generative question**
+
+---
+
+## 💡 mental model
+
+> `question` is the **semantic vector**
+> `<steer>` is the **execution pattern**
+> together, they produce **navigable, interpretable thought**
+
+---
+
+## 📐 analogy
+
+| component     | machine analogue        | cognitive role                    |
+|---------------|--------------------------|------------------------------------|
+| `JMP`         | `<steer>`                | controls flow                     |
+| label address | `question`               | resolves destination              |
+| PC (pointer)  | `focus.concept`          | current location in semantic space|
+
+---
+
+## 🧩 design takeaway
+
+> **Questions make `<steer>` meaningful.**
+> **Without questions, `<steer>` is blind.**
+> **Without `<steer>`, questions go nowhere.**
+
+Semantic navigation requires **both**:
+
+- `<steer>` to manage **motion structure**
+- `questions` to define **motion vector**
+
+---
+
+## 🔁 future integration
+
+This brief connects to:
+
+- [`cortal.execution.instructionset`](./instructionset.md)
+- [`questions`](./questions.md)
+- [`focus.motion.primitives`](./focus.motion.primitives.md)
+

package/dist/logic/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.1.primitives.think.md

@@ -0,0 +1,141 @@
+# 🧠 .brief: `cortal.execution.assemblylang.think`
+
+## .what
+
+`<think>` operations execute **semantic processing** over the current focus.
+They operate on both:
+
+- **`focus.concept`** → the semantic anchor (🫐 berry)
+- **`focus.context`** → the attention posture (🔦 lightcone shape)
+
+They are the **computational core** of structured thought —
+driven by one or more **`focus.motion.primitives`**,
+and capable of modifying focus **content**, **posture**, or both.
+
+> `<think>` is how minds **transform**, **refine**, **blend**, or **generate** meaning.
+
+---
+
+## 🧱 core distinction
+
+| role      | behavior                                       |
+|-----------|------------------------------------------------|
+| `<steer>` | controls procedural flow shape                 |
+| `<think>` | transforms content via motion primitives       |
+| `<recall>`| interfaces with memory / stores or restores    |
+
+---
+
+## 🔀 full motion access
+
+> **`<think>` can apply any combination of `focus.motion.primitives`**.
+
+That includes:
+
+- cross-axis compositions (`.depth` + `.acuity` + `.breadth`)
+- multi-hop motion chains
+- reversible/invertible transformations
+
+| axis           | primitives allowed                          |
+|----------------|----------------------------------------------|
+| `focal.acuity` | `<articulate>`, `<compress>`, `<decompose>`, `<encompose>` |
+| `focal.depth`  | `<generalize>`, `<instantiate>`             |
+| `focal.breadth`| `<shift>`, `<rotate>`, `<invert>`           |
+
+→ `<think>` is the **only** coreop that allows **unrestricted motion composition**
+→ other ops (`<steer>`, `<recall>`) are structurally scoped
+
+---
+
+## 🧠 anchored and generative behavior
+
+| behavior type          | allowed in `<think>`? | example                                           |
+|------------------------|------------------------|---------------------------------------------------|
+| enrich concept traits  | ✅                     | `<articulate>`                                    |
+| reveal parts           | ✅                     | `<decompose>`                                     |
+| reframe perspective    | ✅                     | `<rotate>`, `<invert>`                            |
+| generate new anchor    | ✅                     | `<imagine>` → `[concept:"moon"]` from `[concept:"banana"]` |
+| update context posture | ✅                     | adjust depth, breadth, or acuity dynamically      |
+
+---
+
+## 🧮 `<compute>` vs `<imagine>`
+
+| op          | nature         | behavior style                         |
+|-------------|----------------|----------------------------------------|
+| `<compute>` | deterministic  | rule-based, logical, filter/merge      |
+| `<imagine>` | generative     | creative, analogical, probabilistic    |
+
+both support:
+
+- multi-primitive composition
+- anchor refinement or replacement
+- cross-axis motion
+
+---
+
+## 🧬 `<think>` may recenter focus
+
+Although `<steer>` is usually responsible for traversal,
+**`<think>` can change the `focus.concept` as a byproduct of generation**:
+
+\`\`\`ts
+<imagine>(<reframe>([banana]))
+→ [crescent moon] // anchor has shifted
+\`\`\`
+
+This is **not structural traversal**, but **semantic evolution** —
+a result of content computation, not flow redirection.
+
+---
+
+## 🧭 runtime vs devtime thinking
+
+`<think>` operations appear in **two modes**:
+
+### 🧠 1. **runtime `<think>` inside `<steer>`**
+
+Used dynamically during reasoning:
+
+\`\`\`ts
+<route>([
+  <compute>(<decompose>[bike]),
+  <imagine>(<reframe>[bike])
+])
+\`\`\`
+
+- `<steer>` provides the procedural shell
+- `<think>` performs context-aware computation
+
+---
+
+### 🧠 2. **devtime `<think>` hardcoded into `<steer>`**
+
+Used at design time to precompute steps:
+
+\`\`\`ts
+<route>([
+  concept: [fruit-based tool],  // result of devtime `<imagine>`
+  action: usePremadeInstruction(...)
+])
+\`\`\`
+
+- concept shifts or synthesis is done in advance
+- `<steer>` structure includes pre-baked ideas
+
+---
+
+## 📌 pattern summary
+
+> `<steer>` is the **flow shape**
+> `<think>` is the **content transformation**
+> `<think>` can be used **at runtime** or **compiled into `<steer>`** at design time
+
+---
+
+## 🔁 related briefs
+
+- [`cortal.focus`](./cortal.focus.md)
+- [`focus.motion.primitives`](./focus.motion.primitives.md)
+- [`cortal.execution.instructionset`](./instructionset.md)
+- [`cortal.execution.assemblylang.steer`](./assemblylang.steer.md)