rhachet-roles-ehmpathy 1.1.0 → 1.2.0

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.1.from_instances.[demo].algorithm.md

@@ -0,0 +1,54 @@
+# 🧩 .brief.demo: `brief archetypes via algorithm`
+
+## .what
+the same set of **instances** (🔢 sorting a list, 🗺️ shortest-path on a map, 📐 euclid’s gcd) can be compressed into different **brief archetypes**.
+this demo shows how the concept of an **algorithm** is materialized differently depending on the treatment: definitional, organizational, relational, or pedagogical.
+
+---
+
+## 📖 brief.article — definitional
+**treatment:** clarify *what an algorithm is*
+**content:**
+- defines an algorithm as a **finite, effective procedure** that transforms inputs to outputs via well-specified steps
+- relates with sorting a list (input→ordered output) and navigating a shortest path (start→goal)
+- explains key properties: correctness, termination, complexity, and determinism/probabilism
+
+---
+
+## 🗂️ brief.catalog — organizational
+**treatment:** map *how algorithms vary*
+**content:**
+- **paradigms:** divide-and-conquer, dynamic programming, greedy, backtracking
+- **guarantees:** exact vs approximate; deterministic vs randomized
+- **models/costs:** time vs space complexity; online vs offline
+- relates these facets as dimensions for classifying algorithms
+
+---
+
+## 🎬 brief.demo — relational
+**treatment:** show *how one instance exemplifies the concept*
+**content:**
+- takes **euclid’s algorithm** for gcd(a, b) as the focal instance
+- relates the step rule `gcd(a, b) = gcd(b, a mod b)` until `b = 0` → output `a`
+- bridges concreteness (repeated remainder) to general qualities: termination, correctness proof, complexity `O(log min(a,b))`
+
+---
+
+## 🎓 brief.lesson — pedagogical
+**treatment:** guide *how to learn algorithms step by step*
+**content:**
+1. start with a recipe-like task (sort 5 numbers by hand) and write the steps
+2. trace pseudocode for selection sort; count comparisons/swaps
+3. compare with merge sort; discuss divide-and-conquer idea
+4. apply to a pathfinding task (sketch dijkstra on a tiny graph)
+- relates concrete traces to abstractions (invariants, correctness, big-O)
+
+---
+
+## ✨ insight
+- 📖 **article** defines the essence (finite, effective, specified steps)
+- 🗂️ **catalog** organizes paradigms, guarantees, and cost models
+- 🎬 **demo** exemplifies via a single concrete algorithm (euclid)
+- 🎓 **lesson** teaches the craft through tracing, proofs, and analysis
+
+this demo shows how **algorithms**—though formal and abstract—are materialized through brief archetypes, each relating shared instances in a distinct way.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.1.from_instances.[demo].color.md

@@ -0,0 +1,56 @@
+# 🧩 .brief.demo: `brief archetypes via color`
+
+## .what
+the same **instances** (🌈 prism spectrum, 📱 rgb display, 🎨 paint mixing, 👗 “the dress” illusion) can be compressed into different **brief archetypes**.
+this demo shows how **color** is materialized differently depending on the treatment: definitional, organizational, relational, or pedagogical.
+
+---
+
+## 📖 brief.article — definitional
+**treatment:** clarify *what color is*
+**content:**
+- defines color as a **perceptual attribute** arising from a stimulus’s spectral power distribution **as interpreted by the human visual system** (cone responses and opponent channels)
+- relates with additive light mixing (rgb on a display) vs subtractive pigment mixing (cmyk/paint) and notes **color constancy** (perceived color stabilizes across lighting)
+
+---
+
+## 🗂️ brief.catalog — organizational
+**treatment:** map *how color varies*
+**content:**
+- **physical:** wavelength/spectrum, illuminant, reflectance
+- **physiological:** l/m/s cones; opponent axes (red↔green, blue↔yellow)
+- **psychophysical:** hue, saturation/chroma, lightness/value
+- **representational:** rgb, cmyk, cie xyY / lab / lch; device gamut
+- **contextual phenomena:** constancy, adaptation, metamerism, simultaneous contrast
+- relates these lenses as complementary slices of one concept
+
+---
+
+## 🎬 brief.demo — relational
+**treatment:** show *how one instance exemplifies color*
+**content:**
+- takes **“the dress”** photo as the focal instance
+- relates how **assumed illuminant** (cool shadow vs warm spotlight) shifts perceived white balance, yielding **blue/black** vs **white/gold**
+- bridges to color constancy and the role of priors/context in perception
+
+---
+
+## 🎓 brief.lesson — pedagogical
+**treatment:** guide *how to learn color step by step*
+**content:**
+1. view a phone screen through a macro lens to see **rgb subpixels** (additive mixing)
+2. mix **cyan, magenta, yellow** paints to feel subtractive interactions
+3. compare two lights that look the **same color** but have **different spectra** (metamers)
+4. try a checker-shadow or gray-bar illusion to feel **context effects**
+5. plot a few samples in **cie lab** to connect perception to coordinates
+- relates hands-on activities to the principles of spectrum → cones → appearance → color spaces
+
+---
+
+## ✨ insight
+- 📖 **article** defines
+- 🗂️ **catalog** organizes
+- 🎬 **demo** exemplifies
+- 🎓 **lesson** teaches
+
+one concept, **color**, becomes graspable through different brief treatments, each relating shared instances in a distinct way.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.1.from_instances.[demo].empathy.md

