rhachet-roles-ehmpathy 1.12.1 → 1.13.1

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

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

@@ -1,134 +0,0 @@
-# 🧠 .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

@@ -1,149 +0,0 @@
-# 💾 .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

@@ -1,146 +0,0 @@
-# 🛤️ .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

@@ -1,141 +0,0 @@
-# 🧠 .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)