rhachet-roles-ehmpathy 1.15.12 → 1.15.14

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

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

@@ -1,127 +0,0 @@
-# 🔎 .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/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.3.catalogs.md

@@ -1,107 +0,0 @@
-# 📚 .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/roles/bhrain/.briefs/cognition/cog501.cortal.assemblylang.3.grammar.md

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