@@ -0,0 +1,54 @@
+# 🧩 .brief.demo: `brief archetypes via empathy`
+
+## .what
+the same set of **instances** (🔹 comforting a friend, 🏥 a nurse attending a patient, 🤝 a manager listening to an employee) can be compressed into different **brief archetypes**.
+this demo shows how the concept of **empathy** is materialized differently depending on the treatment: definitional, organizational, relational, or pedagogical.
+
+---
+
+## 📖 brief.article — definitional
+**treatment:** clarify *what empathy is*
+**content:**
+- defines empathy as the capacity to understand and share another’s feelings
+- relates with the instance of a friend comforting another in distress
+- explains its role in emotional intelligence and social connection
+
+---
+
+## 🗂️ brief.catalog — organizational
+**treatment:** map *how empathy manifests across cases*
+**content:**
+- **cognitive empathy** → recognizing another’s perspective (manager listening to employee)
+- **emotional empathy** → sharing another’s feeling (friend comforting friend)
+- **compassionate empathy** → acting to alleviate suffering (nurse caring for patient)
+- relates these forms as variations of one overarching concept
+
+---
+
+## 🎬 brief.demo — relational
+**treatment:** show *how one instance exemplifies empathy*
+**content:**
+- takes the nurse attending to a patient as the focal instance
+- relates this act of attentive care to the broader concept of empathy
+- bridges the concrete act with the general principle of responding to another’s suffering
+
+---
+
+## 🎓 brief.lesson — pedagogical
+**treatment:** guide *how to learn empathy step by step*
+**content:**
+1. observe someone in emotional discomfort (instance: friend in distress)
+2. practice perspective-taking (imagine how they feel)
+3. respond verbally or physically to validate their feelings (comfort them)
+4. reflect on the impact of your action (did it help them feel understood?)
+- relates specific practices to the abstract principle of empathy
+
+---
+
+## ✨ insight
+- 📖 **article** defines empathy
+- 🗂️ **catalog** organizes types of empathy
+- 🎬 **demo** exemplifies empathy through a concrete case
+- 🎓 **lesson** teaches empathy as a learnable skill
+
+this demo shows how a single human concept, **empathy**, can be materialized through different brief archetypes, each relating the same set of instances in a distinct way.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.1.from_instances.[demo].entropy.md

