rhachet-roles-ehmpathy 1.1.0 → 1.2.0

package/dist/_topublish/domain-glossary-brief/src/domain/objects/Catalog.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Catalog.js.map

package/dist/_topublish/domain-glossary-brief/src/domain/objects/Catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Catalog.js","sourceRoot":"","sources":["../../../../../../src/_topublish/domain-glossary-brief/src/domain/objects/Catalog.ts"],"names":[],"mappings":""}

package/dist/_topublish/domain-glossary-brief/src/domain/objects/TriageCatalog.d.ts

@@ -0,0 +1,18 @@
+export type TriageTier = 'P0' | 'P1' | 'P2' | 'P3';
+/**
+ * A TriageCatalog is a structured collection of items
+ * organized into discrete priority tiers.
+ *
+ * - `TTier` = the allowed priority labels (e.g. 'P0' | 'P1' | 'P2' | 'P3')
+ * - `TItem` = the type of each catalog entry (e.g. Question)
+ *
+ * Each tier key holds an **ordered list** of items
+ * that share the same level of urgency, leverage, or essentiality.
+ *
+ * This type is typically the **output** of a <triage> operation
+ * applied to a raw catalog, where the catalog is partitioned
+ * into meaningful priority groupings.
+ */
+export type TriageCatalog<TItem, TTier extends string = TriageTier> = {
+    readonly [K in TTier]: readonly TItem[];
+};

package/dist/_topublish/domain-glossary-brief/src/domain/objects/TriageCatalog.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TriageCatalog.js.map

package/dist/_topublish/domain-glossary-brief/src/domain/objects/TriageCatalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TriageCatalog.js","sourceRoot":"","sources":["../../../../../../src/_topublish/domain-glossary-brief/src/domain/objects/TriageCatalog.ts"],"names":[],"mappings":""}

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/Focus.d.ts

@@ -0,0 +1,34 @@
+import { DomainEntity } from 'domain-objects';
+import { Artifact } from 'rhachet-artifact';
+import { GitFile } from 'rhachet-artifact-git';
+/**
+ * .what = a focus that a @[thinker] can adopt
+ * .why =
+ *   - declares a distinct context and concept with which to think
+ *   - enables focus switches, persistence, replication, etc
+ * .ref = @[bhrain].briefs/cognition
+ */
+export interface Focus {
+    /**
+     * .what = the unique identifier of this focus
+     * .why = enables identification of mutable focus
+     */
+    exid: string;
+    /**
+     * .what = ⚓ the anchor concept, represents the position within the semantic treestruct at focus
+     * .why =
+     *   - serves as the point from which the thinker's perspective is based
+     *   - serves as the topic onto which the thinker's imagination is applied
+     */
+    concept: Artifact<typeof GitFile>;
+    /**
+     * .what = 🔦 the visible concepts, represent the positions within the semantic treestruct included for leverage
+     * .why =
+     *   - defines which concepts can be leveraged for manipulation of the focus.concept
+     *   - can be mutated to grow or shrink, along dimensions of .depth, .breadth, and .acuity
+     */
+    context: Artifact<typeof GitFile>;
+}
+export declare class Focus extends DomainEntity<Focus> implements Focus {
+    static unique: readonly ["exid"];
+}

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/Focus.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Focus = void 0;
+const domain_objects_1 = require("domain-objects");
+class Focus extends domain_objects_1.DomainEntity {
+}
+exports.Focus = Focus;
+Focus.unique = ['exid'];
+//# sourceMappingURL=Focus.js.map

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/Focus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Focus.js","sourceRoot":"","sources":["../../../../../../src/_topublish/rhachet-roles-bhrain/src/domain/objects/Focus.ts"],"names":[],"mappings":";;;AAAA,mDAA8C;AAkC9C,MAAa,KAAM,SAAQ,6BAAmB;;AAA9C,sBAEC;AADe,YAAM,GAAG,CAAC,MAAM,CAAU,CAAC"}

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/PonderCatalog.d.ts

