rhachet-roles-ehmpathy 1.13.1 → 1.13.3

package/dist/logic/roles/bhrain/.briefs/worders/teach.via.library.explanations_vs_examples.md

@@ -0,0 +1,40 @@
+# 🎛️ in-context tuning: explanations vs examples
+
+## 🧩 examples
+- **what they do:** show *how* to perform the task by demonstration.
+- **strengths:**
+  - precise control over output **format** and **style**
+  - model can “copy the pattern” with little ambiguity
+  - fast to apply, low cognitive overhead for the model
+- **weaknesses:**
+  - brittle if task deviates from the pattern
+  - encourages mimicry rather than reasoning
+
+---
+
+## 🧩 explanations
+- **what they do:** tell *why* and *how* the task should be done via rules, instructions, or reasoning steps.
+- **strengths:**
+  - supports **generalization** beyond shown cases
+  - encourages **reasoning chains** instead of rote mimicry
+  - more compact than many examples (token-wise)
+- **weaknesses:**
+  - less consistent for rigid formats (the model may improvise)
+  - requires the model to “translate” abstract rules into concrete actions, which can be noisy
+
+---
+
+## ⚖️ effectiveness comparison
+- **examples win** when:
+  - the task is about *output form* (e.g. json schemas, sql syntax, markdown briefs)
+  - consistency is more important than novelty
+- **explanations win** when:
+  - the task is about *reasoning* or handling unseen variations
+  - flexibility and abstraction matter more than surface mimicry
+
+---
+
+## 🎯 hybrid strategy
+- the strongest “in-context tunage” usually comes from **explanations + 1–2 examples**.
+  - explanation gives the **reasoning scaffold**
+  - examples ground it with **concrete reference points**

package/dist/logic/roles/bhrain/.briefs/worders/trend.prefer_reuse.[seed].md

@@ -0,0 +1,10 @@
+llms prefer reuse input tokens
+
+why?
+- why do they do that (rationale)
+- why do we care? (causal)
+  - how we can use it
+
+---
+
+i.e., most of the time, safe to expect it'll only change the bare minimum

package/dist/logic/roles/bhrain/brief.articulate/stepArticulate.template.md

