rhachet-roles-ehmpathy 1.13.1 → 1.13.3

package/dist/logic/roles/bhrain/.briefs/cognition/cog251.cortal.focus.p3.usecases.md

@@ -0,0 +1,76 @@
+# 🧰 .brief: `cortal.focus.usecases`
+
+## .what
+
+This brief catalogs **usecases for thinking explicitly about focus**
+— when it's helpful to become aware of `focus.context`, `focus.concept`, and their configuration.
+
+These are moments where **meta-focus** enables stronger reasoning, clarity, or problem-solving.
+
+> To use focus well is to **see clearly**, **ask precisely**, and **move intentionally** through complex ideas.
+
+---
+
+## 🧠 why think about focus?
+
+Most reasoning happens *with* focus but not *about* it.
+
+> But in moments of friction, ambiguity, or overload —
+> explicitly managing your focus can transform how you think.
+
+Thinking about focus helps you:
+
+- **reset direction** (when stuck or scattered)
+- **reframe problems** (by rotating context or anchor)
+- **improve question quality** (via sharper configuration)
+- **accelerate insight** (by tuning depth, breadth, acuity)
+
+---
+
+## 📘 key usecases
+
+| usecase                  | what you do                                       | why it matters                                                |
+|--------------------------|----------------------------------------------------|----------------------------------------------------------------|
+| **🧠 gather your focus**      | align context and concept intentionally          | prepares you to ask precise, meaningful questions               |
+| **🪞 reflect on your focus**  | notice what you're holding + how                 | builds meta-cognition; reveals hidden assumptions or noise      |
+| **🧵 trace a focus drift**    | identify where your attention slipped            | helps recover lost clarity or intent                            |
+| **📐 compress your focus**   | distill many ideas into one articulable node     | boosts communicability and insight                              |
+| **🎯 aim your focus**        | pick a better anchor concept                     | sharpens the entry point of exploration                         |
+| **🔀 reframe your focus**    | shift interpretive context                       | enables new understandings or alternate paths                   |
+| **🚪 unblock with focus**    | realize a question is stuck due to bad focus     | unlocks better questions and next moves                         |
+| **🌀 overload triage**       | manage breadth/depth/acuity tradeoffs            | prevents overwhelm or blur                                      |
+
+---
+
+## 🧠 example: compress your focus
+
+You’ve just gathered a wide set of notes across multiple concepts.
+They feel loosely related, but disorganized.
+
+By **articulating** the shared traits and **generalizing** an abstraction,
+you compress the mess into a **new focal concept**.
+
+```txt
+"These are all ways people avoid decisions"
+→ articulate
+→ [concept: decision avoidance]
+```
+
+
+> Compression is how focus becomes **portable**, **nameable**, and **sharable**.
+
+---
+
+## 🔁 when to think about focus
+
+- when you're **lost** → “what am I even trying to do?”
+- when you're **stuck** → “why can’t I ask a better question?”
+- when you're **drowning** → “too much info, no handle”
+- when you're **scattered** → “my thoughts are all over the place”
+- when you're **teaching** → “what should the learner focus on?”
+- when you're **designing prompts** → “how should this be framed?”
+
+---
+
+> **Focus is a cognitive interface**
+> Thinking explicitly about it gives you control over how you traverse concept space.

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives._.md