@@ -0,0 +1,9 @@
+import { TriageCatalog } from '../../../../domain-glossary-brief/src/domain/objects/TriageCatalog';
+import { Question } from './Question';
+/**
+ * A PonderCatalog stores the triaged questions available for use in a ponder operation
+ */
+export type PonderCatalog = {
+    contextualize: TriageCatalog<Question>;
+    conceptualize: TriageCatalog<Question>;
+};

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/PonderCatalog.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PonderCatalog.js.map

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/PonderCatalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PonderCatalog.js","sourceRoot":"","sources":["../../../../../../src/_topublish/rhachet-roles-bhrain/src/domain/objects/PonderCatalog.ts"],"names":[],"mappings":""}

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/Question.d.ts

@@ -0,0 +1 @@
+export type Question = string;

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/Question.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Question.js.map

package/dist/_topublish/rhachet-roles-bhrain/src/domain/objects/Question.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Question.js","sourceRoot":"","sources":["../../../../../../src/_topublish/rhachet-roles-bhrain/src/domain/objects/Question.ts"],"names":[],"mappings":""}

package/dist/logic/artifact/genStepSwapArtifact.d.ts

@@ -38,7 +38,7 @@ export declare const genStepSwapArtifact: <TThreads extends Threads<any>, TFromS
  *   - streamlines definition of multiple swaps in routes without type repetition
  *
  * @example
