rhachet-roles-ehmpathy 1.13.6 → 1.13.7

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.

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

@@ -0,0 +1,26 @@
+# 🧩 .brief.article: `lessonize`
+
+## .what
+**lessonize** is the mechanism that **instantiates lessons**: it materializes a concept as a structured pedagogical treatment that guides learning.
+
+---
+
+## 🔬 definition
+- **mechanism:** the materialization of a concept into lesson form.
+- **function:** provides a scaffolded sequence of steps, examples, and practices so the learner can internalize the concept.
+- **distinction:** articulation describes *what a lesson is*; lessonizing performs the *instantiation* of a lesson.
+
+---
+
+## 📌 examples
+- to lessonize “gravity,” one designs a sequence moving from dropping an apple → comparing planetary orbits → explaining Newton’s law → practicing with tidal predictions.
+- to lessonize “empathy,” one builds a progression from observing a friend’s feelings → practicing perspective-taking → responding → reflecting on the effect.
+
+---
+
+## ✨ insight
+**lessonize** is the bridge between concept and pedagogy:
+- it is the **mechanism** of turning raw content into structured learning.
+- it ensures that lessons are not improvised but **instantiated systematically**.
+
+in knowledge architecture, lessonize sits alongside other mechanisms (e.g., *articulate, catalogize, demonstrate*) as a specific process for **pedagogical materialization**.

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

@@ -0,0 +1,54 @@
+# 🧩 .brief.lesson: `how to lessonize a lesson`
+
+## .what
+a **lesson** is a document that gives a **pedagogical treatment** of a concept: it guides *how the concept is learned and practiced* through structured progression.
+this lesson explains how to **lessonize a lesson** — i.e., how to instantiate a lesson so it effectively scaffolds understanding.
+
+---
+
+## 🎓 steps
+
+1. **define the learning goal**
+   - specify what the learner should understand or be able to do at the end.
+   - e.g., “learn how photosynthesis works.”
+
+2. **choose core instances**
+   - gather examples or cases that ground the concept.
+   - ensure variety: simple → complex, familiar → abstract.
+
+3. **sequence the progression**
+   - order steps to move from known → new, concrete → abstract.
+   - each step should build on the previous one.
+
+4. **embed practice and reflection**
+   - include questions, exercises, or thought experiments.
+   - encourage learners to test and reinforce understanding.
+
+5. **compress into a clear arc**
+   - keep the lesson a few paragraphs or steps, not sprawling.
+   - highlight transitions between steps so the flow is obvious.
+
+---
+
+## 📌 example: lessonizing a lesson on “photosynthesis”
+
+- **goal:** understand how plants convert sunlight into energy.
+- **instances:** observing a leaf, recalling oxygen release, examining energy diagrams.
+- **sequence:**
+  1. start with observation of leaves and sunlight.
+  2. explain chlorophyll capturing light.
+  3. show the chemical reaction (CO₂ + H₂O → glucose + O₂).
+  4. connect to everyday significance (oxygen supply, food chain).
+- **practice:** sketch the process or explain it in simple terms to a peer.
+
+---
+
+## ✨ insight
+to lessonize a lesson:
+- set a **clear goal**
+- select **grounding instances**
+- create a **progression** that builds understanding
+- add **practice and reflection**
+- keep the arc **compressed but complete**
+
+a lesson succeeds when it transforms **instances into a structured pathway**, enabling the learner to grasp and retain the concept.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.kernelize._.[article].md

@@ -0,0 +1,58 @@
+# 🧩 .brief.article: `<kernelize>`
+
+## .what
+**<kernelize>** is the mechanism that extracts 🌱 **doc.kernels** from any 📚 **doc**.
+it reduces unstructured or expansive material into **atomic expressions**, each carrying **one concept**.
+where a 📚 doc may hold many tangled ideas, <kernelize> isolates them into minimal, portable seeds.
+
+---
+
+## 🎯 purpose
+- **distill**: strip away noise, phrasing, and redundancy
+- **separate**: untangle multiple ideas into discrete units
+- **stabilize**: preserve the integrity of each concept in its minimal viable form
+- **prepare**: create fertile, portable kernels for use in 🔖 refs, 🪴 briefs, or new 📚 docs
+
+---
+
+## ⚙️ properties
+- **one concept only** — every kernel carries exactly one concept
+- **atomic** — irreducible without breaking the idea
+- **fertile** — can grow into larger articulations (briefs, essays, treatises)
+- **portable** — reusable across different contexts and documents
+
+---
+
+## 📌 examples
+
+### ⚖️ gravity
+source doc: *“the reason the apple falls is because earth pulls on it with a force — and in fact, any two masses in the universe attract each other.”*
+kernels extracted:
+- 🌱 `earth pulls on the apple`
+- 🌱 `any two masses attract each other`
+
+---
+
+### 🎵 music
+source doc: *“music happens when sounds are arranged in rhythm and melody, and harmony is what gives it depth.”*
+kernels extracted:
+- 🌱 `organized sound creates aesthetic experience`
+- 🌱 `rhythm and melody distinguish music from noise`
+- 🌱 `harmony creates depth in music`
+
+---
+
+### 🧩 triangle
+source doc: *“a triangle is a polygon with three sides, three angles, and the sum of its angles is 180°.”*
+kernels extracted:
+- 🌱 `a triangle has three sides`
+- 🌱 `a triangle has three angles`
+- 🌱 `the sum of a triangle’s angles is 180°`
+
+---
+
+## ✨ insight
+- 📚 docs contain many concepts, often entangled.
+- **<kernelize>** untangles and harvests them into 🌱 kernels.
+- kernels are the **minimal carriers of meaning** — richer than 🔖 refs, smaller than 🪴 briefs.
+- they are the foundation of concept portability, indexing, and recomposition across the document ecosystem.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno301.doc.kernelize._.[lesson].md

