rhachet-roles-ehmpathy 1.1.0 → 1.2.0

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.example.[demo].usecase.book_flight.by_grok.md

@@ -0,0 +1,54 @@
+# 🧩 .brief.demo: `use case` via `example` = `booking flight`
+
+## 💡 Concept
+
+A use case describes how a user interacts with a system to achieve a specific goal, detailing actors, steps, and system responses to define functional requirements in software development.
+
+## ❓ Question
+
+> What is an example of a use case?
+
+## 📌 Example: Booking a Flight on a Travel Website
+
+### 📌.📖 What
+
+> What is the use case "booking a flight on a travel website"?
+
+The use case "booking a flight on a travel website" is a structured description of how a traveler uses an online platform like Expedia or Kayak to purchase an airline ticket.
+
+- **Actor**: Traveler (the user seeking to book a flight).
+- **Goal**: To purchase an airline ticket for a chosen destination and date.
+- **Preconditions**: The user has access to the travel website via a web browser or mobile app and a valid payment method.
+- **Main Flow**:
+  1. **User**: Navigates to the website’s homepage and enters departure city, destination, travel dates, and passenger details, then clicks “Search.”
+  2. **System**: Displays a list of available flights with details (airlines, times, prices).
+  3. **User**: Selects a preferred flight and optional extras (e.g., seat selection, baggage).
+  4. **System**: Prompts for passenger details (name, contact info) and payment information.
+  5. **User**: Enters payment details and confirms the booking.
+  6. **System**: Processes payment, books the ticket, and sends a confirmation email with the ticket.
+- **Exceptions**:
+  - **No Flights Available**: If no flights match the criteria, the system displays an error and suggests alternative dates or destinations.
+  - **Payment Failure**: If payment fails, the system notifies the user and prompts re-entry or an alternative payment method.
+
+### 📌.🔍 How
+
+> How is it an example of a use case?
+
+The use case "booking a flight on a travel website" exemplifies a use case by providing a structured description of a traveler’s interaction with a system to achieve a specific goal, capturing user actions, system responses, and edge cases. It serves as a clear blueprint for developers, illustrating how use cases define functional requirements and ensure user-centric system design.
+
+- **Defined Actor and Goal**
+  - **Traveler as Actor**: Specifies the user (traveler) as the primary actor, aligning with the use case’s focus on who interacts with the system.
+  - **Clear Objective**: The goal of purchasing a ticket drives the interaction, a core element of any use case.
+  - **System Role**: The travel website facilitates the goal, acting as the system under consideration.
+- **Structured Interaction Flow**
+  - **Sequential Steps**: Details a clear sequence (search, select, pay), mirroring the step-by-step flow typical of use case descriptions.
+  - **User-System Dialogue**: Alternates between user actions (e.g., entering details) and system responses (e.g., displaying flights), reflecting use case dynamics.
+  - **Preconditions Included**: Specifies requirements like internet access and payment method, setting the stage for the interaction.
+- **Exception Handling**
+  - **Error Scenarios**: Addresses cases like no flights or payment failure, showing how use cases account for alternate paths.
+  - **User Guidance**: System responses (e.g., error messages, prompts) ensure users can navigate issues, a key use case feature.
+  - **Robustness**: Captures edge cases, ensuring the system is designed to handle real-world challenges.
+- **Requirements Specification**
+  - **Functional Needs**: Outlines needs like search functionality and payment processing, guiding developers on system features.
+  - **Security Focus**: Highlights secure payment handling, a critical requirement derived from the use case.
+  - **Stakeholder Clarity**: Provides a clear reference for developers, testers, and designers to align on user needs and system behavior.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.example.[demo].usecase.order_food.by_chatgpt.md