@@ -0,0 +1,54 @@
+# 🧩 .brief.demo: `brief archetypes via entropy`
+
+## .what
+the same set of **instances** (🧊 ice melting, 🃏 shuffling a deck, 🗜️ lossless data compression limits) can be compressed into different **brief archetypes**.
+this demo shows how the concept of **entropy** is materialized differently depending on the treatment: definitional, organizational, relational, or pedagogical.
+
+---
+
+## 📖 brief.article — definitional
+**treatment:** clarify *what entropy is*
+**content:**
+- defines entropy as a measure of multiplicity/disorder (thermo) or uncertainty/information (info theory)
+- relates with ice melting (more microstates) and shuffled cards (higher uncertainty)
+- explains why entropy tends to increase in closed systems and how it bounds compression
+
+---
+
+## 🗂️ brief.catalog — organizational
+**treatment:** map *how entropy manifests across cases*
+**content:**
+- **thermodynamic entropy** → energy dispersal, phase change (ice → water)
+- **statistical entropy** → microstate counts, shuffled deck outcomes
+- **information entropy** → average surprise, compression limits
+- relates the three as views of “states + probabilities” under different lenses
+
+---
+
+## 🎬 brief.demo — relational
+**treatment:** show *how one instance exemplifies entropy*
+**content:**
+- takes shuffling a new deck of cards as the focal instance
+- relates the move from a highly ordered state to one with vastly more possible arrangements
+- bridges this to uncertainty (info theory) and to the likelihood of higher-entropy states (stat mech)
+
+---
+
+## 🎓 brief.lesson — pedagogical
+**treatment:** guide *how to learn entropy step by step*
+**content:**
+1. start with coin flips to feel uncertainty (1 flip vs 10 flips)
+2. compare ordered vs shuffled decks (counting possibilities)
+3. observe ice warming/melting (energy dispersal)
+4. connect to compression: truly random data resists shrinking
+- relates concrete activities to the abstract principle “more possible states → higher entropy”
+
+---
+
+## ✨ insight
+- 📖 **article** defines entropy across domains
+- 🗂️ **catalog** organizes thermodynamic, statistical, and information views
+- 🎬 **demo** exemplifies entropy via a single concrete case
+- 🎓 **lesson** teaches entropy through progressive activities
+
+this demo shows how cross-domain **entropy** can be materialized through brief archetypes, each relating the same instances in a distinct way.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.1.from_instances.[demo].gravity.md

@@ -0,0 +1,54 @@
+# 🧩 .brief.demo: `brief archetypes` via `gravity`
+
+## .what
+the same set of **instances** (🔹 falling apple, 🌙 moon’s orbit, 🌊 ocean tides) can be compressed into different **brief archetypes**.
+each archetype demonstrates the concept of **gravity** through a distinct treatment: definitional, organizational, relational, or pedagogical.
+
+---
+
+## 📖 brief.article — definitional
+**treatment:** clarify *what gravity is*
+**content:**
+- defines gravity as the universal attraction between masses
+- relates with the apple falling and the moon orbiting
+- explains its significance for physics and daily life
+
+---
+
+## 🗂️ brief.catalog — organizational
+**treatment:** map *how gravity manifests across cases*
+**content:**
+- terrestrial gravity (apple falling, objects pulled to Earth)
+- celestial gravity (moon orbit, planetary motion)
+- tidal gravity (ocean tides pulled by the moon)
+- relates these diverse phenomena under one principle
+
+---
+
+## 🎬 brief.demo — relational
+**treatment:** show *how one instance exemplifies gravity*
+**content:**
+- takes the falling apple as the focal instance
+- relates it to the same force governing planetary orbits
+- bridges the link between a simple case and a universal concept
+
+---
+
+## 🎓 brief.lesson — pedagogical
+**treatment:** guide *how to learn gravity step by step*
+**content:**
+1. observe a dropped apple (instance of falling objects)
+2. compare to the moon’s orbit (celestial instance)
+3. connect both to Newton’s principle of universal gravitation
+4. practice with examples (why we stay grounded, why tides shift)
+- relates concrete cases to the abstract principle
+
+---
+
+## ✨ insight
+- 📖 **article** defines
+- 🗂️ **catalog** organizes
+- 🎬 **demo** exemplifies
+- 🎓 **lesson** teaches
+
+all four compress instances into different treatments — each **relating gravity** in a way tailored to definition, organization, exemplification, or pedagogy.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.1.from_instances.[demo].joke.md