@@ -0,0 +1,88 @@
+# 🧩 .brief.lesson: `how to <kernelize>`
+
+## 💡 concept
+**<kernelize>** is the practice of extracting 🌱 **doc.kernels** — the atomic, fertile units of concepts — from any 📚 **doc**.
+most docs contain **many concepts**, often mixed together.
+the goal of <kernelize> is to harvest **each concept individually** in its minimal viable form.
+
+---
+
+## 🎯 learning goals
+- recognize that a single doc typically contains **multiple concepts**
+- practice isolating and extracting **one kernel per concept**
+- compare kernels to 🔖 refs (pointers) and 🪴 briefs (structured articulations)
+
+---
+
+## 🛠️ method
+
+### step 1: scan for concepts
+- read through the 📚 doc (transcript, notes, essay, article).
+- underline every sentence or clause that carries a **distinct idea**.
+
+---
+
+### step 2: isolate each idea
+- separate intertwined sentences into discrete conceptual units.
+- treat each idea as a candidate for its own kernel.
+
+---
+
+### step 3: reduce to the irreducible
+- rewrite each idea in its **shortest viable form**.
+- test: *if I cut further, does the concept break?*
+- keep only **one concept per kernel**.
+
+---
+
+### step 4: declare as kernels
+- format each idea as a 🌱 **doc.kernel**.
+- a single doc may yield a **set of kernels** — one per concept.
+
+---
+
+## 📌 practice examples
+
+### ⚖️ gravity (from a lecture transcript)
+> *“so, basically, the reason the apple falls is because earth pulls on it with a force — and actually, any two masses in the universe attract each other, that’s Newton’s big insight.”*
+
+kernels extracted:
+- 🌱 `earth pulls on the apple`
+- 🌱 `any two masses attract each other`
+- 🌱 `Newton identified universal gravitation as a key insight`
+
+---
+
+### 🎵 music (from a conversation)
+> *“when you line up sounds in rhythm and melody, suddenly it feels like music instead of just noise. and harmony is what makes it feel rich.”*
+
+kernels extracted:
+- 🌱 `organized sound creates aesthetic experience`
+- 🌱 `rhythm and melody distinguish music from noise`
+- 🌱 `harmony creates richness in music`
+
+---
+
+### 🧩 triangle (from a textbook)
+> *“a triangle is defined as a polygon with three sides, three angles, and the sum of its angles equal to 180°.”*
+
+kernels extracted:
+- 🌱 `a triangle has three sides`
+- 🌱 `a triangle has three angles`
+- 🌱 `the sum of a triangle’s angles is 180°`
+
+---
+
+## ✨ reflection
+- 📚 docs = soils full of **many concepts** (entangled, verbose, raw).
+- 🔖 refs = labels into concepts (*“gravity”*, *“music”*).
+- 🌱 kernels = harvested seeds, **one per concept**.
+- 🪴 briefs = portable pots, where kernels are transplanted and structured.
+
+---
+
+## 🧠 takeaway
+to **<kernelize>** is to **harvest all the concepts from a doc**:
+- extract **each concept separately**
+- reduce it to its **minimal viable form**
+- treat kernels as **fertile seeds** for cataloging, briefing, or hosting in new docs.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno351.docs.are_instances.[article].md