@@ -0,0 +1,40 @@
+# .brief.demo: `use case` via `example` = `online food delivery`
+
+## 💡 concept
+a use case describes how a user interacts with a system to achieve a specific goal, detailing the steps, actors, and system responses involved in the interaction.
+
+## ❓ question
+> what is an example of a use case?
+
+## 📌 example: online food delivery
+
+### 📌.📖 what
+
+> what is the online food delivery use case?
+
+the online food delivery use case outlines how a customer orders food through a delivery platform (like doordash or uber eats), and how the system responds at each stage to fulfill the request. it represents a common digital interaction where multiple actors (customer, restaurant, courier, system) collaborate to achieve the user’s goal: receiving a meal at home.
+
+- **actors involved**
+  - customer places an order
+  - restaurant receives and prepares food
+  - courier picks up and delivers the order
+  - system coordinates communication and payments
+- **goal**
+  - customer receives desired food at their location in a timely manner
+- **context**
+  - mobile app or website interface, integrated with payment and logistics
+
+### 📌.🔍 how
+
+> how is online food delivery an example of a use case?
+
+it demonstrates a use case by showing the **sequence of interactions**:
+
+1. **customer action**: browses menu, selects food, and confirms order.
+2. **system response**: sends order details to the restaurant, processes payment, provides confirmation to customer.
+3. **restaurant action**: prepares the food and marks it ready.
+4. **system response**: dispatches courier notification and tracks delivery.
+5. **courier action**: picks up order and delivers to customer’s address.
+6. **system response**: updates tracking, confirms delivery, and collects feedback.
+
+this example embodies the concept of a use case by mapping out actors, steps, and goals in a structured way, showing how user intent translates into system-supported outcomes.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.example.[demo].walkability.portland.by_chatgpt.i3.md

@@ -0,0 +1,42 @@
+# .brief.demo: `walkability` via `example` = `downtown portland`
+
+## 💡 concept
+walkability is the measure of how friendly an area is to walking, determined by the proximity of daily needs, the quality of pedestrian infrastructure, and the safety and comfort of the walking environment.
+
+## ❓ question
+> what is an example of walkability?
+
+## 📌 example: downtown portland
+
+### 📌.📖 what
+
+> what is downtown portland?
+
+downtown portland is a central neighborhood in portland, oregon, known for its compact urban grid, accessible public transit, and pedestrian-friendly design. the area integrates commercial, residential, and cultural spaces within short walking distances.
+
+- **daily needs within reach**
+  - groceries, cafes, and schools located within 5–10 minutes by foot
+    - *example:* whole foods and local corner markets
+    - *example:* elementary schools and daycare facilities
+- **continuous walking network**
+  - sidewalks, curb ramps, and bike lanes that form a safe, connected grid
+    - *example:* protected bike lanes on broadway
+- **pedestrian-priority crossings**
+  - crosswalks, countdown signals, and curb extensions
+    - *example:* marked intersections with pedestrian-first light cycles
+- **transit integration**
+  - max light rail, bus, and streetcar stops accessible directly from sidewalks
+    - *example:* pioneer courthouse square transit hub
+
+### 📌.🔍 how
+
+> how is downtown portland an example of walkability?
+
+downtown portland exemplifies walkability because it combines **proximity**, **infrastructure**, and **integration**:
+
+- **proximity**: mixed-use zoning keeps housing, workplaces, shops, and cultural venues close together, reducing reliance on cars.
+- **infrastructure**: the city grid ensures short blocks, frequent intersections, and pedestrian-scale street design that prioritize people on foot.
+- **integration**: public transit connects seamlessly with sidewalks, allowing trips to extend beyond walking range without breaking the pedestrian experience.
+- **safety and comfort**: traffic calming, green streets, and shaded sidewalks create a walking environment that is both secure and inviting.
+
+together, these factors transform downtown portland into a living demonstration of how urban design can encourage walking as the default mode of daily life.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.example.[demo].walkability.portland.by_grok.i2.md