- * const swapArt = enthreadGenStepSwapArtifact<StitcherDesired['threads']>();
+ * const swapArt = useGenStepSwapArtifactFor<StitcherDesired['threads']>();
  * swapArt({
  *   // set @thinker[inflight] = @thinker.inflights.diverge
  *   use: { stitchee: 'thinker', artee: 'inflights.diverge' },

package/dist/logic/artifact/genStepSwapArtifact.js

@@ -46,7 +46,7 @@ exports.genStepSwapArtifact = genStepSwapArtifact;
  *   - streamlines definition of multiple swaps in routes without type repetition
  *
  * @example
- * const swapArt = enthreadGenStepSwapArtifact<StitcherDesired['threads']>();
+ * const swapArt = useGenStepSwapArtifactFor<StitcherDesired['threads']>();
  * swapArt({
  *   // set @thinker[inflight] = @thinker.inflights.diverge
  *   use: { stitchee: 'thinker', artee: 'inflights.diverge' },

package/dist/logic/roles/bhrain/.briefs/cognition/cog000.overview.and.premise.md

@@ -0,0 +1,115 @@
+# 🧠 .brief: `cortal.thoughtspace.foundation`
+
+## .what = instantiate
+
+This system instantiates a structured **thoughtspace**, where `focus` operates within a semantic `concept.treestruct` using navigable `motion` primitives.
+
+---
+
+### 1. `concept.treestruct` exists
+
+- a semantic graph of concepts (nodes) and relationships (edges)
+- structured as a **spherical tree**:
+  - **radial axis** → abstraction (general ↔ specific)
+  - **angular axes** → descriptive variation (peers, types, traits)
+- each concept has:
+  - an **abstractive position** (radial)
+  - a **descriptive position** (angular)
+
+---
+
+### 2. `focus` exists within the concept.treestruct
+
+- defines a **perspective** — a relative point-of-view from which thought is applied
+- composed of:
+
+#### ▸ **focus.concept**
+- the specific **concept** from which the perspective is based
+- the anchor for semantic navigation
+- defined by its coordinates within the treestruct
+
+#### ▸ **focus.context**
+- the **shape of attention**, or how the concept is being examined
+- expressed across three internal dimensions:
+
+  - `.depth` → the **thickness of abstractive span** — how far focus reaches:
+    - **inward** along the **radial axis** toward generalizations (`.depth.abstract++`)
+    - **outward** along the **radial axis** toward concrete instances (`.depth.concrete++`)
+    - both may expand **simultaneously**, forming a radial shell of multiple abstraction layers around the focal concept
+
+  - `.breadth` → the **spread across angular variation** — how many neighboring concepts at the same abstraction level are included
+    - defined by motion along one or more **descriptive axes** (e.g. flavor, function, tone)
+    - governs lateral comparisons, analogies, and contrasts
+
+  - `.acuity` → the **sharpness of resolution** at the current coordinate
+    - `.attributes` — surface clarity: how precisely external traits are perceived
+    - `.substructs` — internal clarity: how clearly nested parts or subcomponents are resolved
+
+> context defines how much **radial**, **angular**, and **granular** semantic material is held in focus —
+> like shaping a lens through abstraction, variation, and precision.
+
+
+---
+
+### 3. motion is performed via **questions**, which act as **links**
+
+- motion = semantic traversal through the `concept.treestruct`
+- **questions** serve as the **branches** — the only valid drivers of motion
+- **sumptions** serve as the **berries** — semantic forks where focus can anchor
+
+#### ▸ sumption: the unified node type
+
+A **sumption** is any semantic unit presumed or accepted for any reason — including:
+
+- a **question** → an **executable motion** — a prompt that enables semantic traversal
+- an **answer** → a **destination of a question** — one of the resolved outcomes of semantic traversal
+
+> Any **answer** can itself be **any type of sumption** — including another **question**.
+> This enables **recursive motion**, where questions resolve into deeper prompts,
+> forming chains, trees, or loops of semantic navigation.
+
+note: questions are not separate from the treestruct — they are **subtrees that encode traversability**.
+
+
+#### ▸ structural rule:
+
+| element   | type         | role in treestruct             |
+|-----------|--------------|-------------------------------|
+| **link**  | question     | enables motion (edge)          |
+| **fork**  | sumption     | anchoring concept (node)       |
+|           | ⤷ question   | unresolved fork                |
+|           | ⤷ answer     | resolved fork                  |
+
+> sumptions are **not truth-claims**, but **semantic constructs** that hold position in conceptual space.
+
+---
+
+### 4. exists `focus.motion.primitives`
+
+- atomic, directional transformations of `focus.context`
+- each:
+  - operates on a **single subaxis**
+  - is **irreducible**, **driftless**, and **composable**
+- examples:
+  - `<generalize>` → `.depth.abstract++`
+    *shift focus inward toward a more abstract concept*
+  - `<articulate>` → `.acuity.attributes++`
+    *sharpen surface details of the current concept*
+  - `<decompose>` → `.acuity.substructs++`
+    *resolve the internal structure or components*
+  - `<vary>` → `.breadth++`
+    *highlight peer-level differences between variants*
+  - etc
+
+
+---
+
+### 5. exists `interogative.primitives`
+
+- atomic building blocks of semantic inquiry
+- used to construct **question-links** between concepts
+- examples:
+  - `what` → identify instances or roles
+  - `why` → surface cause or rationale
+  - `how` → reveal process or transformation
+  - `when`, `who`, `where` → context-based locators

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.coordinates.spherical.md

@@ -0,0 +1,69 @@
+# 🌐 .brief: `spherical.coordinates`
+
+## .what
+**Spherical coordinates** define a point in 3D space using three parameters relative to a central origin:
+- **distance from the origin**,
+- **vertical angle from the z-axis**, and
+- **horizontal angle around the z-axis**.
+
+This system generalizes polar coordinates into 3D, enabling orientation in radial and angular terms.
+
+---
+
+## 🧭 dimensions
+
+| axis           | symbol | description                                                                 |
+|----------------|--------|-----------------------------------------------------------------------------|
+| **radial**     | `r`    | distance from the origin to the point                                       |
+| **inclination** (polar angle) | `θ`    | angle from the positive z-axis toward the point (0 to π)               |
+| **azimuth** (azimuthal angle) | `φ`    | angle from the positive x-axis in the x-y plane (0 to 2π)              |
+
+> Note: symbols may differ by domain — in mathematics, `θ` often denotes azimuth and `φ` inclination.
+
+---
+
+## 🌀 usage
+
+- Converts naturally to **Cartesian coordinates**:
+  \```txt
+  x = r · sin(θ) · cos(φ)
+  y = r · sin(θ) · sin(φ)
+  z = r · cos(θ)
+  \```
+
+- Used in:
+  - physics (e.g. fields around a point source)
+  - computer graphics (e.g. camera rotation)
+  - astronomy and navigation
+  - geographic models of Earth
+
+---
+
+## 🌍 real-world example: Earth coordinates
+
+Take **New York City**:
+
+| Earth Coordinate | Value         | Spherical Equivalent                 |
+|------------------|---------------|--------------------------------------|
+| **Latitude**     | 40.7128° N     | Inclination `θ` = 90° − 40.7128° = **49.2872°** |
+| **Longitude**    | 74.0060° W     | Azimuth `φ` = −74.0060° = **285.994°** |
+| **Radius**       | ~6,371 km      | Radial distance `r` from Earth's center |
+
+> So:
+> **(r, θ, φ) = (6371 km, 49.29°, 285.99°)**
+
+This demonstrates how geographic coordinates are a **spherical coordinate system** on the Earth's surface — assuming a constant radius.
+
+---
+
+## 🏗️ structure
+
+This system implies a **radial core** with **angular shells**, where:
+
+- `r` defines the **radial distance** from center
+- `θ` defines **elevation** from the pole (vertical tilt)
+- `φ` defines **rotation** around the equator (horizontal sweep)
+
+Together, these describe a point on a **spherical shell** at radius `r`.
+
+---

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.metaphor.cauliflorous.md

@@ -0,0 +1,44 @@
+# 🌸 .brief: `cauliflorous.plants`
+
+## .what
+**Cauliflorous plants** are species that produce **flowers and fruits directly from their main stem, trunk, or older branches**, rather than at the tips of new growth.
+
+> This unusual trait is known as **cauliflory** and is most commonly found in tropical species.
+
+---
+
+## 🌐 ecological function
+
+Cauliflory supports unique plant-animal interactions by:
+
+- **Enabling access** to flowers and fruits for **ground-dwelling pollinators and dispersers**
+  (e.g., rodents, bats, flightless birds)
+- **Reducing vertical competition** by flowering and fruiting below the canopy
+- **Improving pollination success** in shaded or dense environments
+
+---
+
+## 🌱 notable examples
+
+| plant                     | use / region                      |
+|---------------------------|----------------------------------|
+| *Theobroma cacao*         | cacao (chocolate), South America |
+| *Artocarpus heterophyllus* | jackfruit, Southeast Asia         |
+| *Durio spp.*              | durian, Southeast Asia           |
+| *Plinia cauliflora*       | jaboticaba, Brazil               |
+
+---
+
+## 🧬 botanical mechanism
+
+- Flowers develop from **dormant buds** embedded in older, woody tissue.
+- Often associated with **woody perennials** in **humid tropics**.
+
+---
+
+## .why it matters
+
+Cauliflory illustrates how plant morphology can evolve to match **ecological niches** —
+especially where typical pollinators or dispersers are **not airborne**.
+
+It also inspires biomimetic designs for **low-access harvesting**, **layered ecosystems**, and **ground-level productivity**.

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.structs.catalog.md

@@ -0,0 +1,51 @@
+# 🗂️ .brief: `catalog`
+
+## .what
+A **catalog** is a **structured concept collection**, where each item is
+paired with **descriptive information** to support **recognition**, **selection**, or **retrieval**.
+
+It serves as a **semantic surface** over a deeper collection —
+organized for **browsing**, **filtering**, and **comparative reasoning**.
+
+While an **inventory** tracks availability or logistics,
+a catalog emphasizes **clarity, presentation, and user-centered discovery**.
+
+---
+
+## 🧭 key traits
+
+| trait             | meaning                                                                 |
+|-------------------|-------------------------------------------------------------------------|
+| **enumerated**     | each concept is explicitly listed, not abstracted away                 |
+| **descriptive**    | highlights distinguishing features (e.g. label, image, type, metadata) |
+| **browsable**      | optimized for lateral focus and scanning across entries                |
+| **non-exhaustive** | curated based on salience, criteria, or constraints                    |
+| **ordered**        | often sorted semantically or pragmatically (e.g. relevance, recency)   |
+
+---
+
+## 🧩 comparison
+
+| structure    | emphasizes                 | typical use                        |
+|--------------|----------------------------|------------------------------------|
+| `index`      | position or reference       | lookup or navigation               |
+| `inventory`  | quantity and availability   | logistics, restocking, tracking    |
+| `catalog`    | structure and presentation  | curation, exploration, shopping    |
+
+---
+
+## 📦 examples
+
+- a **product catalog** listing items by type, brand, and price
+- a **library catalog** with subject tags, authors, and summaries
+- a **course catalog** organizing classes with time, credits, and prerequisites
+
+---
+
+## 🧠 role in semantic systems
+
+In a `concept.treestruct`, a catalog acts as a **flattened radial slice**
+at a given `focal.depth` — exposing **breadth peers** for comparison or selection.
+
+It is often used in tandem with primitives like `<compare>`, `<cluster>`, or `<instantiate>`
+to surface patterns or choose options from a structured field.

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.structs.vector.md

@@ -0,0 +1,112 @@
+# 🧭 .brief: `physics.vector`
+
+## .what
+A **physics vector** is a mathematical object used to represent **quantities that have both magnitude and direction** in physical space.
+It also functions as a **data structure** — encoding directionally relevant information for computation, simulation, and modeling.
+
+---
+
+## 🧩 structure
+
+A vector is defined by:
+
+- **magnitude** → the scalar size of the quantity
+- **direction** → the orientation in space
+- **components** → projections along basis axes (e.g. `x`, `y`, `z`)
+  - written as `v = ⟨vx, vy, vz⟩` or `v = vx î + vy ĵ + vz k̂`
+
+---
+
+## 🧠 examples of vector quantities
+
+| quantity         | description                                 |
+|------------------|---------------------------------------------|
+| **velocity**     | speed + direction of motion                 |
+| **acceleration** | rate of change of velocity (directional)    |
+| **force**        | push or pull with a direction               |
+| **momentum**     | mass × velocity                             |
+| **electric field** | directional force on a unit charge        |
+
+---
+
+## 🔧 operations on vectors
+
+| operation             | meaning                                             |
+|------------------------|-----------------------------------------------------|
+| **addition**          | combine vectors tip-to-tail                         |
+| **subtraction**       | find relative vector between two                   |
+| **scalar multiplication** | scales magnitude, keeps direction            |
+| **dot product**       | projects one vector onto another (returns scalar)   |
+| **cross product**     | finds perpendicular vector (returns vector)         |
+
+---
+
+## 📐 geometric interpretation
+
+Vectors live in a **Euclidean space** (ℝ², ℝ³) and can be visualized as **arrows**:
+
+- **length** of arrow = magnitude
+- **angle** = direction relative to axes
+- operations map to geometric rules (e.g. triangle or parallelogram rule)
+
+---
+
+## 🧮 as a data structure
+
+In computational systems, a vector is a **structured container of values**, optimized for directional computation:
+
+| property           | value                                      |
+|--------------------|--------------------------------------------|
+| **type**           | `Vector` or `Array<number>`                |
+| **arity**          | dimensionality (e.g. 2D, 3D, nD)            |
+| **shape**          | fixed-length tuple of scalars              |
+| **indexing**       | ordered (e.g. `[0] = x`, `[1] = y`)        |
+| **mutability**     | may be mutable (runtime), or immutable     |
+
+Vectors are frequently implemented as:
+
+\`\`\`ts
+type Vector3 = [number, number, number]
+\`\`\`
+
+or with named accessors:
+
+\`\`\`ts
+interface Vector3 {
+  x: number
+  y: number
+  z: number
+}
+\`\`\`
+
+This enables:
+
+- direct algebraic operations (`add`, `dot`, `normalize`, etc.)
+- efficient storage (especially in graphics, physics engines)
+- compatibility with matrix operations and coordinate transforms
+
+---
+
+## ⚠️ important distinctions
+
+- Vectors ≠ scalars — direction matters
+- Coordinate representation is **basis-relative**
+- The vector itself is **basis-invariant**
+
+---
+
+## 🧬 advanced notes
+
+- In relativity: vectors generalize to **4-vectors** (e.g. spacetime)
+- In field theory: **vector fields** assign a vector to each point in space
+- In curved space: vectors live in **tangent spaces** and obey **manifold** rules
+- In graphics and physics engines: vectors are core data primitives — enabling transforms, simulations, and animations
+
+---
+
+## 🧰 summary: dual perspective
+
+| perspective     | usage                                  |
+|------------------|------------------------------------------|
+| **physical**     | represents real-world directional quantity |
+| **computational**| structured data enabling math operations  |

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.coords.1.spherical.md

@@ -0,0 +1,80 @@
+# 🌳 .brief: `concept.treestruct.spherical`
+
+## .why
+use this brief if you want to...
+
+- **understand how abstraction works** in a concept `TreeStruct`, in terms of generality and specificity
+
+- **navigate or manipulate concepts radially** — moving inward toward abstractions or outward toward instances
+
+- **distinguish between different kinds of abstraction**, such as categorical vs functional vs modal
+
+- **identify the semantic axis** a concept belongs to (e.g., “fruit” is a categorical abstraction)
+
+- **structure your knowledge hierarchically** by tracing how concepts generalize along meaningful dimensions
+
+- **design tools or prompts** that rely on structured abstraction (e.g., AI reasoning, taxonomy design, teaching models)
+
+
+## .what
+The `concept.treestruct` models conceptual space using a **spherical coordinate system**, where each concept has both:
+
+- a **radial position** *(aka "abstractive position")*: how abstract or concrete it is
+- an **angular position** *(aka "descriptive position")*: how it varies descriptively from its peers
+
+This structure allows concepts to be organized by both **hierarchical abstraction** and **semantic variation**, enabling multidirectional traversal.
+
+---
+
+## 🧭 dimensions
+
+| spherical axis     | treestruct role                | alias                    | description                                           |
+|--------------------|--------------------------------|--------------------------|-------------------------------------------------------|
+| **radius** `r`     | abstractive hierarchy          | **abstractive position** | inward = more abstract/core<br>outward = more concrete/detail |
+| **inclination** `θ`| categorical differentiation    | **descriptive position** | vertical angular shifts between categories or frames  |
+| **azimuth** `φ`    | sibling/instance differentiation | **descriptive position** | horizontal angular shifts between analogs or variants |
+
+> The angular dimensions (`θ`, `φ`) are both descriptive: they define where the concept sits relative to peers at the same level of abstraction.
+
+---
+
+## 🪜 radial motion: abstraction
+
+Radial motion moves through layers of **conceptual generality**:
+
+- **inward**: toward more universal, abstract ideas
+- **outward**: toward more specific, detailed instances
+
+This defines the **core structure** of the tree — from root abstractions to concrete applications.
+
+---
+
+## 🔀 angular motion: variation
+
+Angular motion explores **alternative expressions** at the same abstractive level:
+
+- **vertical tilt** (`θ`) shifts across **types or categories**
+- **horizontal rotation** (`φ`) shifts across **peer instances or analogies**
+
+These motions describe **semantic diversity**, not hierarchy.
+
+---
+
+## 🌐 structural implications
+
+- The treestruct forms **layers of abstraction** (radial) populated by **rings of descriptive diversity** (angular)
+- Concepts can be:
+  - **grouped** by angular proximity (descriptive similarity)
+  - **traced** by radial lineage (abstractive derivation)
+
+---
+
+## 🌀 navigation
+
+- to **generalize** → move **inward** (more abstract)
+- to **specialize** → move **outward** (more concrete)
+- to **reframe**, **contrast**, or **analogize** → rotate **angularly**
+
+This enables precise, multidimensional navigation of meaning.
+
+---