@@ -0,0 +1,34 @@
+# 🧩 .brief.article: `documents as instances`
+
+## .what
+all **documents** are themselves **instances of their document type** (article, catalog, demo, lesson).
+because documents are created from instances, they in turn can serve as **instances for new documents**, enabling recursive knowledge-building.
+
+---
+
+## 🔬 definition
+- **duality:** a document is both
+  - a **materialization of a concept** (built from instances of reality), and
+  - an **instance itself** (of the document type, usable as input).
+- **mechanism:** documents can reference, incorporate, or organize other documents as if they were instances.
+- **implication:** knowledge systems are cumulative and self-referential, layering documents upon documents.
+
+---
+
+## 📌 examples
+- 📖 an *article* on gravity → becomes an instance in a 🗂️ catalog of scientific papers.
+- 🎬 a *demo* of empathy in a nurse–patient interaction → becomes an instance in a 📖 article defining empathy.
+- 🗂️ a *catalog* of philosophical texts → becomes an instance in a 🎓 lesson on the history of philosophy.
+- 🎓 a *lesson* on climate change → becomes an instance in a 🗂️ catalog of teaching curricula.
+
+---
+
+## ✨ insight
+- all documents are **instances of type**.
+- documents can serve as **input instances** for new documents.
+- this recursive structure explains how **knowledge accumulates and evolves**:
+  - concepts are materialized as documents,
+  - documents become instances,
+  - new documents materialize from those instances.
+
+in knowledge architecture, this principle underpins the **layered ecology of documents**, where works are both **outputs** and **inputs** in the ongoing materialization of concepts.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno351.docs.recursion.[catalog].md

@@ -0,0 +1,44 @@
+# 🧩 .brief.catalog: `recursion in documents`
+
+## .what
+because all documents are **instances of type**, they can serve as **input instances** for new documents.
+this recursive property explains how knowledge systems accumulate: documents continually materialize concepts while drawing on prior documents as their raw material.
+
+---
+
+## 📖 articles using documents
+- **citing:** reference prior articles as evidence or context.
+- **synthesizing:** weave multiple documents into a new definitional treatment.
+- **example:** a meta-article on “democracy” cites historical articles, demos, and lessons to define its evolution.
+
+---
+
+## 🗂️ catalogs using documents
+- **aggregating:** group documents of the same type into taxonomies or lists.
+- **indexing:** organize articles, demos, or lessons by topic, date, or author.
+- **example:** a catalog of teaching curricula (lessons) across universities.
+
+---
+
+## 🎬 demos using documents
+- **showcasing:** use an article, lesson, or catalog as the instance that exemplifies a concept.
+- **contextualizing:** demonstrate how a specific document embodies or reveals a broader principle.
+- **example:** a demo showing how Newton’s *Principia* itself demonstrates the process of scientific articulation.
+
+---
+
+## 🎓 lessons using documents
+- **sequencing:** structure lessons around prior articles, demos, or catalogs.
+- **teaching through documents:** use preserved works as practice material.
+- **example:** a philosophy curriculum built from Plato’s dialogues (demos), Aristotle’s categories (catalog), and modern articles.
+
+---
+
+## ✨ insight
+- 📖 **articles cite** other documents to refine definitions.
+- 🗂️ **catalogs aggregate** documents into organized systems.
+- 🎬 **demos showcase** documents as exemplars.
+- 🎓 **lessons sequence** documents into pathways of learning.
+
+recursion in documents ensures that knowledge is **layered, cumulative, and evolving**:
+documents are never isolated — they both **draw from** and **become** instances for new documents in the ongoing materialization of concepts.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno401.actors.1.role.author.[article].md

@@ -0,0 +1,36 @@
+# 🧩 .brief.article: `author`
+
+## .what
+an **author** is the actor that **creates documents**: they materialize concepts by selecting and arranging instances into communicable forms such as articles, catalogs, demos, or lessons.
+
+---
+
+## 📑 scope of operation
+- authors do **not** operate on collections; they originate documents.
+- their role is to **materialize concepts into documents**, shaping raw instances into definitional, organizational, relational, or pedagogical treatments.
+- where librarians weave documents into collections, authors weave instances into documents.
+
+---
+
+## 🔬 functions of an author
+1. **concept selection** → choosing which concept to materialize.
+2. **instance gathering** → collecting examples, cases, or data.
+3. **treatment choice** → deciding whether to articulate, catalogize, demonstrate, or lessonize.
+4. **composition** → structuring the document into coherent, transmissible form.
+5. **expression** → shaping language, style, and framing to suit audience and purpose.
+
+---
+
+## 📌 examples
+
+- **science:** an author creates a 📖 *document.article* defining “gravity,” a 🗂️ catalog of physical constants, a 🎬 demo of falling apples, or a 🎓 lesson on Newton’s laws.
+- **philosophy:** an author creates a 📖 article (Plato on justice), a 🗂️ catalog (Aristotelian categories), a 🎬 demo (Socratic dialogue), or a 🎓 lesson (ethics curriculum).
+
+---
+
+## ✨ insight
+- **authors** materialize concepts into *documents*.
+- **librarians** materialize documents into *collections*.
+- **readers** (to be articulated) materialize collections into *understanding*.
+
+in knowledge architecture, the **author** is the entry point: without authors producing documents, there is nothing for librarians to curate or readers to interpret.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno401.actors.1.role.librarian.[article].md