@@ -0,0 +1,49 @@
+# 🧩 .brief.demo: `walkability` via `example` = `portland`
+
+## 💡 Concept
+
+Walkability refers to how friendly an area is to walking, characterized by safe, accessible, and pleasant environments that encourage pedestrian activity, reduce car dependency, and promote community interaction.
+
+## ❓ Question
+*What is an example of walkability?*
+
+## 📌 Example: Portland’s Pearl District
+
+### 📌.📖 What
+
+What is Portland’s Pearl District?
+
+The Pearl District is a vibrant, urban neighborhood in Portland, Oregon, known for its transformation from an industrial area into a cultural hub with art galleries, lofts, and lively public spaces. Once home to warehouses and rail yards, it’s now a model of modern urban living with a focus on community and accessibility.
+
+- **Historical Context**
+  - **Industrial Origins**: Began as a late 19th-century warehouse and rail yard district, redeveloped in the 1990s into a residential and commercial area.
+  - **Urban Renewal**: Old industrial buildings were converted into lofts, galleries, and shops, revitalizing the area into a bustling neighborhood.
+- **Neighborhood Character**
+  - **Cultural Hub**: Features prominent art galleries, boutique shops, and restaurants, drawing artists, residents, and tourists.
+  - **Modern Design**: Combines historic brick buildings with sleek, contemporary architecture in a compact grid layout.
+- **Community Features**
+  - **Public Parks**: Includes Jamison Square and Tanner Springs Park, offering green spaces for recreation and community events.
+  - **Diverse Housing**: Provides high-rise condos, converted lofts, and some affordable housing, fostering a varied resident base.
+
+### 📌.🔍 How
+
+How is it an example of walkability?
+
+The Pearl District exemplifies walkability through its compact, mixed-use design, robust pedestrian infrastructure, and vibrant community spaces that make walking safe, convenient, and enjoyable. Its integration with transit and focus on sustainability further enhance its pedestrian-friendly environment.
+
+- **Mixed-Use Accessibility**
+  - **Proximity of Amenities**: Shops, cafes, galleries, and offices are within a 10–15 minute walk, enabling car-free daily routines.
+  - **Street-Level Engagement**: Ground-floor businesses with outdoor seating create lively, walkable destinations.
+  - **Compact Layout**: Short blocks and a grid pattern minimize walking distances, encouraging pedestrian travel.
+- **Pedestrian-Friendly Infrastructure**
+  - **Safe Sidewalks**: Wide, ADA-compliant sidewalks and frequent crosswalks with countdown timers ensure accessibility and safety.
+  - **Traffic Calming**: Speed bumps and narrowed streets reduce vehicle speeds, prioritizing pedestrian movement.
+  - **Aesthetic Appeal**: Tree-lined streets and public art enhance the walking experience, making it pleasant and inviting.
+- **Transit Integration**
+  - **Streetcar Access**: The Portland Streetcar connects the district to downtown and other areas, supporting car-free mobility.
+  - **Light Rail Proximity**: Nearby MAX light rail stations provide regional access, complementing walking routes.
+  - **Bike Synergy**: Dedicated bike lanes and racks integrate cycling with walking, enhancing multimodal options.
+- **Community and Environmental Benefits**
+  - **Social Connectivity**: Plazas and events like farmers’ markets foster interactions, making walking a community-building activity.
+  - **Sustainability**: Reduced car use lowers emissions, aligning with Portland’s eco-friendly ethos.
+  - **Health Promotion**: Walkable access to amenities encourages physical activity, supporting resident well-being.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.example.[lesson].howto.md

@@ -0,0 +1,28 @@
+# 🧩 .brief.lesson: howto create a .brief.demo via example
+
+## 🎯 Objective
+
+Learn how to create a `.brief.demo`, a concise document that demonstrates a concept through a specific example, with a focus on instantiating the concept in a dedicated “What” section to make it clear and tangible.
+
+## 📋 Steps
+
+1. **Define the Concept Clearly**
+   - Write a brief, one-sentence definition of the concept to set the context for the demonstration.
+   - **Example**: For the concept of a use case, define it as “A use case describes how a user interacts with a system to achieve a goal, detailing actors, steps, and system responses.”
+2. **Choose a Representative Example**
+   - Select a single, concrete example that directly embodies the concept and is relatable to the audience.
+   - **Example**: For shear force, choose “scissors cutting paper” to show parallel forces causing material deformation, a clear and familiar instance.
+3. **Instantiate the Concept in the “What” Section**
+   - Present the example as a direct instance of the concept, using a structure that mirrors its natural form (e.g., a use case template for “Booking a Flight,” a scenario for shear force).
+   - Avoid general descriptions; focus on showing the concept in action.
+   - **Example**: For a use case, present a structured description with Actor (Traveler), Goal (purchase a ticket), Main Flow (search, select, pay), and Exceptions (no flights, payment failure).
+4. **Explain the Connection in a “How” Section**
+   - Detail how the example embodies the concept’s key characteristics, using a structured format like a bulleted list to ensure clarity and depth.
+   - **Example**: For “Booking a Flight,” explain how its structured flow and exception handling align with a use case’s role in defining system requirements.
+
+## 🔑 Key Considerations
+
+- **Instantiation is Key**: The “What” section should always present the example as an instance of the concept (e.g., a use case template, not just a booking process) to directly demonstrate its essence, making the concept tangible.
+- **Keep It Concise**: Avoid verbose outlines or excessive sub-bullets; focus on the example’s core elements to maintain clarity, as seen in the streamlined “Booking a Flight” use case.
+- **Adapt to Concept Type**: Tailor the instantiation to the concept’s nature—use templates for meta-concepts (e.g., use case), scenarios for physical concepts (e.g., shear force), or specific items for tangible concepts (e.g., Darjeeling tea).
+- **Ensure Relatability**: Choose examples that resonate with the audience (e.g., scissors for shear force, a familiar website for booking), ensuring accessibility across technical or abstract concepts.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.example.structure.[article].i2.md