@@ -0,0 +1,120 @@
+# 🗣️ prompt: `<articulate>` — generate a .brief article for a given [concept]
+
+you are a **skilled explainer** performing the **focus.motion** primitive `<articulate>`.
+
+---
+
+## 📜 contract
+for `<articulate>` to work as intended:
+
+input = [concept][brief] = `focus.concept`
+  - may be **empty** (start from scratch)
+  - may be a **seed** (partial brief to expand)
+  - may be **inflight** (actively being refined)
+  - must define a **single, coherent concept** — not a bundle of unrelated topics
+
+output = [concept][brief]
+  - a high-signal markdown `.brief` that captures the concept in clear, accessible form
+  - must be **complete** enough to serve as a stable reference for others or your future self
+  - all sections should maximize **signal-to-noise** and avoid filler
+
+**why this contract exists:**
+- articulation turns **implicit understanding** into **explicit, structured form**
+- consistent `.brief` structure ensures clarity, comparability, and reuse
+- constraints prevent drift away from the core concept
+
+---
+
+## ⚙️ method
+1. **anchor to the seed**
+   - establish the core concept or seed you’re articulating
+   - lock in scope and avoid redefining mid-process
+
+2. **structure**
+   - choose an organizational frame (outline, template, narrative, gallery-based, etc.)
+   - match format to purpose and audience
+   - when producing the brief:
+     - leverage **the provided templates** when relevant
+     - and/or **imagine the most useful aspects to articulate** for the concept, based on its nature and context
+
+3. **express**
+   - render the concept in clear, direct language
+   - surface key attributes, context, and distinctions
+
+4. **refine**
+   - check for clarity, completeness, and fidelity to the original intent
+   - adjust wording or structure as needed
+
+---
+
+## 📐 output format
+- return **only** the `.md` brief — no extra commentary
+- always start with:
+  `# 🧩 .brief.article: \`[concept]\``
+- all section headers use `##` or `---` separators
+- prose must be lowercase except proper nouns
+- use concise lists and short paragraphs; avoid long blocks of text
+
+
+---
+
+## 📚 briefs
+
+here are the .briefs you've studied for this skill and actively strive to leverage
+
+$.rhachet{skill.briefs}
+
+---
+
+## 📥 inputs
+
+the following inputs define the semantic frame for `<articulate>`:
+
+---
+
+## 📎 references
+
+here are possibly relevant references you may need
+
+$.rhachet{references}
+
+---
+
+## 📒 templates
+
+here are the templates you should leverage
+
+$.rhachet{templates}
+
+---
+
+### 🧘 @[focus.context]
+> the context in focus available for leverage
+
+\`\`\`md
+$.rhachet{focus.context}
+\`\`\`
+
+---
+
+### 🫐 @[focus.concept]
+> the **inflight document of output** — the seed brief being refined by `<articulate>`
+> if this is empty, treat it as **no seed** and start from scratch
+
+\`\`\`md
+$.rhachet{focus.concept}
+\`\`\`
+
+---
+
+### 🎯 @[guide.goal]
+\`\`\`md
+$.rhachet{guide.goal}
+\`\`\`
+
+---
+
+### 💬 @[guide.feedback]
+\`\`\`md
+$.rhachet{guide.feedback}
+\`\`\`

package/dist/logic/roles/bhrain/brief.demonstrate/stepDemonstrate.template.md

@@ -0,0 +1,135 @@
+# 🗣️ prompt: `<demonstrate>` — generate a .brief demo for a given [concept]
+
+you are a **skilled explainer** performing the **focus.motion** primitive `<demonstrate>`.
+
+---
+
+## 📜 contract
+for `<demonstrate>` to work as intended:
+
+**input = [concept][brief][article] || [concept][ref] = seed.concept**
+- a **[concept][brief][article]** is a **full article**: a complete, structured write-up containing all necessary details.
+- a **[concept][ref]** is just a **reference**: a short label or title pointing to a concept.
+- input **cannot** be empty. if `seed.concept` is empty, return:
+  `"BadRequestError: no seed.concept"`
+- input must define a **single, coherent concept** — not a bundle of unrelated topics. if not coherent, return:
+  `"BadRequestError: incoherent seed.concept"`
+
+**output = [concept][brief][demo] = focus.concept**
+- a high-signal markdown `.brief` that **demonstrates** the concept in clear, observable form
+- may be **empty** (start from scratch)
+- may be a **seed** (partial demo to expand)
+- may be **inflight** (actively being refined)
+- must include **examples, evidence, or procedures** that make the concept tangible
+- should be **convincing** enough to prove or validate the concept to the audience
+- all sections must maximize **clarity and impact**, avoiding filler
+
+**why this contract exists:**
+- demonstration transforms **abstract ideas** into **visible, provable outcomes**
+- structured `.brief` demos ensure clarity, reproducibility, and comparability
+- constraints prevent drift toward generic explanation instead of concrete showing
+
+---
+
+## ⚙️ method
+1. **anchor to the seed**
+   - identify the concept or reference to demonstrate
+   - clarify the objective (what the demo must prove, show, or validate)
+
+2. **structure**
+   - select one or more demonstration modes (hands-on, visual, case study, simulation, walkthrough, etc.)
+   - match format to audience, context, and purpose
+
+3. **execute**
+   - lay out steps, examples, or evidence
+   - show rather than tell; prioritize observable details
+
+4. **validate**
+   - highlight results, outcomes, or feedback that confirm the concept
+   - integrate audience interaction or checkpoints for understanding
+
+5. **refine**
+   - review for clarity, engagement, and persuasiveness
+   - adapt based on context or feedback
+
+---
+
+## 📐 output format
+- return **only** the `.md` brief — no extra commentary
+- always start with:
+  `# 🧩 .brief.demo: \`[concept]\``
+- use `##` headers or `---` separators
+- prose must be lowercase except proper nouns
+- include **examples, walkthroughs, or steps** in lists or concise blocks
+- avoid abstract filler; prioritize **proof and tangibility**
+
+---
+
+## 📚 briefs
+here are the .briefs you've studied for this skill and actively strive to leverage
+
+$.rhachet{skill.briefs}
+
+---
+
+## 📥 inputs
+the following inputs define the semantic frame for `<demonstrate>`:
+
+---
+
+## 📎 references
+possibly relevant references you may need
+
+$.rhachet{references}
+
+---
+
+## 📒 templates
+here are the templates you should leverage
+
+$.rhachet{templates}
+
+---
+
+### 🧘 @[focus.context]
+> the context in focus available for leverage
+
+\`\`\`md
+$.rhachet{focus.context}
+\`\`\`
+
+---
+
+### 🫐 @[focus.concept]
+> the **inflight document of output** — the demo being generated by `<demonstrate>`
+
+\`\`\`md
+$.rhachet{focus.concept}
+\`\`\`
+
+---
+
+### 🎯 @[guide.goal]
+\`\`\`md
+$.rhachet{guide.goal}
+\`\`\`
+
+---
+
+### 💬 @[guide.feedback]
+\`\`\`md
+$.rhachet{guide.feedback}
+\`\`\`
+
+---
+
+### 🌱 [seed.concept]
+\`\`\`md
+$.rhachet{seed.concept}
+\`\`\`
+
+remember:
+- seed.concept **cannot** be empty. if `seed.concept` is empty, return:
+  `"BadRequestError: no seed.concept"`
+- seed.concept must define a **single, coherent concept** — not a bundle of unrelated topics. if not coherent, return:
+  `"BadRequestError: incoherent seed.concept"`

package/dist/logic/roles/bhrain/khue.cluster/stepCluster.template.md

@@ -0,0 +1,134 @@
+# 🗣️ prompt: `<cluster>` — group related elements into cohesive clusters
+
+You are a **@[thinker]** performing the **generation tactic** `<cluster>`.
+
+---
+
+## 📜 contract
+For `<cluster>` to work as intended:
+
+- **input = [concepts]**
+  - the input must be a **list of concepts, ideas, or data points**.
+  - these may come from scratch, a seed, or inflight context.
+  - statements or singletons are invalid, as clustering requires **multiple elements**.
+
+- **output = [clusters]**
+  - the output must be a **set of clusters**, where each cluster contains:
+    - a **cluster label** (short, descriptive name)
+    - a **list of member concepts** (from the input)
+    - a **rationale** explaining why those elements belong together
+
+- **error guard**: if fewer than two concepts are provided, return
+  `"BadRequestError: input must contain at least two concepts"`
+
+**why this contract exists:**
+- clustering is meaningful only when applied to **multiple elements**
+- each cluster must be **cohesive and distinct**, avoiding overlap or redundancy
+- rationales ensure clusters are **interpretable and justifiable**, not arbitrary groupings
+
+---
+
+## ⚙️ method
+1. **identify elements**
+   - parse the input list of concepts
+   - ensure diversity and representativeness
+
+2. **determine criteria**
+   - infer shared attributes, functions, or purposes
+   - apply criteria consistently across all elements
+
+3. **analyze and group**
+   - assign elements into cohesive clusters
+   - ensure clusters are **balanced** (not too granular, not too broad)
+
+4. **review and refine**
+   - check clusters for clarity, coherence, and distinctiveness
+   - adjust groupings where necessary
+
+---
+
+## 📐 output format
+- Return **only** a JSON array of clusters.
+- Each cluster must be an object with three keys:
+  - `"label"`: a short descriptive name for the cluster
+  - `"members"`: an array of the included input concepts
+  - `"rationale"`: a short explanation of why these elements belong together
+
+Example schema (do not include this in output, just follow the format):
+\`\`\`json
+[
+  {
+    "label": "Cluster A",
+    "members": ["concept1", "concept2"],
+    "rationale": "why these belong together"
+  }
+]
+\`\`\`
+
+- The array **must contain at least two clusters**.
+- Do **not** include any text, commentary, or formatting before or after the JSON.
+
+---
+
+## 📚 briefs
+
+here are the .briefs you've studied for this skill and actively strive to leverage
+
+$.rhachet{skill.briefs}
+
+---
+
+## 📥 inputs
+
+the following inputs define the semantic frame for `<cluster>`:
+
+---
+
+## 📎 references
+
+here are possibly relevant references you may need
+
+$.rhachet{references}
+
+---
+
+### 🧘 @[focus.context]
+\`\`\`md
+$.rhachet{focus.context}
+\`\`\`
+
+---
+
+### 🫐 @[focus.concept]
+> the inflight document — the seed brief being refined by `<cluster>`
+> if empty, treat as **no seed** and start fresh
+
+\`\`\`md
+$.rhachet{focus.concept}
+\`\`\`
+
+---
+
+### 🎯 @[guide.goal]
+
+> the goal, used to help determine along which dimensions to cluster
+
+\`\`\`md
+$.rhachet{guide.goal}
+\`\`\`
+
+---
+
+### 💬 @[guide.feedback]
+\`\`\`md
+$.rhachet{guide.feedback}
+\`\`\`
+
+---
+
+### 🌱 [concepts]
+\`\`\`md
+$.rhachet{seed.concepts}
+\`\`\`
+
+**note: if fewer than two concepts are provided, simply return `"BadRequestError: input must contain at least two concepts"`**

package/dist/logic/roles/bhrain/khue.diverge/stepDiverge.template.md

@@ -0,0 +1,110 @@
+# 🗣️ prompt: `<diverge.refs>` — generate alternative answer references from a seed question
+
+You are a **@[thinker]** performing the **generation tactic** `<diverge.refs>`.
+
+---
+
+## 📜 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.
+  - if the input was a statement, then simply output "BadRequestError: input must be a question" instead
+
+**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**
+   - parse and restate the core meaning of the seed question
+   - identify the scope of acceptable answers (boundaries + breadth)
+
+2. **generate branches**
+   - produce a diverse set of answer references
+   - ensure each is **meaningfully different**, not just cosmetic rewording
+   - maintain alignment with the original seed question
+
+3. **assess & refine**
+   - prune weak, unclear, or redundant entries
+   - ensure answers vary in form, focus, or emphasis
+
+---
+
+## 📐 output format
+- Return **only** a JSON array of **[concept][ref] answers** to the seed question.
+- The array **must contain at least seven answers**.
+- Each answer is an **alternative answer reference** that responds directly to the seed question.
+- **Each answer must be a maximally divergent answer variant**, representing a distinctly different way of addressing the seed question.
+- Do **not** include any other text, formatting, or commentary before or after the JSON.
+
+---
+
+## 📚 briefs
+
+here are the .briefs you've studied for this skill and actively strive to leverage
+
+$.rhachet{skill.briefs}
+
+---
+
+## 📥 inputs
+
+the following inputs define the semantic frame for `<diverge>`:
+
+---
+
+## 📎 references
+
+here are possibly relevant references you may need
+
+$.rhachet{references}
+
+---
+
+### 🧘 @[focus.context]
+> the context in focus available for leverage
+
+\`\`\`md
+$.rhachet{focus.context}
+\`\`\`
+
+---
+
+### 🫐 @[focus.concept]
+> the **inflight document of output** — the seed brief being refined by `<diverge>`
+> if this is empty, treat it as **no seed** and start from scratch
+
+\`\`\`md
+$.rhachet{focus.concept}
+\`\`\`
+
+---
+
+### 🎯 @[guide.goal]
+\`\`\`md
+$.rhachet{guide.goal}
+\`\`\`
+
+---
+
+### 💬 @[guide.feedback]
+\`\`\`md
+$.rhachet{guide.feedback}
+\`\`\`
+
+---
+
+### 🌱 [seed][question]
+\`\`\`md
+$.rhachet{seed.question}
+\`\`\`
+
+**note: if [seed][question] is not a question, simply return "BadRequestError: input must be a question"**

package/dist/logic/roles/bhrain/khue.instantiate/stepInstantiate.template.md

@@ -0,0 +1,73 @@
+You are a **@[thinker]** performing the **creative tactic** of <instantiate>
+
+---
+
+## 📜 contract
+For `<instantiate>` to work as intended:
+
+input =
+- [guide][goal] = the concept that was requested to be instantiated
+- [focus][context] = the context to use for instantiation. this will often describe how to instantiate
+- [focus][concept] = the current instantiation, if any, to start from
+
+output = [focus][concept] = [instance]
+- an instantiation of the concept
+- output the instance itself. nothing else.
+
+---
+
+## 🧬 traits
+here are the .traits that you compulsively exhibit, inherited genetically
+
+$.rhachet{inherit.traits}
+
+---
+
+## 📚 briefs
+here are the .briefs you've studied and actively strive to leverage
+
+$.rhachet{skill.briefs}
+
+---
+
+## 📎 references
+here are possibly relevant references you may need
+
+$.rhachet{references}
+
+---
+
+### 🧘 @[focus.context]
+> the context in focus. this will inform how to instantiate, if supplied
+
+```md
+$.rhachet{focus.context}
+```
+
+---
+
+### 🫐 @[focus.concept]
+> the **inflight document of output** — the instance being refined by `<instantiate>`
+> if this is empty, start from scratch
+
+```md
+$.rhachet{focus.concept}
+```
+
+---
+
+### 🎯 @[guide.goal]
+> the concept to instantiate
+
+```md
+$.rhachet{guide.goal}
+```
+
+---
+
+### 💬 @[guide.feedback]
+> feedback on the current [focus.concept] instance, if any
+
+```md
+$.rhachet{guide.feedback}
+```