@@ -0,0 +1,56 @@
+# 🧩 .brief.demo: `brief archetypes via joke`
+
+## .what
+the same **instances** (😂 a knock-knock pun, 🙃 an anti-joke with no punchline, 🎤 a stand-up routine, 🤡 a slapstick gag) can be compressed into different **brief archetypes**.
+this demo shows how the concept of a **joke** is materialized differently depending on the treatment: definitional, organizational, relational, or pedagogical.
+
+---
+
+## 📖 brief.article — definitional
+**treatment:** clarify *what a joke is*
+**content:**
+- defines a joke as a **short narrative, phrase, or act designed to elicit humor**, often by subverting expectation
+- relates with the form of a pun (wordplay that flips meaning) and slapstick (physical incongruity)
+- explains how jokes rely on **setup → punchline**, timing, and audience context
+
+---
+
+## 🗂️ brief.catalog — organizational
+**treatment:** map *how jokes vary*
+**content:**
+- **verbal jokes** → puns, one-liners, riddles
+- **narrative jokes** → anecdotes, shaggy-dog stories
+- **performative jokes** → slapstick, stand-up, pranks
+- **meta-jokes** → anti-jokes, self-referential humor
+- relates these forms as variations on incongruity, timing, and audience expectation
+
+---
+
+## 🎬 brief.demo — relational
+**treatment:** show *how one instance exemplifies a joke*
+**content:**
+- takes a **knock-knock pun** as the focal instance
+- relates how it sets up a predictable pattern, then subverts it with wordplay in the punchline
+- bridges the simple case to the general principle: humor often arises from expectation + violation
+
+---
+
+## 🎓 brief.lesson — pedagogical
+**treatment:** guide *how to learn jokes step by step*
+**content:**
+1. observe a simple riddle with an expected answer
+2. replace the expected answer with a surprising one → feel the shift
+3. practice with puns (homophones, double meanings)
+4. try delivering timing-based humor (pause before punchline)
+5. reflect on audience response to refine delivery
+- relates stepwise practice to the general principle of setup, timing, and incongruity
+
+---
+
+## ✨ insight
+- 📖 **article** defines joke
+- 🗂️ **catalog** organizes joke types
+- 🎬 **demo** exemplifies joke via a single pun
+- 🎓 **lesson** teaches joke-telling as a learnable skill
+
+this demo shows how the everyday concept of a **joke** can be materialized through brief archetypes, each relating shared instances in a distinct way.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.1.from_instances.[demo].value.md

@@ -0,0 +1,54 @@
+# 🧩 .brief.demo: `brief archetypes via value`
+
+## .what
+the same set of **instances** (💵 a product’s price tag, ❤️ choosing family over work, ⚖️ a debate on justice) can be compressed into different **brief archetypes**.
+this demo shows how the concept of **value** is materialized differently depending on the treatment: definitional, organizational, relational, or pedagogical.
+
+---
+
+## 📖 brief.article — definitional
+**treatment:** clarify *what value is*
+**content:**
+- defines value as the measure of worth or importance attributed to something
+- relates with the instances of a price tag on goods and the prioritization of relationships
+- explains how value operates across economic, ethical, and personal domains
+
+---
+
+## 🗂️ brief.catalog — organizational
+**treatment:** map *how value manifests across cases*
+**content:**
+- **economic value** → exchange worth (price of a good)
+- **moral value** → ethical priority (justice, fairness)
+- **personal value** → subjective importance (family, love, passion)
+- relates these as distinct yet overlapping forms of the concept of value
+
+---
+
+## 🎬 brief.demo — relational
+**treatment:** show *how one instance exemplifies value*
+**content:**
+- takes the example of choosing family over work
+- relates this decision to the broader concept of personal value
+- bridges the specific case to the general principle that humans assign worth beyond money
+
+---
+
+## 🎓 brief.lesson — pedagogical
+**treatment:** guide *how to learn value step by step*
+**content:**
+1. examine a product’s price as an instance of economic value
+2. compare it with moral debates (justice vs expedience)
+3. reflect on personal decisions (time with loved ones vs career ambition)
+4. connect these examples to the general principle that “value” is the attribution of worth across domains
+- relates concrete experiences to the abstract principle of value
+
+---
+
+## ✨ insight
+- 📖 **article** defines value as worth
+- 🗂️ **catalog** organizes its types
+- 🎬 **demo** exemplifies value in a single case
+- 🎓 **lesson** teaches value as a learnable, multi-domain concept
+
+this demo shows how a contested and multifaceted concept like **value** can still be materialized through brief archetypes, each relating the same set of instances in a distinct way.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.2._.[catalog].md