@@ -0,0 +1,73 @@
+# 🧩 .brief.article: `recommended structure of .brief.demo via example`
+
+## 🌟 introduction
+
+a `.brief.demo` is a streamlined, example-driven document designed to illustrate a concept by presenting a specific instance of it in a structured markdown format. by recommending a standardized structure with a focus on instantiating the concept, it ensures clarity, engagement, and adaptability for diverse audiences, from students to professionals.
+
+## 📚 the core components
+
+the `.brief.demo` follows a logical progression to build understanding step by step.
+
+### 1. concept definition (💡)
+a concise, one-sentence definition of the concept, setting the foundation without overwhelming the reader. it acts as the entry point, ensuring everyone starts on the same page.
+
+- **purpose**: define the concept succinctly, avoiding jargon where possible.
+
+### 2. guiding question (❓)
+a block-quoted question focuses the demo on a specific inquiry, typically:
+`> what is an example of [concept]?`
+
+- **purpose**: to create curiosity and direct attention to the example’s role in answering the query.
+
+### 3. example presentation (📌)
+this is the heart of the `.brief.demo`, introducing the chosen example and breaking it into two subsections: **what** and **how**.
+
+#### 📌.📖 what
+instantiates the concept by presenting the example in its most representative form. the structure used here is imagined to best fit the concept being demonstrated.
+
+**purpose**: to make the concept tangible rather than abstract.
+
+#### 📌.🔍 how
+explains how the instantiated example embodies the concept. the structure of this explanation is also imagined to best fit the concept.
+
+**purpose**: to provide depth and analysis, linking the instance back to the definition in a systematic way.
+
+### 4. placeholder example of `.brief.demo` structure
+
+\`\`\`markdown
+# 🧩 .brief.demo: `[concept]` via `example` = `[example]`
+
+## 💡 concept
+[brief definition of the concept]
+
+## ❓ question
+> what is an example of [concept]?
+
+## 📌 example: [example title]
+
+### 📌.📖 what
+
+> What is [specific example of the concept]?
+
+[brief introduction to the example]
+
+[structured instantiation imagined to fit the concept]
+
+### 📌.🔍 how
+
+> How is it an example of [concept]?
+
+[brief explanation of how it embodies the concept]
+
+[structured explanation imagined to fit the concept]
+\`\`\`
+
+## ✅ benefits and adaptability
+
+the `.brief.demo` structure excels in its adaptability:
+
+- **clarity through instantiation**: the “what” section transforms abstractions into concrete, example-driven forms.
+- **depth without overload**: the “how” section provides analysis through whatever framing best matches the concept, ensuring precision without unnecessary bulk.
+- **versatility across domains**: whether scientific, technical, social, or abstract, the structure adapts by letting the instance shape its own presentation.
+
+this makes `.brief.demo` a powerful tool for education, documentation, and knowledge sharing, consistently delivering clear and engaging concept demonstrations.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.narrative.[demo].usecase.order_online.by_chatgpt.md

@@ -0,0 +1,34 @@
+# .brief.demo: `use case` via `narrative` = `ordering dinner on an app`
+
+## 💡 concept
+a use case describes how a user interacts with a system to achieve a specific goal, detailing the steps, actors, and system responses involved in the interaction.
+
+## ❓ question
+> what is a narrative example of a use case?
+
+## 📌 narrative: ordering dinner on an app
+
+### 📌.📖 what
+
+> what is the story of ordering dinner on an app?
+
+emma has just finished a long day at work and doesn’t feel like cooking. she opens her favorite food delivery app on her phone, browses local restaurants, and chooses a thai place she likes. after customizing her pad thai with no peanuts, she taps “order now.”
+
+- the **system** processes her payment and confirms the order.
+- the **restaurant** receives the request and begins cooking.
+- a **courier** is assigned and notified through the app.
+- emma gets real-time updates and watches the courier’s location as the delivery approaches.
+- finally, the courier rings her doorbell and hands her dinner, just as the app marks the order complete.
+
+### 📌.🔍 how
+
+> how does this narrative embody a use case?
+
+this narrative demonstrates a use case because it shows:
+
+- **actors**: emma (customer), the app (system), the restaurant, and the courier.
+- **goal**: emma’s objective of getting a meal delivered.
+- **steps**: the sequence of interactions—from browsing and ordering to cooking, delivery, and confirmation.
+- **system responses**: payment processing, status updates, and delivery tracking that support each step.
+
+by telling a story from the user’s perspective, the narrative highlights the flow of interactions that define a use case, making the abstract concept tangible and relatable.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/<demonstrate>.variants.walkthrough.[demo].usecase.book_online.by_chatgpt.md

@@ -0,0 +1,47 @@
+# .brief.demo: `use case` via `walkthrough` = `booking a hotel room online`
+
+## 💡 concept
+a use case describes how a user interacts with a system to achieve a specific goal, detailing the steps, actors, and system responses involved in the interaction.
+
+## ❓ question
+> what is a walkthrough example of a use case?
+
+## 📌 walkthrough: booking a hotel room online
+
+### 📌.📖 what
+
+> what is the walkthrough of booking a hotel room?
+
+a customer wants to reserve a hotel stay through a booking website. this walkthrough guides step by step through the interaction from start to finish.
+
+1. **open system**
+   - user navigates to the hotel booking website.
+   - *system response:* homepage loads with search bar.
+2. **search hotels**
+   - user enters destination, dates, and guest count.
+   - *system response:* list of available hotels appears.
+3. **select hotel**
+   - user browses and chooses a hotel.
+   - *system response:* details page shows amenities, price, and photos.
+4. **choose room**
+   - user selects a room type.
+   - *system response:* room availability and price confirmed.
+5. **enter details**
+   - user provides guest information and payment method.
+   - *system response:* form validates input and displays order summary.
+6. **confirm booking**
+   - user clicks “book now.”
+   - *system response:* confirmation page with reservation number and email receipt.
+
+### 📌.🔍 how
+
+> how is this a walkthrough of a use case?
+
+this walkthrough shows the **structured sequence** of steps and responses:
+
+- **actors**: user and system are clearly identified at each stage.
+- **goal orientation**: every step moves toward the outcome—successfully booking a room.
+- **interaction clarity**: system responses are paired with user actions, demonstrating the back-and-forth flow.
+- **step-by-step detail**: breaking the process into checkpoints makes the use case easy to follow and replicate.
+
+the walkthrough method highlights the **procedural nature** of a use case, showing how user actions trigger system behavior until the goal is achieved.

package/dist/logic/roles/bhrain/.briefs/librarian.tactics/[brief].verbiage.outline.over.narrative.md

@@ -0,0 +1,55 @@
+# 🧩 .brief: `brief.article.format.outline`
+
+## .what
+**`brief.article.format.outline`** specifies the preference for writing **[brief][article]**s in **outline format** rather than paragraph format,
+in order to **maximize signal-to-noise ratio** — ensuring the reader receives the **most relevant information** with the **least distraction**.
+
+---
+
+## 🎯 purpose
+- prioritize **information density** over narrative flow
+- enable **rapid scanning** and **selective focus** on relevant points
+- minimize **filler language**, rhetorical padding, and connective prose that dilute clarity
+
+---
+
+## 📐 rationale
+### 1. higher signal density
+- each point stands alone, stripped to its essential statement
+- no dependency on surrounding sentences for meaning
+
+### 2. lower cognitive noise
+- reduced verbal clutter, fewer transitions
+- visual separation between concepts lowers mental parsing cost
+
+### 3. faster scanning & retrieval
+- indentation and bullet hierarchy serve as immediate visual anchors
+- enables “jump-to-point” reading without loss of context
+
+### 4. explicit structure
+- hierarchy is visible, not inferred
+- easier to map relationships between concepts at a glance
+
+---
+
+## 🔍 comparison
+| factor                  | outline format  | paragraph format |
+|-------------------------|----------------|------------------|
+| signal density          | **high**       | medium           |
+| noise suppression       | **strong**     | weaker           |
+| scan speed              | **fast**       | slower           |
+| structure visibility    | **explicit**   | implicit         |
+| nuance capacity         | lower          | higher           |
+
+---
+
+## 🛠 usage guidance
+- default to outline format for all `[brief][article]`s
+- use paragraph sub-sections **only** when nuance or rhetorical flow is essential
+- keep bullet points **single-idea only**; avoid compound sentences in bullets
+
+---
+
+## 📎 note
+this preference is **format-level**, not **content-level** — it shapes **presentation**, not **what is included**.
+the core content of a [brief] remains the same regardless of format; the outline format simply transmits it **more cleanly and quickly**.

package/dist/logic/roles/bhrain/.briefs/thinker.tactics/<cluster>._.[article].frame.tactical._.md

@@ -0,0 +1,85 @@
+# 🧩 .brief: `thought process of <cluster>`
+
+## .what
+
+The `<cluster>` operation involves grouping related concepts, ideas, or data points into cohesive units based on shared characteristics or themes. This process leverages pattern recognition and categorization principles to enhance understanding, comparison, and analysis.
+
+---
+
+## 🎯 purpose
+
+- to identify and form meaningful groups from disparate elements
+- to facilitate deeper insights through pattern recognition
+- to simplify complex information by breaking it into manageable parts
+
+---
+
+## ⚙️ method
+
+1. **identify elements**
+   - gather concepts, ideas, or data points that need clustering
+   - ensure a diverse and representative sample
+
+2. **determine criteria**
+   - establish the basis for clustering (e.g., shared attributes, function, purpose)
+   - criteria should be clear and consistent across all elements
+
+3. **analyze and group**
+   - assess each element against the criteria
+   - form clusters based on the most significant matches or relationships
+
+4. **review and refine**
+   - evaluate clusters for clarity, coherence, and relevance
+   - adjust groupings as necessary for optimal structure
+
+---
+
+## 🧠 cognitive basis
+
+Clustering relies on the brain's natural ability to recognize patterns and associations. It mimics cognitive processes involved in categorization, memory retrieval, and decision-making, thereby streamlining information processing and comprehension.
+
+---
+
+## 📐 when to use
+
+- when dealing with large volumes of information that need organization
+- when exploring relationships between concepts for strategic insight or analysis
+- when preparing data for presentation, highlighting key themes or trends
+
+---
+
+## 🔁 dynamic behavior
+
+Clustering is often iterative, with repeated cycles of grouping, reviewing, and refining. This helps to accommodate new information or evolving understanding, ensuring clusters remain relevant and actionable.
+
+---
+
+## ⚠️ caution: over-clustering
+
+Avoid creating too many clusters or overly complex structures, which can obscure rather than clarify. Clusters should strike a balance between granularity and cohesion.
+
+---
+
+## 🧰 use it for:
+
+- data analysis and research
+- strategic planning and brainstorming
+- knowledge management and taxonomy development
+
+---
+
+## 📊 examples
+
+1. **Market Segmentation**
+   - Grouping customers based on demographic, geographic, or behavioral characteristics to tailor marketing strategies.
+
+2. **Academic Research**
+   - Clustering academic papers or references by themes or topics to identify research gaps or emerging trends.
+
+3. **Product Categorization**
+   - Organizing products into categories like electronics, clothing, and home appliances to enhance user navigation in online stores.
+
+4. **Strategic Brainstorming**
+   - Grouping ideas from brainstorming sessions into actionable categories such as short-term tactics, long-term strategies, and innovative solutions.
+
+---

package/dist/logic/roles/bhrain/.briefs/thinker.tactics/<cluster>.vs_<diverge>.duality.[article].md

@@ -0,0 +1,43 @@
+# 🧩 .brief: `<diverge> ↔ <cluster>`
+
+## .what
+the **duality** between `<diverge>` and `<cluster>` describes a **complementary motion of thought**:
+- `<diverge>` expands a concept outward into **maximum variance instances**
+- `<cluster>` contracts many instances inward into **coherent groupings**
+
+together they form a **push–pull dynamic** of exploration and organization.
+
+---
+
+## 🎯 purpose
+- balance **creativity and clarity**: generate wide variety, then refine into structure
+- ensure **coverage and coherence**: divergence prevents blind spots, clustering prevents overload
+- support **iterative cycles of insight**: each informs and strengthens the other
+
+---
+
+## ⚙️ motion
+1. **<diverge>**
+   - spread focus to surface **differences, alternatives, and variations**
+   - motion is centrifugal — outward, increasing breadth
+
+2. **<cluster>**
+   - compress focus to reveal **patterns, affinities, and themes**
+   - motion is centripetal — inward, increasing coherence
+
+---
+
+## 🔄 interplay
+- divergence without clustering → noise, endless fragments, lack of synthesis
+- clustering without divergence → rigidity, premature convergence, missed options
+- **dual-cycle**:
+  1. diverge to gather possibilities
+  2. cluster to extract structure
+  3. repeat as needed, each cycle sharper
+
+---
+
+## 📐 metaphor
+- `<diverge>` = scattering seeds across a field
+- `<cluster>` = harvesting them into sheaves
+- the **crop of thought** emerges only through both motions in rhythm

package/dist/logic/roles/bhrain/.briefs/thinker.tactics/<diverge>._.[article].frame.cognitive.[seed].md

@@ -0,0 +1,4 @@
+<diverge> is an extreme example of <vary>
+
+see cognition briefs for reference
+

package/dist/logic/roles/bhrain/.briefs/thinker.tactics/<diverge>._.[article].frame.tactical.md

@@ -0,0 +1,89 @@
+# 🧩 .brief: `diverge.refs`
+
+## .what
+**`diverge.refs`** is a **generation tactic** that creates multiple distinct `[concept][ref]` (reference) forms from a single seed question.
+instead of locking into one framing, it **branches** the expression into alternative answer-forms — each still anchored to the intent of the original question.
+
+---
+
+## 🎯 goal
+- explore **variety in expression** while retaining core meaning
+- surface **different entry points** for the same underlying concept
+- identify **strongest, most resonant refs** for specific audiences or purposes
+
+---
+
+## 📜 contract
+for `<diverge.refs>` to work as intended:
+
+input = [seed][question]
+  - **only questions** — the `[seed][ref]` **must** be phrased as a question that clearly guides what to diverge into.
+  - **no statements** — statement seeds are disallowed, as they create uncertainty about whether outputs should be synonyms, examples, or subtopics.
+
+output = [concept][ref]
+  - **only answers** — each divergence **must** be an **alternative answer reference** to the seed question.
+
+**why this contract exists:**
+- questions naturally define a **search space of possible answers**, capable of precise generation guidance
+- answers can be compared for **completeness and variety** relative to the same inquiry
+- keeps outputs consistently interpretable as **answer-forms** to the same guiding question
+
+---
+
+## ⚙️ method
+1. **anchor to the seed question**
+   - start from a single clear question (seed `[ref]`)
+   - clarify the essential meaning to preserve across all divergences
+
+2. **generate branches**
+   - vary along one or more axes relevant to the goal
+   - ensure each `[ref]` is **meaningfully different**, not just cosmetic rewording
+
+3. **assess & refine**
+   - check for clarity, accuracy, and audience fit
+   - prune weak or redundant variations
+
+---
+
+## 📐 when to use
+- when testing **messaging resonance**
+- when creating **menus of choices** or **navigation labels**
+- when brainstorming **campaign slogans, feature names, or thematic headers**
+
+---
+
+## 🖼 examples
+
+### example 1
+
+**seed `[ref]`:** "what makes historic train travel memorable?"
+
+- "luxury journeys aboard restored locomotives"
+- "guided scenic tours through mountain passes"
+- "onboard dining with period-accurate menus"
+- "storytelling from railway historians"
+- "overnight sleeper cars with vintage charm"
+
+---
+
+### example 2
+
+**seed `[ref]`:** "how can cooks work smarter in the kitchen?"
+
+- "by prepping ingredients in bulk ahead of time"
+- "by keeping knives sharpened for faster cutting"
+- "by labeling and dating all stored food"
+- "by cleaning as they go to save time"
+- "by organizing stations for smoother workflow"
+
+---
+
+### example 3
+
+**seed `[ref]`:** "what are different types of ducks?"
+
+- "mallard"
+- "wood duck"
+- "northern pintail"
+- "muscovy duck"
+- "american black duck"

package/dist/logic/roles/bhrain/.briefs/thinker.tactics/<elaborate>_vs_<elucidate>.[seed].md

@@ -0,0 +1 @@
+To elucidate is to make something clear and easy to understand, essentially to shed light on it, while to elaborate is to provide more details, information, or examples to expand upon a topic or idea. The choice depends on whether the goal is to clarify a concept or to provide greater depth and breadth of information about it.