rhachet-roles-ehmpathy 1.1.0 → 1.3.0

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)

package/dist/logic/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.2.composites.zoom.md

@@ -0,0 +1,127 @@
+# 🔎 .brief: `cortal.execution.assemblylang.zoom`
+
+## .what
+
+`<zoom>` is a **composite assemblylang operation**
+used to reshape **`focus.context`** by applying a structured sequence of:
+
+- `<think>` — to process or generate detail
+- `<recall>` — to retrieve supporting memory or context
+- `<steer>` — to navigate to concept-adjacent resources
+
+It adjusts **how attention is configured**, not just **what is in focus** —
+enabling deliberate expansion or contraction of **depth**, **breadth**, **acuity**, or blends of all three.
+
+---
+
+## 🧭 directional forms
+
+| form              | effect                              |
+|-------------------|--------------------------------------|
+| `<zoom><in>`      | increase contextual richness         |
+| `<zoom><out>`     | decrease contextual load or scope    |
+
+→ both forms operate **within or near the current `focus.concept`**,
+and update **`focus.context`** as their primary target.
+
+---
+
+## 🧩 axes of zooming
+
+Each zoom may declare one or more **focus dimensions** or subaxes via `.via(...)`:
+
+\`\`\`ts
+<zoom><in>.via("attributes")        // enrich trait resolution
+<zoom><out>.via("depth")            // abstract away from specifics
+<zoom><in>.via("substructs", "depth") // composite focus sharpening
+\`\`\`
+
+| axis            | zoom in effect                      | zoom out effect                        |
+|------------------|--------------------------------------|------------------------------------------|
+| `attributes`     | `<articulate>`                      | `<compress>`                             |
+| `substructs`     | `<decompose>`                       | `<encompose>`                            |
+| `depth`          | `<instantiate>`                     | `<generalize>`                           |
+| `breadth`        | `<shift>` / `<fanout>`              | `<rotate>` / `<invert>` / prune peers    |
+
+---
+
+## 🔧 zoom as composite coreop
+
+Unlike primitive coreops, `<zoom>`:
+
+- **has no fixed form** — it is always a composed chain
+- **is defined by purpose** — modulate attention shape
+- **may include multiple coreops** in sequence or parallel
+
+---
+
+## 🧠 example: single-axis zoom in
+
+\`\`\`ts
+<zoom><in>.via("substructs") = [
+  <recall>("known parts"),
+  <think>(<decompose>)
+]
+\`\`\`
+
+---
+
+## 🧠 example: multi-axis zoom out
+
+\`\`\`ts
+<zoom><out>.via("breadth", "depth") = [
+  <recall>("sibling concepts"),
+  <think>(<generalize>),
+  <steer>(<fanout>)
+]
+\`\`\`
+
+---
+
+## 🛠️ use cases
+
+| scenario                          | zoom form                       |
+|-----------------------------------|----------------------------------|
+| examine the internal structure    | `<zoom><in>.via("substructs")`   |
+| find similar alternatives         | `<zoom><out>.via("breadth")`     |
+| simplify framing and focus        | `<zoom><out>.via("attributes")`  |
+| generate specific variants        | `<zoom><in>.via("depth")`        |
+| design from multiple dimensions   | `<zoom><in>.via("depth", "attributes", "substructs")` |
+
+---
+
+## 🔄 relation to other coreops
+
+| op         | acts on          | motion pattern | context reshaping |
+|------------|------------------|----------------|--------------------|
+| `<steer>`  | `focus.concept`  | procedural     | indirectly         |
+| `<think>`  | `focus.*`        | local          | ✅ yes             |
+| `<recall>` | memory/interface | static or indirect | ✅ yes        |
+| **`<zoom>`**   | `focus.context`  | composite       | ✅ **primary**     |
+
+---
+
+## 🔁 runtime & devtime support
+
+Like `<think>`, `<zoom>` can be:
+
+- **executed dynamically** inside `<steer>` or `<choice>` blocks
+- **precompiled** into `<steer>` routes to pre-shape context before key steps
+
+---
+
+## 📌 metaphor
+
+> `<zoom>` is like turning the **lens dial** of your semantic focus —
+> it widens, sharpens, simplifies, or recasts your cognitive beam.
+
+---
+
+## 🔁 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)
+- [`cortal.execution.assemblylang.recall`](./assemblylang.recall.md)

package/dist/logic/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.3.catalogs.md

@@ -0,0 +1,107 @@
+# 📚 .brief: `cortal.catalogs`
+
+## .what
+
+`cortal.catalogs` are **structured repositories of reusable cognition** —
+collections of **semantic tools** that support fast, interpretable reasoning without starting from scratch.
+
+There are two main kinds:
+
+1. **question catalogs** → reusable **motion vectors**
+2. **assembly catalogs** → reusable **thought sequences**
+
+> catalogs capture **well-shaped recipes** —
+> high-quality, repeatable semantic moves.
+
+---
+
+## ❓ 1. question catalogs
+
+A **question** is a **motion vector** through concept space.
+A **question catalog** collects **reusable semantic maneuvers**, each defined only by:
+
+- **motion.vector** → what kind of semantic motion it performs
+- **motion.usecases** → when and why this motion is useful
+
+### example entries:
+
+| question                                 | motion.vector                 | motion.usecases                   |
+|------------------------------------------|--------------------------------|------------------------------------|
+| `what caused this?`                      | `.depth++`                    | causal diagnosis                   |
+| `what are alternatives?`                 | `.breadth++`                  | option generation                  |
+| `how is this composed?`                  | `.acuity.substruct++`         | structural decomposition           |
+| `what’s missing?`                        | `.acuity.attribute++`         | completeness / gap-finding         |
+| `is this still true?`                    | `.context.refresh`            | contextual verification            |
+
+> 📍 questions **do not define context or concept** —
+> they are **pure motion vectors**, reusable anywhere.
+
+---
+
+## 🛠️ 2. assembly catalogs
+
+An **assembly** is a **compiled thought sequence** —
+a stepwise **atomic chain** built from primitives like `<steer>`, `<think>`, and `<recall>`.
+
+An **assembly catalog** collects common **reasonage workflows**
+that can be reused, adapted, or parameterized.
+
+### example entries:
+
+#### 🧠 diagnosis loop
+
+\`\`\`ts
+<route>([
+  ask("what failed?"),
+  <think>(<decompose>[system]),
+  ask("what caused this part to fail?"),
+  <recall>(<save>("hypothesis"))
+])
+\`\`\`
+
+#### 🎯 selection flow
+
+\`\`\`ts
+<route>([
+  ask("what are the options?"),
+  <fanout>[[option]],
+  <compare>[[option]] → [criteria],
+  ask("which is most viable?"),
+  <choice>({...})
+])
+\`\`\`
+
+> assemblies are **semantic macros** — reusable atomic chains of thought
+
+---
+
+## 🔁 reuse vs scratch
+
+| method         | advantage                                |
+|----------------|-------------------------------------------|
+| from scratch   | custom-tailored, cognitively expensive    |
+| from catalog   | efficient, proven, semantically smooth    |
+
+> 🧠 good catalogs let you **plug in your content**
+> without reinventing the flow.
+
+---
+
+## 🧩 catalog roles
+
+| kind       | unit           | function                            |
+|------------|----------------|-------------------------------------|
+| `question` | motion vector  | semantic traversal pattern          |
+| `assembly` | atomic chain   | procedural thought sequence         |
+
+---
+
+## 🔁 related briefs
+
+- [`questions`](./questions.md)
+- [`cortal.assemblylang.primitives`](./cortal.assemblylang.primitives.md)
+- [`cortal.execution.instructionset`](./instructionset.md)
+- [`cortal.assembly.grammar`](./cortal.assembly.grammar.md)
+- [`focus.motion.primitives`](./focus.motion.primitives.md)
+
+---

package/dist/logic/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.3.grammar.md

@@ -0,0 +1,124 @@
+# 🧩 .brief: `cortal.assembly.grammar`
+
+## .what
+
+`cortal.assembly.grammar` defines how **execution primitives** and **conceptual references**
+combine into flat, **stepwise semantic expressions**.
+
+It provides a low-level syntax for:
+
+- executing primitives (`<steer>`, `<think>`, `<recall>`)
+- referencing semantic units (`[X]`, `[[X]]`)
+- expressing flat operations that yield either **single or pooled** outputs
+
+> expressions are always **one level deep** — atomic, interpretable, and
+> suitable for line-by-line execution or inspection.
+
+---
+
+## 🧠 expression structure
+
+Each instruction uses this flat format:
+
+\`\`\`ts
+<operation>[input] → [output]
+\`\`\`
+
+- `<operation>`: one of the core execution primitives or motion commands
+- `[input]`: a **singular** resource
+- `[[input]]`: a **plural** resource (a pool)
+- `[output]`: result of the operation, may also be singular or plural
+
+> both **input** and **output** may be pools (`[[X]]`) or single items (`[X]`)
+
+---
+
+## 📦 resource forms
+
+| form         | meaning                                 |
+|--------------|------------------------------------------|
+| `[X]`        | a **singular resource** (concept)        |
+| `[[X]]`      | a **plural resource** (pool of concepts) |
+| `[Class]`    | abstract type or category                |
+| `[example]`  | instance of a class                      |
+
+Examples:
+
+\`\`\`ts
+<compare>[[fruit]] → [axis]
+<gather>[[claim]] → [[evidence]]
+<imagine>[Tool] → [[tool]]
+\`\`\`
+
+> `[[X]]` = pool
+> `[X]` = single concept
+
+---
+
+## 🧪 example: class to instance pool
+
+\`\`\`ts
+<imagine>[Threat] → [[threat]]
+\`\`\`
+
+- `[Threat]` is a class
+- `[[threat]]` is a **pool** of generated examples
+- `<imagine>` returns **many plausible manifestations**, not one
+
+---
+
+## 🧠 roles in the grammar
+
+| element       | role                          | example                  |
+|---------------|-------------------------------|---------------------------|
+| `<op>`        | execution primitive            | `<decompose>`, `<save>`   |
+| `[X]`         | singular operand               | `[banana]`, `[Tool]`      |
+| `[[X]]`       | plural operand                 | `[[fruit]]`, `[[idea]]`   |
+| `→`           | yields                         | motion result             |
+| `[Y]`         | singular output                | `[axis]`, `[knife]`       |
+| `[[Y]]`       | plural output                  | `[[tool]]`, `[[claim]]`   |
+| `"label"`     | memory reference               | `"draft"`, `"goal"`       |
+
+---
+
+## 📏 grammar rules
+
+- ❌ **No nesting:**
+  \`\`\`ts
+  <compress>(<decompose>[X])    // ❌ invalid
+  \`\`\`
+
+- ✅ **Use chaining instead:**
+  \`\`\`ts
+  <decompose>[bike] → [parts]
+  <compress>[parts] → [summary]
+  \`\`\`
+
+- ✅ **Use memory for state passing:**
+  \`\`\`ts
+  <save>("bike")
+  <load>("bike") → [bike]
+  \`\`\`
+
+---
+
+## 🧩 grammar patterns
+
+| pattern                             | purpose                                |
+|-------------------------------------|----------------------------------------|
+| `<imagine>[Class] → [[examples]]`   | generate a pool of concept instances   |
+| `<compare>[[peers]] → [axis]`       | extract trait from a set               |
+| `<steer>[goal]`                     | change focal anchor                    |
+| `<recall>(<save>["label"])`         | persist semantic state                 |
+
+---
+
+## 🔁 related briefs
+
+- [`cortal.assemblylang.primitives`](./cortal.assemblylang.primitives.md)
+- [`focus.motion.primitives`](./focus.motion.primitives.md)
+- [`cortal.focus`](./cortal.focus.md)
+- [`questions`](./questions.md)
+- [`concept.treestruct`](./concept.treestruct.md)
+
+---