@@ -0,0 +1,43 @@
+# 🧩 .brief.catalog: `mechanisms of document instantiation`
+
+## .what
+each document archetype (📖 article, 🗂️ catalog, 🎬 demo, 🎓 lesson) corresponds to a **mechanism** that materializes a concept in that form.
+this catalog organizes the four mechanisms — **articulate, catalogize, demonstrate, lessonize** — showing how they function in parallel.
+
+---
+
+## 📖 articulate → articles (definitional treatment)
+- **mechanism:** materializes a concept *as* an article
+- **function:** defines the concept, sets boundaries, clarifies meaning
+- **example:** articulating “symmetry” by defining invariance under transformations and relating with butterfly wings, squares, and musical phrases
+
+---
+
+## 🗂️ catalogize → catalogs (organizational treatment)
+- **mechanism:** materializes a concept *as* a catalog
+- **function:** organizes instances into groups, categories, or dimensions
+- **example:** catalogizing “memory” into short-term vs long-term, then declarative vs procedural
+
+---
+
+## 🎬 demonstrate → demos (relational treatment)
+- **mechanism:** materializes a concept *as* a demo
+- **function:** shows how an instance exemplifies the concept, bridging abstract and concrete
+- **example:** demonstrating “walkability” by relating the city of Portland’s sidewalks, mixed-use zoning, and transit integration to the broader concept
+
+---
+
+## 🎓 lessonize → lessons (pedagogical treatment)
+- **mechanism:** materializes a concept *as* a lesson
+- **function:** builds a scaffolded progression of steps and practices for learning
+- **example:** lessonizing “gravity” into a sequence: dropping an apple → comparing orbits → stating Newton’s law → practicing with tides
+
+---
+
+## ✨ insight
+- 📖 **articulate** defines concepts
+- 🗂️ **catalogize** organizes concepts
+- 🎬 **demonstrate** exemplifies concepts
+- 🎓 **lessonize** teaches concepts
+
+together, these mechanisms form the **system of document instantiation**: four complementary ways to materialize concepts by arranging instances into communicable form.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.2.articulate.[article].md

@@ -0,0 +1,27 @@
+# 🧩 .brief.article: `articulate`
+
+## .what
+**articulate** is the mechanism that **instantiates articles**: it materializes a concept as a definitional treatment that clarifies *what it is*.
+
+---
+
+## 🔬 definition
+- **mechanism:** the materialization of a concept *as* article form.
+- **function:** provides definition, boundary-setting, and explanation so the concept becomes clear and communicable.
+- **distinction:** articulation describes *what an article is*; articulating performs the *instantiation* of an article.
+
+---
+
+## 📌 examples
+- to articulate “symmetry,” one defines it as **invariance under transformation**, relating with instances like butterfly wings and geometric rotations.
+- to articulate “leadership,” one defines it as **the capacity to influence and coordinate others**, relating with instances like historical figures or everyday group dynamics.
+- to articulate “entropy,” one defines it as **a measure of multiplicity/uncertainty**, relating with ice melting or shuffled cards.
+
+---
+
+## ✨ insight
+**articulate** is the bridge between **concept and definition**:
+- it is the **mechanism** of clarifying meaning and boundaries.
+- it ensures that articles are not anecdotes but **systematic materializations** of conceptual definition.
+
+in knowledge architecture, **articulate** sits alongside mechanisms like **catalogize** (catalogs), **demonstrate** (demos), and **lessonize** (lessons), each materializing concepts in a distinct document mode.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.2.articulate.[lesson].md