@@ -0,0 +1,40 @@
+# 🧩 .brief.article: `librarian`
+
+## .what
+a **librarian** is the actor that **curates knowledge collections**: rather than authoring new documents, the librarian operates on existing ones, arranging them into coherent systems that make knowledge accessible and durable.
+
+---
+
+## 📑 scope of operation
+- librarians do **not** usually instantiate documents themselves.
+- instead, they **operate on documents**: selecting, classifying, preserving, and connecting them within a knowledge system.
+- where authors **materialize concepts into documents**, librarians **materialize documents into collections**.
+
+---
+
+## 🔬 functions of a librarian
+1. **selection** → deciding which documents belong in a collection.
+2. **classification** → arranging documents into catalogs, indexes, and metadata systems.
+3. **navigation** → providing guides, references, and pathways for discovery.
+4. **preservation** → maintaining continuity of documents across time and formats.
+5. **contextualization** → situating documents in relation to one another, weaving knowledge networks.
+
+---
+
+## 📌 examples
+
+- **climate change:**
+  authors produce an 📖 article (definition), a 🗂️ catalog (models), a 🎬 demo (regional case), and a 🎓 lesson (curriculum).
+  the librarian curates them into a collection, classifies by type/domain, adds cross-references, and ensures long-term preservation.
+
+- **philosophy:**
+  authors produce an 📖 article (Metaphysics), a 🗂️ catalog (scholastic indexes), a 🎬 demo (Socratic dialogue), and a 🎓 lesson (curriculum).
+  the librarian curates them into traditions, preserves across formats, and builds navigation systems (indexes, headings).
+
+---
+
+## ✨ insight
+- **authors** materialize concepts into *documents*.
+- **librarians** materialize documents into *collections*.
+- mechanisms like **articulate, catalogize, demonstrate, lessonize** operate **within documents**.
+- the **librarian** operates **between documents**, turning scattered works into a coherent knowledge ecology.

package/dist/logic/roles/bhrain/.briefs/knowledge/kno401.actors.2.interdependence.[article].md

@@ -0,0 +1,52 @@
+# 🧩 .brief.catalog: `author ↔ librarian`
+
+## .what
+**authors** and **librarians** are interdependent mechanisms in the knowledge ecology.
+- 📖 **authors** materialize **documents from instances** (observations + documents).
+- 🗂️ **librarians** collect and curate **instances** (observations and documents) into accessible, preserved systems.
+this interdependence forms a loop: authors rely on librarians to supply instances, and librarians rely on authors to generate new documents to collect.
+
+---
+
+## 🔬 functions compared
+
+### 📖 author
+- **concept selection** → chooses which idea to materialize.
+- **instance gathering** → draws from reality *and* from preserved collections.
+- **treatment choice** → decides between article, catalog, demo, or lesson.
+- **composition** → structures instances into a coherent document.
+- **expression** → shapes language and style for audience.
+
+### 🗂️ librarian
+- **selection** → curates both observations (specimens, datasets) and documents.
+- **classification** → organizes them into catalogs, indexes, and metadata.
+- **navigation** → provides pathways for authors and readers to find instances.
+- **preservation** → maintains continuity of both raw data and documents.
+- **contextualization** → links instances so they can be meaningfully reused.
+
+---
+
+## 📌 examples
+
+- **science:**
+  - librarian preserves **specimens** (observation-instances) and **journals** (document-instances).
+  - author consults both to write an article on a new species.
+  - librarian then collects the new article into the archive, completing the loop.
+
+- **philosophy:**
+  - librarian preserves **ancient manuscripts** (document-instances) and **oral traditions/notes** (observation-instances).
+  - author draws on them to articulate a new article or construct a lesson.
+  - librarian curates the new works into the philosophical canon.
+
+---
+
+## ✨ insight
+- **authors** depend on librarians for access to *instances of reality* (observations preserved) and *instances of knowledge* (documents preserved).
+- **librarians** depend on authors to expand the corpus of documents worth curating.
+- together, they sustain a **two-way loop**:
+  1. librarians collect → preserve instances.
+  2. authors use instances → create documents.
+  3. librarians curate documents → collections.
+  4. authors return to collections → draw instances.
+
+this makes authors and librarians **mutually constitutive**: without librarians, authors lack access to accumulated instances; without authors, librarians lack new material to curate.