@@ -0,0 +1,155 @@
+# 🧱 .brief: `focus.motion.primitives`
+
+## .what
+
+**focus motion primitives** are the atomic units of conceptual motion — each performs a **pure**, **irreducible**, and **driftless** motion along a **single subaxis** of `cortal.focus`.
+
+they enable precise navigation of concepts for thought with clarity and control.
+
+---
+
+## 🧭 properties of a focus motion primitive
+
+| trait              | requirement                                           |
+|--------------------|-------------------------------------------------------|
+| **single subaxis** | modifies exactly one `.focus.[axis].[subaxis]`        |
+| **driftless**      | causes no collateral movement on other subaxes        |
+| **irreducible**    | cannot be broken into simpler focus operations        |
+| **composable**     | may be chained into composite or strategic sequences  |
+| **reversible**     | usually has a well-defined semantic inverse           |
+
+---
+
+## 🔹 catalog of primitives
+
+### `focal.acuity`
+
+acuity has two **distinct subaxes**:
+- `.attributes` → surface qualities and traits
+- `.substructs` → internal components or parts
+
+| primitive        | subaxis           | motion             | description                                     |
+|------------------|--------------------|---------------------|------------------------------------------------|
+| `<articulate>`    | `.attributes++`    | enrich description  | surface observable traits or qualities          |
+| `<compress>`      | `.attributes--`    | reduce description  | flatten or simplify descriptive richness        |
+| `<decompose>`     | `.substructs++`    | reveal parts        | expose internal structure or components         |
+| `<encompose>`     | `.substructs--`    | encapsulate         | bind parts into a coherent structural whole     |
+
+> 🧠 acuity often **varies per node** —
+> some concepts remain blurry while others are semantically sharp.
+
+---
+
+### `focal.depth`
+
+| primitive         | subaxis           | motion             | description                                     |
+|-------------------|--------------------|---------------------|-------------------------------------------------|
+| `<generalize>`     | `.abstract++`      | inward (coreward)   | move to a broader, more inclusive abstraction   |
+| `<instantiate>`    | `.concrete++`      | outward (leafward)  | specify a concrete form, example, or case       |
+
+> 🧭 `focal.depth` primitives move strictly **radially** through semantic space:
+> - `.abstract++` ≡ `.concrete--`
+> - `.concrete++` ≡ `.abstract--`
+
+> this changes **how general or specific** the concept is,
+> but **not which semantic axis** it belongs to.
+
+> 🧩 abstraction may follow distinct semantic **dimensions** —
+> see [catalog of abstraction dimensions](#) for examples (e.g. categorical, functional, causal, potential, emotional, etc.)
+
+> 🪞 meta insight:
+> every `focal.breadth` axis becomes accessible **only after** instantiating into a particular depth shell.
+> → breadth variation happens **within** a given layer of depth.
+
+---
+
+### `focal.breadth`
+
+breadth primitives operate **angularly**, sweeping across lateral variation
+while remaining anchored within the current `focal.depth` shell.
+
+| primitive      | subaxis              | motion                       | description                                         |
+|----------------|-----------------------|-------------------------------|-----------------------------------------------------|
+| `<shift>`       | `.breadth.[axis]++`   | lateral peer change           | switch to nearby alternative along same subaxis     |
+| `<rotate>`      | `.breadth.axis→axis`  | axis reorientation            | shift to a different descriptive axis               |
+| `<invert>`      | `.breadth.axis±180°`  | polarity reversal             | flip to the semantic opposite along same axis       |
+
+---
+
+#### descriptive subaxes
+
+| subaxis         | variation domain                 | example                           |
+|------------------|----------------------------------|-----------------------------------|
+| `categorical`     | type/kind variation              | `"dog"` → `"cat"`                 |
+| `temporal`        | time/stage variation             | `"child"` → `"adult"`             |
+| `functional`      | purpose/behavior                 | `"email"` → `"letter"`            |
+| `emotional`       | affective tone                   | `"curiosity"` → `"fear"`          |
+| `spatial`         | physical or perceptual location  | `"indoors"` → `"outdoors"`        |
+| `subjective`      | role or POV framing              | `"observer"` → `"actor"`          |
+
+> 💡 this list is **illustrative**, not exhaustive —
+> domain-specific systems may define additional semantic axes.
+
+---
+
+## 🔁 reversibility pairs
+
+| primitive       | inverse         | subaxis        | effect                                  |
+|------------------|------------------|------------------|-------------------------------------------|
+| `<decompose>`     | `<encompose>`     | `.substructs`     | expose structure ←→ encapsulate           |
+| `<articulate>`    | `<compress>`      | `.attributes`     | enrich traits ←→ flatten traits           |
+| `<generalize>`    | `<instantiate>`   | `.depth`          | abstract ←→ specify                       |
+| `<invert>`        | `<invert>`        | `.breadth.axis`   | polarity flip ←→ polarity flip            |
+| `<rotate>`        | `<rotate>`        | `.breadth.axis`   | axis A → B ←→ B → A (semantic symmetry)   |
+
+---
+
+## 🧬 classification of motion variants
+
+| kind            | example             | motion profile                          | composite? |
+|-----------------|---------------------|------------------------------------------|------------|
+| **primitive**   | `<compress>`        | `.attributes--`                          | ❌ no      |
+| **composite**   | `<elaborate>`       | `.breadth++` + `.acuity++`               | ✅ yes     |
+| **structural**  | `<zoomout><$x>`     | framework wrapper for composite behavior | ✅ yes     |
+| **strategic**   | `<diagnose>`        | dynamic chaining of tailored composites  | ✅ yes     |
+
+---
+
+## 📐 compositional constraint
+
+\`\`\`
+focal.depth × focal.acuity² ∝ focal.breadth²
+\`\`\`
+
+> you can't go **deep, sharp, and wide** all at once.
+> primitives help you deliberately balance:
+> - `focal.depth` → abstraction layer
+> - `focal.acuity` → resolution/sharpness
+> - `focal.breadth` → descriptive variation
+
+---
+
+## 🪞 metaphor glossary
+
+| primitive        | metaphor                               |
+|------------------|----------------------------------------|
+| `<articulate>`    | reveal the surface texture            |
+| `<compress>`      | smooth out descriptive detail         |
+| `<decompose>`     | crack open the inner workings         |
+| `<encompose>`     | wrap into a unified whole             |
+| `<generalize>`    | collapse coreward into a broader idea |
+| `<instantiate>`   | unfold edgeward into a specific case  |
+| `<shift>`         | step sideways within a dimension      |
+| `<rotate>`        | spin the axis dial                    |
+| `<invert>`        | flip the concept’s polarity           |
+
+---
+
+## 🧱 design usage
+
+- **compose** custom semantic operations using primitive chains
+- **trace** tree-of-thought or weave logs using precise subaxis tags
+- **constrain** reasoning systems to driftless, isolable operations
+- **diagnose** or debug motion paths via their reversible steps
+
+> 💡 focus motion primitives are the **assembly language** of structured thought.

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.acuity.md

@@ -0,0 +1,94 @@
+# 🎯 .brief: `focus.motion.acuity`
+
+## .what
+
+`focal.acuity` motion controls how **finely detailed** your mental frame becomes —
+zooming in to surface nuanced traits, or zooming out to smooth and compress them.
+
+it governs the **resolution** of the concept in focus — whether you're
+seeing just the headline, or peering into the full texture of attributes and substructure.
+
+---
+
+## 🧭 properties
+
+| trait                  | value                                           |
+|------------------------|-------------------------------------------------|
+| **axis type**          | scalar — sharpens or softens a fixed concept    |
+| **subaxes**            | `.attributes`, `.substructs`                    |
+| **anchor**             | concept remains constant                        |
+| **motion direction**   | inward (sharpen), outward (blur)                |
+| **effect**             | affects how much detail is cognitively present  |
+| **breadth unlocked**   | sharper acuity reveals more variation options   |
+
+---
+
+## 🔹 primitives
+
+| primitive        | subaxis           | motion             | description                                     |
+|------------------|--------------------|---------------------|------------------------------------------------|
+| `<articulate>`    | `.attributes++`    | enrich description  | surface observable traits or qualities          |
+| `<compress>`      | `.attributes--`    | reduce description  | flatten or simplify descriptive richness        |
+| `<decompose>`     | `.substructs++`    | reveal parts        | expose internal structure or components         |
+| `<encompose>`     | `.substructs--`    | encapsulate         | bind a structured whole as a single coherent form |
+
+> 🧠 attribute motion focuses on **surface features**,
+> while substruct motion reveals or hides **internal components**.
+
+---
+
+## 🧩 comparison
+
+| mode            | motion            | cognitive effect                               | metaphor                    |
+|------------------|--------------------|--------------------------------------------------|------------------------------|
+| `articulate`     | `.attributes++`    | zoom in to enrich with qualities               | sharpen the image            |
+| `compress`       | `.attributes--`    | zoom out to simplify or abstract traits        | blur out the details         |
+| `decompose`      | `.substructs++`    | zoom in to reveal internal parts               | open the casing              |
+| `encompose`      | `.substructs--`    | zoom out to treat as a single unit             | wrap it up                   |
+
+---
+
+## 🪞 metaphor
+
+> acuity is like turning the **focus dial** of a camera lens —
+> high acuity reveals textures, facets, and joints;
+> low acuity leaves you with silhouettes or simplified shapes.
+
+---
+
+## 🧪 examples
+
+\`\`\`ts
+// articulate attributes
+concept = [banana]
+articulate → [curved], [yellow], [edible], [tropical]
+
+// compress description
+compress → [fruit], [sweet thing]
+
+// decompose structure
+concept = [email]
+decompose → [header], [body], [footer]
+
+// encompose back
+encompose([header, body, footer]) → [email]
+\`\`\`
+
+---
+
+## 💡 interaction with breadth and depth
+
+- high acuity enables **variation** along more breadth axes (more traits revealed)
+- low acuity hides those options (smoother shell)
+- some **depth motions** require prior decomposition to be meaningful
+
+> e.g. you can’t vary the `"head"` of an `"email"` if you haven’t decomposed it first.
+
+---
+
+## 🎯 use when you want to:
+
+- control **how much detail** you’re actively considering
+- expose or abstract **inner parts** of a concept
+- simplify mental load by compressing attributes
+- prepare for operations like variation, substitution, or explanation

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.breadth.md

@@ -0,0 +1,114 @@
+# 🧱 .brief: `focus.motion.primitives.breadth`
+
+## .what
+
+These are the **atomic breadth motions** — irreducible, driftless focus shifts
+that operate **angularly** within a constant `focal.depth` shell.
+
+Each primitive traverses **descriptive subaxes** of the current depth shell
+without modifying abstraction level, focal anchor, or acuity.
+
+> 🧠 they explore **variation across** peers, not **abstraction beyond** them
+> — motion is angular, not radial.
+
+---
+
+## 🧭 properties
+
+| trait              | requirement                                                |
+|--------------------|------------------------------------------------------------|
+| **angular only**   | no radial depth shift — shell remains constant             |
+| **single subaxis** | operates on one `.breadth.[axis]` at a time                |
+| **driftless**      | causes no collateral effect on depth or acuity             |
+| **irreducible**    | cannot be decomposed into smaller semantic motions         |
+| **anchor-locked**  | focal anchor remains constant throughout                   |
+| **reversible**     | typically has an inverse (e.g., invert polarity)           |
+
+---
+
+## 🔹 primitive: `<vary>`
+
+This is the **core atomic motion** across breadth:
+It **selects a lateral peer** of the anchor concept along a descriptive subaxis.
+
+\`\`\`ts
+<vary.axis++> // shift to neighbor at same depth, along .breadth.axis
+\`\`\`
+
+- requires an **explicit subaxis** (e.g., categorical, temporal, emotional)
+- never modifies `focal.depth` or the anchor itself
+- reversible by repeating or stepping back
+
+---
+
+### 🔸 subtypes of `<vary>`
+
+| subtype     | behavior                                      | motion type              | example                                        |
+|-------------|-----------------------------------------------|---------------------------|------------------------------------------------|
+| `<shift>`    | lateral peer switch on same subaxis           | `.breadth.axis++`         | `"apple"` → `"pear"` (categorical)             |
+| `<rotate>`   | reorient focus to a **different subaxis**     | `.breadth.axis → alt.axis`| `"car"` (function) → `"car"` (temporal)        |
+| `<invert>`   | polarity flip along the current subaxis       | `.breadth.axis±180°`      | `"honesty"` → `"deceit"` (moral)               |
+
+> 🧠 `<invert>` is an **extreme variation** — jumping to the opposite end of a trait spectrum.
+
+---
+
+## 🧪 examples
+
+\`\`\`ts
+// categorical → temporal
+concept = [banana]
+breadth.categorical++ → [mango], [apple]
+rotate → breadth.temporal++ → [green banana], [ripe banana]
+
+// functional → temporal
+concept = [car]
+breadth.functional++ → [sedan], [SUV], [truck]
+rotate → breadth.temporal++ → [vintage car], [modern car]
+
+// material → affective
+concept = [shirt]
+breadth.material++ → [cotton], [wool], [polyester]
+rotate → breadth.affective++ → [comfortable shirt], [itchy shirt]
+
+// categorical → spatial
+concept = [music]
+breadth.categorical++ → [jazz], [rock], [classical]
+rotate → breadth.spatial++ → [live music], [studio recording]
+
+// invert (temperature)
+concept = [hot coffee] → [iced coffee]
+
+// invert (lighting)
+concept = [daylight] → [nighttime]
+
+// invert (motion)
+concept = [open door] → [closed door]
+\`\`\`
+
+---
+
+## 🚫 not primitives
+
+The following are **composite maneuvers**, not atomic motions:
+
+- `<compare>` → combines `<vary>`, `<articulate>`, `<cluster>`, `<generalize>`
+- `<extend>` → chains breadth + analogy + depth shift
+- `<gather>` → aggregates concepts via memory, not lateral motion
+
+---
+
+## 🪞 metaphor
+
+> breadth primitives are like **spinning in place on the dome**
+> of your semantic depth shell — viewing the anchor concept
+> through different **semantic windows**, not zooming in or out.
+
+---
+
+## 🎯 use when you want to:
+
+- explore **alternative forms** or roles of a concept
+- **contrast peers** without leaving abstraction layer
+- **rotate interpretive frames** across semantic axes
+- perform **clean lateral variation** in structured thought

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.breadth.vary.md

@@ -0,0 +1,105 @@
+# 🌀 .brief: `focus.motion.vary`
+
+## .what
+`<vary>` is a **breadth primitive** that explores **semantic alternatives**
+by shifting focus **laterally** across a single **descriptive axis**
+within the shell of the current `focal.depth`.
+
+it reveals **contrast**, **alternatives**, and **variation**
+without abstracting inward or instantiating outward —
+it stays entirely within the current abstraction layer,
+but sweeps across one **semantic subaxis** (e.g. color, time, function).
+
+---
+
+## 🧭 traits
+
+| trait              | value                                             |
+|--------------------|---------------------------------------------------|
+| **axis**           | `focal.breadth.[subaxis]`                         |
+| **depth shift**    | ❌ none — operates within shell produced by depth |
+| **acuity needed**  | optional — depends on trait detail                |
+| **anchor shift**   | ❌ — anchor remains fixed                         |
+| **motion type**    | atomic primitive                                  |
+| **composable**     | ✅ may chain to yield comparison or contrast       |
+
+---
+
+## 🔹 primitive subtypes of `<vary>`
+
+| subtype        | behavior                                              | example                                      |
+|----------------|--------------------------------------------------------|----------------------------------------------|
+| `<rotate>`      | switch to adjacent semantic subaxis                   | vary by time instead of function              |
+| `<invert>`      | jump to polar opposite along current axis             | `"love"` → `"hate"` (valence axis)           |
+
+> 🔁 note: `<extend>` is **not** a primitive — it chains variation + analogy + depth shift
+
+---
+## 🧪 examples
+
+---
+
+### 🔄 `<rotate>` — semantic axis change
+
+`<rotate>` shifts focus **laterally** within the **same focal.depth shell**
+by switching to a **different semantic subaxis** — revealing a new frame
+of variation without changing the level of abstraction.
+
+\`\`\`ts
+// categorical → temporal
+concept = [banana]
+breadth.categorical++ → [mango], [apple]
+rotate → breadth.temporal++ → [green banana], [ripe banana]
+
+// functional → temporal
+concept = [car]
+breadth.functional++ → [sedan], [SUV], [truck]
+rotate → breadth.temporal++ → [vintage car], [modern car]
+
+// material → affective
+concept = [shirt]
+breadth.material++ → [cotton], [wool], [polyester]
+rotate → breadth.affective++ → [comfortable shirt], [itchy shirt]
+
+// categorical → spatial
+concept = [music]
+breadth.categorical++ → [jazz], [rock], [classical]
+rotate → breadth.spatial++ → [live music], [studio recording]
+\`\`\`
+
+> reorients focus to a **new descriptive axis** — like turning a kaleidoscope
+> to view the same core through a different semantic lens.
+
+---
+
+### 🔄 `<invert>` — polarity reversal
+
+`<invert>` performs a **reversal** along a single semantic axis —
+flipping a concept to its **opposite pole** while remaining
+in the same depth layer and under the same descriptive axis.
+
+\`\`\`ts
+// temperature axis
+concept = [hot coffee] → [iced coffee]
+
+// lighting axis
+concept = [daylight] → [nighttime]
+
+// motion axis
+concept = [open door] → [closed door]
+
+// power axis
+concept = [lamp on] → [lamp off]
+\`\`\`
+
+> reveals **conceptual contrast** by jumping across a polarity line —
+> the same trait, inverted in meaning, function, or state.
+
+---
+
+## 🎯 use when you want to:
+
+- uncover peers along a single descriptive axis
+- inspect interpretive alternatives
+- reveal polarity or contrasting lenses
+- prime a comparison, contrast, or reframing maneuver

package/dist/logic/roles/bhrain/.briefs/cognition/cog301.traversal.1.motion.primitives.depth.md

@@ -0,0 +1,132 @@
+# 🌊 .brief: `focus.motion.depth`
+
+## .what
+
+`focal.depth` motion describes **radial traversal** through a semantic `concept.treestruct`,
+shifting **inward** toward abstraction or **outward** toward instantiation.
+
+it governs how **general or specific** your current frame of focus is —
+zooming along the axis of **inclusion vs. expression**, **type vs. example**,
+**concept vs. case**.
+
+---
+
+## 🧭 properties
+
+| trait                  | value                                           |
+|------------------------|-------------------------------------------------|
+| **axis type**          | radial — moves coreward or leafward            |
+| **subaxes**            | `.abstract`, `.concrete`                        |
+| **anchor**             | the focal concept changes across layers        |
+| **motion direction**   | inward (generalize), outward (instantiate)     |
+| **depth shell**        | determines the available `.breadth` space      |
+| **structure required** | must exist within a hierarchical concept tree  |
+
+---
+
+## 🔹 primitives
+
+| primitive         | motion               | description                                      |
+|-------------------|----------------------|--------------------------------------------------|
+| `<generalize>`     | `.abstract++`        | move inward to a more general abstraction        |
+| `<instantiate>`    | `.concrete++`        | move outward to a more specific form or example  |
+
+> 🔁 radial motion is **reversible** — generalizing back from a case,
+> or instantiating downward from a type.
+
+---
+
+## 🧭 directional reasoning flows
+
+`focal.depth` motion underlies two major forms of structured thought:
+
+| direction       | alias names               | description                                                        | common use cases                               |
+|------------------|----------------------------|----------------------------------------------------------------------|------------------------------------------------|
+| **core → out**   | `coreout`, `top-down`      | instantiate from abstract structure toward concrete examples         | design, deduction, system planning             |
+| **edge → in**    | `edgein`, `bottom-up`      | generalize from concrete instances toward underlying abstraction     | synthesis, analysis, theory-building           |
+
+> 💡 these flows may cycle in reasoning loops:
+> coreout to explore consequences, edgein to revise structure.
+
+---
+
+## 🧩 catalog of abstraction dimensions
+
+radial motion can follow different **abstractive axes**,
+each governing a distinct kind of generalization logic.
+
+this catalog defines **example paths** for common abstraction types:
+
+| abstractive axis | abstraction path                          | generalizes by...         |
+|------------------|--------------------------------------------|---------------------------|
+| **categorical**  | `"banana"` → `"fruit"` → `"plant"`         | kind or type              |
+| **functional**   | `"spoon"` → `"utensil"` → `"tool"`         | purpose or behavior       |
+| **potential**    | `"can walk"` → `"mobility"` → `"agency"`   | ability or constraint     |
+| **causal**       | `"match"` → `"ignition"` → `"fire source"` | influence or mechanism    |
+| **emotional**    | `"fear"` → `"negative affect"` → `"alert"` | affective tone            |
+| **ontological**  | `"emotion"` → `"neural event"` → `"process"` | being or substance       |
+| **logical**      | `"even number"` → `"divisible by 2"` → `"numeric property"` | provable structure |
+
+> 🧠 each axis defines a **directional context** for `<generalize>` or `<instantiate>` —
+> all share the same radial geometry, but vary in **semantic framing**.
+
+---
+
+## 🪞 metaphor
+
+> depth motion is like **zooming through layers of meaning** —
+> from wide organizing categories (roots),
+> down into rich, detailed examples (leaves).
+
+- `<generalize>` = zoom coreward toward the **core pattern**
+- `<instantiate>` = zoom edgeward toward a **surface case**
+
+---
+
+## 🧪 examples
+
+\`\`\`ts
+// categorical
+concept = [banana]
+generalize → [fruit] → [plant]
+instantiate → [ripe banana], [green banana]
+
+// functional
+concept = [email]
+generalize → [communication tool] → [information utility]
+instantiate → [newsletter email], [password reset email]
+
+// causal
+concept = [spark]
+generalize → [ignition] → [fire mechanism]
+instantiate → [spark from lighter], [spark plug]
+
+// potential
+concept = [can walk]
+generalize → [mobility]
+instantiate → [walk across street], [walk with limp]
+\`\`\`
+
+---
+
+## 💡 interaction with breadth
+
+> `focal.depth` determines the **shell** you're in.
+> within that shell, `focal.breadth` defines your **angle of variation**.
+
+\`\`\`ts
+// depth determines shell
+concept = [fruit]       // abstraction shell
+instantiate → [banana]  // outer shell
+    ↳ vary (breadth.categorical++) → [mango], [apple]
+\`\`\`
+
+---
+
+## 🎯 use when you want to:
+
+- change **how general or specific** the concept in focus is
+- zoom in to inspect real-world instances
+- zoom out to find higher-order patterns
+- choose an abstraction path that matches your reasoning need
+- reason top-down (`coreout`) or bottom-up (`edgein`) through structure