@@ -0,0 +1,49 @@
+# 🧩 .brief.lesson: `how to articulate an article`
+
+## .what
+an **article** is a document that gives a **definitional treatment** of a concept: it clarifies *what the concept is*, often by setting boundaries, tracing meaning, and relating to representative instances.
+this lesson shows step by step how to **articulate an article** effectively.
+
+---
+
+## 🎓 steps
+
+1. **identify the concept**
+   - choose the subject of articulation (e.g., “symmetry”)
+   - state it clearly in one sentence as the anchor
+
+2. **define the essence**
+   - provide a concise definition: *what it is at its core*
+   - ensure the definition distinguishes the concept from related ones
+
+3. **relate with instances**
+   - select 1–3 representative cases that make the definition tangible
+   - show how each instance fits the boundaries of the concept
+
+4. **contextualize**
+   - situate the concept in a larger frame: its domain, contrasts, or history
+   - explain why the concept matters or how it functions in practice
+
+5. **compress into structure**
+   - arrange into a few short, well-ordered paragraphs
+   - ensure clarity, minimal noise, maximum signal
+
+---
+
+## 📌 example: articulate an article on “symmetry”
+
+- **definition:** symmetry is a structural property where an object remains invariant under a transformation (e.g., reflection, rotation).
+- **instances:** butterfly wings (reflection), square (rotation), musical phrase (repetition).
+- **context:** symmetry is central in mathematics, physics, and aesthetics; it reveals order and regularity in systems.
+- **compression:** three paragraphs, moving from definition → examples → significance.
+
+---
+
+## ✨ insight
+to articulate an article:
+- start with a **clear definition**
+- **relate with key instances** to ground it
+- **situate in context** for meaning
+- **compress** into structured paragraphs for clarity
+
+this sequence ensures the article functions as a **definitional treatment** that makes the concept graspable and transmissible.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.2.catalogize.[article].md

@@ -0,0 +1,27 @@
+# 🧩 .brief.article: `catalogize`
+
+## .what
+**catalogize** is the mechanism that **instantiates catalogs**: it materializes a concept as an organizational treatment that maps how its instances or sub-concepts relate within a system.
+
+---
+
+## 🔬 definition
+- **mechanism:** the materialization of a concept *as* catalog form.
+- **function:** organizes instances into clusters, categories, or hierarchies to reveal structure and variation.
+- **distinction:** articulation describes *what a catalog is*; catalogizing performs the *instantiation* of a catalog.
+
+---
+
+## 📌 examples
+- to catalogize “memory,” one groups instances into **short-term vs. long-term**, then subdivides into **declarative vs. procedural**.
+- to catalogize “color,” one organizes by **hue, saturation, brightness** or by **additive vs. subtractive models**.
+- to catalogize “jokes,” one maps types like **puns, anecdotes, slapstick, anti-jokes**.
+
+---
+
+## ✨ insight
+**catalogize** is the bridge between **concept and structure**:
+- it is the **mechanism** of arranging instances to make a system visible.
+- it ensures that catalogs are not random lists but **systematic materializations** of conceptual organization.
+
+in knowledge architecture, **catalogize** sits alongside mechanisms like **articulate** (articles), **demonstrate** (demos), and **lessonize** (lessons), each materializing concepts in a distinct document mode.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.2.catalogize.[lesson].md

@@ -0,0 +1,54 @@
+# 🧩 .brief.lesson: `how to catalogize a catalog`
+
+## .what
+a **catalog** is a document that gives an **organizational treatment** of a concept: it maps *how instances or sub-concepts relate* within a system.
+this lesson shows step by step how to **catalogize a catalog** — i.e., how to instantiate a catalog so its structure clearly materializes the concept.
+
+---
+
+## 🎓 steps
+
+1. **identify the scope**
+   - choose the domain of organization (e.g., “types of memory”)
+   - define boundaries: what belongs in the catalog, what doesn’t
+
+2. **collect instances**
+   - gather relevant cases or sub-concepts
+   - ensure diversity, so the catalog reflects breadth
+
+3. **group by principle**
+   - decide the organizing logic (taxonomy, dimensions, categories, functions)
+   - examples: short-term vs long-term memory; declarative vs procedural
+
+4. **name and order clusters**
+   - assign clear labels to each group
+   - order them logically (hierarchy, chronology, continuum, network)
+
+5. **compress into structure**
+   - write each group with a short description
+   - present the whole as a coherent, navigable map
+
+---
+
+## 📌 example: catalogize a catalog of “memory”
+
+- **scope:** human memory
+- **instances:** remembering a phone number, recalling facts, knowing how to ride a bike
+- **groups:**
+  - **short-term memory** → holding a phone number briefly
+  - **long-term memory** → stored knowledge and skills
+     - **declarative** (facts/events)
+     - **procedural** (skills/habits)
+- **compression:** sections for each cluster, presented hierarchically
+
+---
+
+## ✨ insight
+to catalogize a catalog:
+- **scope** defines what’s included
+- **instances** supply the raw material
+- **grouping principles** shape the structure
+- **labels + order** make it navigable
+- **compression** ensures clarity
+
+a catalog succeeds when it reveals the **systematic structure** of a concept, turning scattered instances into an organized map.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.2.demonstrate.[article].md

