rhachet-roles-ehmpathy 1.0.0 → 1.1.0

package/dist/logic/roles/bhrain/.briefs/physics/optics.focal.distance.md

@@ -0,0 +1,92 @@
+# .brief: focal.distance
+
+## what
+
+**focal.distance** refers to the **distance from the lens to the focal plane** — the exact location in space where the subject is brought into geometric focus.
+
+---
+
+## why
+
+While **focal.acuity** defines *how finely* the focal plane is rendered, and **focal.depth** defines *how far* sharpness extends around it, **focal.distance** defines *where* that clarity is placed in the scene.
+
+It controls:
+- Subject framing and spatial scale
+- The perceived compression of background and foreground
+- The sensitivity of focus and blur relationships in space
+
+---
+
+## governed by
+
+### 📐 Thin lens equation
+
+```\`\`
+1/f = 1/focal.distance + 1/image_distance
+\`\```
+
+This determines **where** the focal plane sits for a given lens.
+
+---
+
+### 🔧 How aperture interacts — via depth of field
+
+The **relationship between aperture and focal.distance** emerges through the depth of field equation:
+
+```\`\`
+focal.depth ≈ (2 * N * c * focal.distance²) / f²
+\`\```
+
+where
+- `N` = aperture (f-number)
+- `c` = circle of confusion (maximum acceptable blur)
+- `focal.distance` = subject distance (from lens to focal plane)
+- `f` = focal length, a fn of `focal.breadth`
+
+simplified
+- assume `c = d = 2.44 * λ * N`, a diffraction-limited system
+- deref `f ∝ k₁ / focal.breadth`, by definition
+
+```\`\`
+focal.depth ∝ N² × focal.distance² × focal.breadth²
+\`\```
+
+---
+
+## key behaviors
+
+| Adjustment               | Effect on focal.distance           |
+|--------------------------|------------------------------------|
+| Physically moving closer | decreases it                       |
+| Stepping farther back    | increases it                       |
+| Using wider aperture     | makes the system more sensitive to small changes in focal.distance |
+| Using smaller aperture   | tolerates more deviation from exact distance |
+
+---
+
+## creative usage
+
+- **Close focal.distance**:
+  - Emphasizes subject
+  - Increases blur and isolation
+  - Requires precision
+
+- **Far focal.distance**:
+  - Expands depth
+  - Stabilizes scene-wide focus
+  - Suits landscapes, architecture, and static subjects
+
+---
+
+## limitations
+
+- Very close distances drastically reduce focal.depth
+- Large apertures require extremely accurate focusing at short distances
+- Focal.distance interacts with both lens choice and aperture behavior
+
+---
+
+## metaphorical phrasing
+
+> **focal.distance** is your **placement of intent** — it marks where clarity lands.
+> The closer it lies, the tighter your tolerance must be; the farther it stretches, the more generous the depth becomes.

package/dist/logic/roles/bhrain/.briefs/physics/optics.focal.tradeoffs.md

@@ -0,0 +1,107 @@
+# .brief: focal.tradeoffs
+
+## what
+
+**focal.tradeoffs** describe the physical constraint that links:
+
+- **focal.acuity** — the fineness of detail resolvable **at the focal plane**
+- **focal.breadth** — the angular or spatial extent of the field of view (FoV)
+- **focal.distance** — the distance **from the lens to the focal plane**
+- **focal.depth** — the range of distances **around the focal plane** that remain acceptably sharp
+
+These four factors are coupled by the geometry of light: changing one requires compensating adjustments to at least one of the others. The relationship models the inescapable tradeoffs in all optical focus systems.
+
+---
+
+## equation
+
+Assuming constant sensor size and fixed circle of confusion:
+
+\`\`\`ts
+// given
+focal.depth ∝ N² × focal.distance² × focal.breadth²
+focal.acuity ∝ 1 / N
+
+// then
+N ∝ 1 / focal.acuity
+focal.depth ∝ (1 / focal.acuity)² × focal.distance² × focal.breadth²
+focal.depth ∝ focal.distance² × focal.breadth² / focal.acuity²
+
+// therefore
+focal.acuity² × focal.depth ∝ focal.distance² × focal.breadth²
+\`\`\`
+
+---
+
+## key relationship
+
+\`\`\`
+focal.acuity² × focal.depth ∝ focal.distance² × focal.breadth²
+\`\`\`
+
+> You can only maximize two at a time — the other two must yield.
+
+---
+
+## variable meanings
+
+- **focal.acuity** — how finely your lens resolves detail at the point of focus
+- **focal.breadth** — how wide your frame sees (field of view)
+- **focal.depth** — how far the focus zone stretches through space
+- **focal.distance** — how close or far the focal plane is set
+
+---
+
+## tradeoff matrix
+
+| Want to increase…     | Compensate by…                                   |
+|------------------------|--------------------------------------------------|
+| **focal.acuity** ↑     | decrease depth ↓, step back ↑, narrow breadth ↓ |
+| **focal.breadth** ↑    | reduce acuity ↓, step back ↑, flatten depth ↓   |
+| **focal.depth** ↑      | reduce acuity ↓, step back ↑, compress breadth ↓|
+| **focal.distance** ↓   | reduce depth ↓, increase acuity ↑, narrow breadth ↓ |
+
+---
+
+## verbal examples
+
+- want **finer details**? (focal.acuity++)
+- then, either
+  - step back (focal.distance++)
+  - collapse depth (focal.depth--)
+  - crop field of view (focal.breadth--)
+
+- want a **wider scene**? (focal.breadth++)
+- then, either
+  - reduce acuity (focal.acuity--)
+  - step back (focal.distance++)
+  - tolerate shallow depth (focal.depth--)
+
+- want **deeper focus**? (focal.depth++)
+- then, either
+  - reduce acuity (focal.acuity--)
+  - step back (focal.distance++)
+  - narrow scene (focal.breadth--)
+
+- want to get **closer**? (focal.distance--)
+- then, either
+  - reduce depth (focal.depth--)
+  - increase sharpness (focal.acuity++)
+  - narrow scene (focal.breadth--)
+
+---
+
+## best practice zone
+
+For full-frame photography:
+
+- Aperture: f/5.6 to f/8
+- Distance: 2–5 meters
+- Focal length: 35mm–85mm (moderate breadth)
+
+This keeps the optical balance manageable:
+
+- **focal.acuity**: avoids diffraction or aberration
+- **focal.breadth**: flexible for framing
+- **focal.depth**: useful for subject layering
+- **focal.distance**: compositional stability

package/dist/logic/roles/bhrain/.briefs/tactic.<think>[idea]/composite/<triangulate>[concept].md

@@ -0,0 +1,66 @@
+# 🧠 .brief: <triangulate>[concept]
+
+Triangulation is a composite reasoning move that sharpens your understanding of a concept by **comparing it against lateral peers** within the same semantic layer.
+
+---
+
+## 💬 .what
+
+`<triangulate>[X]` = **position X more precisely** by:
+- identifying **lateral peers** (same abstraction layer)
+- detecting **similarities and contrasts**
+- surfacing the **defining traits** that distinguish X
+
+---
+
+## 🧭 .why
+
+Helps form **clean category boundaries**, **disambiguate meanings**, and **diagnose** unclear or overloaded concepts.
+
+This move is especially useful when:
+- a concept is fuzzy or ambiguous
+- you're choosing between similar options
+- you want to articulate the essence of something
+
+---
+
+## 🧩 composition grammar
+
+\```
+<triangulate>[X] =
+  <zoomout><breadth>[X]
+  → <collect>[peers]
+  → <contrast>[X, peers]
+\```
+
+Or, compactly:
+
+\```
+<triangulate>[X] = <zoomout><breadth>[X] → <contrast>
+\```
+
+This reflects:
+- `focal.breadth++` → explore lateral options
+- `focal.acuity++` → resolve fine differences
+
+---
+
+## 🧪 examples
+
+### 🔨 <triangulate>[concept:"hammer"]
+→ compare with [concept:"wrench"], [concept:"mallet"], [concept:"crowbar"]
+→ highlight traits like `percussive.force`, `flat.face`, `handle.shape`
+
+### 🐕 <triangulate>[concept:"dog"]
+→ contrast with [concept:"cat"], [concept:"fox"], [concept:"wolf"]
+→ detect relational traits like `domesticated`, `pack.behavior`, `human.bonding`
+
+### 💡 <triangulate>[concept:"idea"]
+→ compare with [concept:"thought"], [concept:"concept"], [concept:"plan"]
+→ sharpen meaning by isolating `creative.specificity` and `actionability`
+
+---
+
+## 🔭 metaphor
+
+Like using multiple landmarks to determine your position, triangulation defines a concept **by its contrastive coordinates** relative to nearby meanings.

package/dist/logic/roles/bhrain/.briefs/tactic.<think>[idea]/primitive/<zoom>._.md

@@ -0,0 +1,124 @@
+# 🔎 .brief: `<zoom>` operations over concept.treestruct
+
+## .what
+The `<zoom>` family defines **directional traversal mechanisms** through a radial `concept.treestruct`, where each `<zoom>` operation tunes one of the three core `cortal.focus` dimensions:
+
+- **acuity** = semantic sharpness per concept
+- **breadth** = angular cone of included neighbors
+- **depth** = radial span of abstraction/specialization layers
+
+Each `<zoom>` takes the form:
+
+\\```text
+<zoom>[dimension]<verb>[concept]
+\\```
+
+Where:
+- `zoom` ∈ `zoomin`, `zoomout`
+- `dimension` ∈ `acuity`, `breadth`, `depth`
+- `verb` = traversal verb describing the motion
+- `concept` = anchor node of exploration
+
+---
+
+## 🔍 `<zoomin>` operations
+
+### 🔎 `<zoomin>[acuity]<sharpen>[concept]`
+
+**Effect:** Increases semantic resolution of the concept
+**Focus:** Reveals more attributes or distinguishing traits
+
+#### Example:
+- `"banana"`
+  → observes `spot.pattern`, `firmness.range`, `skin.porosity`, `sugar.level`
+
+---
+
+### 🧩 `<zoomin>[breadth]<decompose>[concept]`
+
+**Effect:** Splits concept into constituent parts or roles
+**Focus:** Internal structure, contents, or mechanisms
+
+#### Example:
+- `"toolbox"`
+  → by contents: `"hammer"`, `"wrench"`, `"tape measure"`
+  → by material: `"metal tools"`, `"plastic tools"`
+  → by chronology: `"modern tools"`, `"legacy tools"`
+
+---
+
+### 🧠 `<zoomin>[depth]<abstractify>[concept]`
+
+**Effect:** Moves radially inward toward more abstract cores
+**Focus:** Generalizes anchor into higher-category meanings
+
+#### Example:
+- `"banana"`
+  → `"fruit"`
+  → `"plant organ"`
+  → `"edible biological thing"`
+  → `"physical object"`
+
+---
+
+## 🌌 `<zoomout>` operations
+
+### 🌫️ `<zoomout>[acuity]<blurren>[concept]`
+
+**Effect:** Lowers the semantic resolution of focus
+**Focus:** Tracks fewer attributes per concept; smooths over distinctions
+
+#### Example:
+- `"banana"`
+  → as just `"fruit"`
+  → then just `"thing to eat"`
+  → eventually just `"thing"`
+
+---
+
+### 🌐 `<zoomout>[breadth]<broaden>[concept]`
+
+**Effect:** Gathers neighboring concepts across multiple axes
+**Focus:** Expands context and increases semantic diversity
+
+#### Example:
+- `"banana"`
+  → categorical neighbors: `"mango"`, `"apple"`, `"pear"`
+  → functional neighbors: `"bread"`, `"snack"`, `"lunch item"`
+  → narrative neighbors: `"banana peel joke"`, `"banana split"`
+
+---
+
+### 🧪 `<zoomout>[depth]<elaborate>[concept]`
+
+**Effect:** Deepens outward — reveals specific examples or applications
+**Focus:** Subtypes, refinements, or concrete variants
+
+#### Example:
+- `"banana"`
+  → `"peeled banana"`
+  → `"frozen banana on a stick"`
+  → `"banana in smoothie"`
+  → `"banana in Andy Warhol art"`
+
+---
+
+## 🎯 use cases
+
+| zoom        | dimension | use for...                          |
+|-------------|-----------|-------------------------------------|
+| `<zoomin>`  | acuity    | diagnostics, subfeature analysis    |
+| `<zoomin>`  | breadth   | teaching composition, breaking down |
+| `<zoomin>`  | depth     | theory building, category modeling  |
+| `<zoomout>` | acuity    | simplicity, gist-level framing      |
+| `<zoomout>` | breadth   | comparison, brainstorming, context  |
+| `<zoomout>` | depth     | scenario building, case discovery   |
+
+---
+
+## 🧩 related
+
+- `cortal.focus` → determines focus beam shape (depth × acuity² ∝ breadth²)
+- `concept.treestruct` → radial semantic terrain
+- `<pan>` → lateral traversal between semantic peers
+- `<refocus>` → relocate the anchor node of attention

package/dist/logic/roles/bhrain/.briefs/tactic.<think>[idea]/primitive/<zoomin>[acuity]<sharpen>[concept].md

@@ -0,0 +1,53 @@
+# 🎯 .brief: <zoomin>[acuity]<sharpen>[concept]
+
+## .what
+`<sharpen>` increases the **focal acuity** on a concept — revealing **more detailed attributes**, traits, and inner structure.
+It is a **radial inward motion** on the **acuity axis**, without changing abstraction depth or neighbor scope.
+
+This does **not** move to a more specific example.
+Instead, it **resolves the same concept** at a **finer grain**, exposing its internal features.
+
+---
+
+## 🧠 how it works
+- `focal.acuity++`
+- `focal.depth = const`
+- `focal.breadth = const`
+
+→ same concept, **sharper resolution**
+→ adds **semantic detail**, **latent features**, and **trait structure**
+
+---
+
+## 🧪 examples
+
+### 🔨 concept: `"hammer"`
+- sharpen: `head.material`, `handle.length`, `strike.force.profile`
+
+### 🐕 concept: `"dog"`
+- sharpen: `fur.length`, `bark.pitch`, `gait.pattern`, `tail.language`
+
+### 🥝 concept: `"kiwi"`
+- sharpen: `fuzz.texture`, `sugar.ratio`, `seed.count`, `acidity.sharpness`
+
+---
+
+## 📐 metaphors
+- like turning up focus on a camera lens: same object, clearer view
+- like shifting from a noun to an **attribute set**
+
+---
+
+## 🔁 related operations
+- `<zoomout>[acuity]<blurren>[concept]` → reduces detail, simplifies the concept holistically
+- `<zoomin>[depth]<abstractify>[concept]` → moves inward along abstraction
+- `<zoomin>[breadth]<decompose>[concept]` → breaks into **examples**, not internal traits
+
+---
+
+## 🔦 when to use
+- during **feature engineering**
+- for **fine classification** or **trait-based comparison**
+- for **design precision** or **diagnostic attention**
+
+> Sharpening helps see **what makes the concept tick** — not what other things are like it.

package/dist/logic/roles/bhrain/.briefs/tactic.<think>[idea]/primitive/<zoomin>[breadth]<decompose>[concept].md

@@ -0,0 +1,67 @@
+# 🎯 .brief: <zoomin>[breadth]<decompose>[concept]
+
+## .what
+`<decompose>` increases **focal breadth** around a concept by surfacing its **internal components**, **parts**, or **dimensions**.
+It is a **zoom-in operation on breadth**: widening the focus *within* the concept to reveal its **semantic neighbors held inside**.
+
+Unlike abstraction or sharpening, **decomposition** explores what the concept **contains**, not what it belongs to, or how fine each trait is.
+
+---
+
+## 🧠 how it works
+- `focal.breadth++`
+- `focal.depth = const`
+- `focal.acuity = const`
+
+→ You stay at the **same semantic depth**, but attend to **more neighbor components** or **sub-concepts** that make up the whole.
+
+---
+
+## 🧪 examples
+
+### 🧰 concept: `"toolbox"`
+Decomposable by:
+- **contents** → what it holds
+  - [concept:"hammer"], [concept:"wrench"], [concept:"screwdriver"], [concept:"tape measure"]
+- **construction** → how it's built
+  - [concept:"hinge"], [concept:"latch"], [concept:"handle"], [concept:"tray insert"]
+- **chronical** → when and how it's used
+  - [concept:"daily maintenance"], [concept:"emergency repairs"], [concept:"project kickoff"], [concept:"seasonal cleanup"]
+
+---
+
+### 🧪 concept: `"experiment"`
+Decomposable by:
+- **logical structure**: [concept:"hypothesis"], [concept:"variables"], [concept:"conclusion"]
+- **temporal phases**: [concept:"setup"], [concept:"execution"], [concept:"analysis"]
+- **roles involved**: [concept:"researcher"], [concept:"subject"], [concept:"observer"]
+
+---
+
+### 🏠 concept: `"home"`
+Decomposable by:
+- **spaces**: [concept:"bedroom"], [concept:"kitchen"], [concept:"garage"]
+- **functions**: [concept:"resting"], [concept:"cooking"], [concept:"storage"]
+- **utilities**: [concept:"plumbing"], [concept:"electricity"], [concept:"heating"]
+
+---
+
+## 📐 metaphor
+- like **opening up a container** to see what’s inside
+- like **zooming in laterally** across its internal slots
+
+---
+
+## 🔁 related operations
+- `<zoomin>[acuity]<sharpen>[concept]` → increases detail per trait
+- `<zoomin>[depth]<abstractify>[concept]` → moves inward toward general meaning
+- `<zoomout>[breadth]` → includes more **peers**, not parts
+
+---
+
+## 🔦 when to use
+- to **analyze internal structure**
+- to **unpack meaning** without changing abstraction level
+- for **planning**, **diagnosis**, or **curriculum design**
+
+> **Decompose** reveals *what it contains*, not what it is like.

package/dist/logic/roles/bhrain/.briefs/tactic.<think>[idea]/primitive/<zoomin>[depth]<abstractify>[concept].md

@@ -0,0 +1,124 @@
+# 🕳️ .brief: `<zoomin>[depth]<abstractify>[concept]`
+
+## .what
+**`<abstractify>`** moves **inward** toward **more general, inclusive abstractions** — traveling **radially toward the core** of concept space.
+
+It performs a **`focal.depth++`** operation:
+- deepens focus by including **higher-level abstractions**
+- does **not increase neighbor context** (`breadth`) or **attribute granularity** (`acuity`)
+- focuses on **semantic compression** — revealing what the concept **is an instance of**
+
+> Imagine standing on a branch and tracing it inward toward the trunk.
+
+---
+
+## 🧭 direction
+
+This is a **radial inward motion**:
+- from a **relative anchor** concept
+- toward **increasingly abstract** root concepts
+- in the **universal perspective**, this is always inward on the RootStruct
+
+---
+
+## 🎯 .why
+
+Abstraction allows us to:
+- **reduce complexity** in cognition and communication
+- **surface essential structure** and ignore noise
+- **enable reuse**, analogy, comparison, and category formation
+
+---
+
+## 🌱 how it works
+
+`<abstractify>` can operate via two major methods:
+
+### 1. by **reducing attributes**
+Strip away specific features until only a general structure remains.
+
+\\```txt
+"banana" → "elongated edible plant part" → "plant organ" → "thing"
+\\```
+
+### 2. by **comparing and linking neighbors**
+Find common ground among neighboring concepts, and abstract to their shared parent.
+
+#### grammar:
+\\```txt
+[origin:concept] <-> [link:concept] <-> [neighbor:concept]
+\\```
+
+#### neighbor types:
+- **link.included neighbor** → supports abstraction path
+- **link.excluded neighbor** → shows where abstraction fails
+
+#### e.g.
+\\```txt
+"banana" <-> "fruit" <-> "orange"       // included
+"banana" <-> "food" <-> "bread"         // included
+"banana" <-> "thing" <-> "joke"         // excluded
+→ "banana" → "concept"
+\\```
+
+---
+
+## 🎯 examples: `<abstractify>[concept]` in multiple directions
+
+### 🍌 concept: `"banana"`
+- **categorical**: `"banana"` → `"fruit"` → `"food"` → `"item"`
+- **functional**: `"banana"` → `"snack"` → `"meal component"` → `"experience"`
+- **biological**: `"banana"` → `"plant organ"` → `"vegetative structure"` → `"organism part"`
+
+---
+
+### 🧰 concept: `"toolbox"`
+- **categorical**: `"toolbox"` → `"storage container"` → `"object"`
+- **functional**: `"toolbox"` → `"tool organizer"` → `"workflow enabler"` → `"support structure"`
+- **contextual**: `"toolbox"` → `"repair accessory"` → `"worksite object"` → `"task-enabling thing"`
+
+---
+
+### 🔋 concept: `"battery"`
+- **categorical**: `"battery"` → `"electrical component"` → `"device"` → `"object"`
+- **functional**: `"battery"` → `"energy storage"` → `"power medium"` → `"utility function"`
+- **capability**: `"battery"` → `"power source"` → `"resource"` → `"capacity"`
+
+---
+
+### 🧼 concept: `"soap"`
+- **categorical**: `"soap"` → `"cleaning product"` → `"chemical compound"` → `"substance"`
+- **functional**: `"soap"` → `"dirt remover"` → `"hygiene tool"` → `"health facilitator"`
+- **social**: `"soap"` → `"bathroom staple"` → `"cultural hygiene norm"` → `"societal practice"`
+
+---
+
+## 🚫 .not
+
+`<abstractify>` is **not**:
+- **vagueness** — it does not remove detail arbitrarily
+- **ambiguity** — it does not introduce confusion
+- **accidental omission** — abstraction is **intentional and structured**
+
+---
+
+## 🧪 examples: other domains
+
+- **code**:
+  `function add(a, b)` — hides implementation, reveals structural pattern
+- **map**:
+  subway diagram — omits geography, reveals logical connections
+- **language**:
+  `"vehicle"` — abstracts over car, bike, truck, etc.
+- **ethics**:
+  `"justice"` — generalizes across legal frameworks
+
+---
+
+## 🧠 cognitive role
+
+- enables **generalization**, **categorization**, **theory-building**
+- supports **analogy formation** by grouping under shared roots
+- good for **semantic compression**, **vocabulary alignment**, and **domain modeling**
+
+→ Use `<abstractify>` when you want to **understand what a concept is**, and how it connects upward in your mental model.

package/dist/logic/roles/bhrain/.briefs/tactic.<think>[idea]/primitive/<zoomout>[acuity]<blurren>[concept].md

@@ -0,0 +1,56 @@
+# 🎯 .brief: <zoomout>[acuity]<blurren>[concept]
+
+## .what
+`<blurren>` reduces **focal acuity** on a concept — not by abstracting it, but by **tracking fewer internal attributes**.
+
+It is a **zoom-out operation on acuity**:
+you still refer to the **same concept**, but your cognitive lens treats it more **coarsely**, **loosely**, or **holistically**.
+
+---
+
+## 🧠 how it works
+- `focal.acuity--`
+- `focal.depth = const`
+- `focal.breadth = const`
+
+→ **same concept**, lower internal resolution
+→ you attend to **fewer traits**, dimensions, or features
+→ not abstraction — just **fuzzy focus**
+
+---
+
+## 🧪 examples
+
+### 🔨 concept: `"hammer"`
+- sharpened: tracks `handle.material`, `head.weight`, `impact.type`
+- blurred: just “a thing for hitting”
+
+### 🐕 concept: `"dog"`
+- sharpened: tracks `breed`, `size`, `temperament`, `purpose`
+- blurred: just “a dog”
+
+### 🥝 concept: `"kiwi"`
+- sharpened: tracks `flesh.color`, `skin.hairs`, `acidity.level`, `origin.region`
+- blurred: just “a fruit you eat with a spoon”
+
+---
+
+## 📐 metaphor
+- like **softening the focus** of a camera — the object stays, but details are less crisp
+- like glancing at something instead of inspecting it
+
+---
+
+## 🔁 related operations
+- `<zoomin>[acuity]<sharpen>[concept]` → increases trait tracking
+- `<zoomout>[depth]<elaborate>[concept]` → adds more examples or instances
+- `<zoomout>[breadth]` → includes more peers
+
+---
+
+## 🔦 when to use
+- for **quick judgments**, **category tagging**, or **low-effort recall**
+- to reduce detail load in working memory
+- to treat a concept as **symbolic**, **metaphoric**, or **general-purpose**
+
+> **Blurren** simplifies by looking *less closely* — not by generalizing away.