@@ -0,0 +1,26 @@
+# 🧩 .brief.article: `demonstrate`
+
+## .what
+**demonstrate** is the mechanism that **instantiates demos**: it materializes a concept as a relational treatment that shows how an instance exemplifies that concept.
+
+---
+
+## 🔬 definition
+- **mechanism:** the materialization of a concept *as* demo form.
+- **function:** reveals the concept through a chosen instance, making the abstract visible and graspable.
+- **distinction:** articulation describes *what a demo is*; demonstrating performs the *instantiation* of a demo.
+
+---
+
+## 📌 examples
+- to demonstrate “walkability,” one presents Portland as the focal instance, relating its sidewalks, mixed-use layout, and transit integration to the broader concept.
+- to demonstrate “empathy,” one spotlights a nurse comforting a patient, relating this specific act of care to the general principle of understanding and sharing another’s feelings.
+
+---
+
+## ✨ insight
+**demonstrate** is the bridge between **concept and exemplar**:
+- it is the **mechanism** of showing concepts *in action* through instances.
+- it ensures that demos are not just anecdotes but **systematic materializations** of concept–instance relations.
+
+in knowledge architecture, **demonstrate** sits alongside mechanisms like **articulate** (articles), **catalogize** (catalogs), and **lessonize** (lessons), each materializing concepts in a distinct document mode.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.enbrief.2.demonstrate.[lesson].md

@@ -0,0 +1,49 @@
+# 🧩 .brief.lesson: `how to demonstrate a demo`
+
+## .what
+a **demo** is a document that gives a **relational treatment** of a concept: it shows *how an instance exemplifies a concept*.
+this lesson explains how to **demonstrate a demo** — i.e., how to instantiate a demo so the connection between instance and concept is maximally clear.
+
+---
+
+## 🎓 steps
+
+1. **select the concept**
+   - identify the abstraction you want to materialize (e.g., “resilience”).
+
+2. **choose a focal instance**
+   - pick a concrete, vivid case (e.g., a tree bending in strong wind).
+   - ensure it is representative enough to reveal the concept.
+
+3. **frame the relation**
+   - state directly how the instance demonstrates the concept.
+   - highlight the relational link (instance → concept).
+
+4. **situate in context**
+   - explain why this instance is a strong example.
+   - connect to broader relevance (domain, application, meaning).
+
+5. **compress articulation**
+   - keep it concise: usually 2–3 paragraphs.
+   - remove noise, emphasize clarity of the instance–concept link.
+
+---
+
+## 📌 example: demonstrating a demo of “resilience”
+
+- **concept:** resilience
+- **instance:** a tree bending in strong wind
+- **relation:** the bending tree demonstrates resilience by showing flexibility under force without breaking.
+- **context:** this everyday natural instance captures the broader human/social concept of adapting to stress.
+- **compression:** two short paragraphs clearly tying instance → concept.
+
+---
+
+## ✨ insight
+to demonstrate a demo:
+- pick a **clear instance**
+- articulate its **relation to the concept**
+- situate it in **context**
+- keep the link **compressed and clear**
+
+a demo succeeds when the audience can see the **abstract concept made visible** through a single, well-chosen instance.