rhachet-roles-ehmpathy 1.1.0 → 1.2.0

package/dist/logic/roles/bhrain/.briefs/worders/knowledge.internalized.[demo].artist.md

@@ -0,0 +1,36 @@
+# 🧩 .brief.demo: `style transfer for internalized knowledge`
+
+---
+
+## 🎨 essence of the frame
+style transfer highlights how exposure to repeated patterns (in art, language, or reasoning) becomes **internalized capacity** rather than **explicit recall**.
+- the artist does not carry a mental library of every impressionist canvas.
+- instead, they have **absorbed the structure of impressionism**: how to layer colors, how to break light into strokes, how to balance softness with vibrancy.
+- this “knowledge” manifests not as stored facts but as *fluid capability* to reproduce and adapt style in new contexts.
+
+---
+
+## 🧠 mapping to llms
+- **training as exposure**
+  llms are exposed to vast corpora just as the artist is immersed in impressionist works. through gradient descent, the weights adapt to reflect these patterns.
+
+- **weights as embodiment**
+  the learned style of language — grammar, facts, idioms, reasoning steps — becomes embedded in the weight matrix. no individual weight is “the fact,” but the whole structure embodies it.
+
+- **generation as expression**
+  when prompted, the llm doesn’t “remember” training text. it **expresses** the internalized style of text it has absorbed, much like an artist expressing impressionism in a novel painting.
+
+---
+
+## 🔑 insights revealed
+- **knowledge ≈ style**: both are *latent patterns* embodied in a system’s structure.
+- **generalization over memorization**: an llm, like the artist, can apply its internalized patterns to situations it has never encountered before.
+- **creative reconstruction**: outputs are not reproductions of training data but reconstructions consistent with internalized distributions.
+- **hallucinations as byproduct**: just as an artist might invent an impressionist scene that never existed, llms may produce plausible but fabricated content.
+
+---
+
+## 📌 practical intuition
+- **teaching style**: explaining llm knowledge as *“style internalized in weights”* makes it clear that the model isn’t storing a database, but embodying a way of *expressing patterns*.
+- **limits of fidelity**: just as an artist cannot perfectly replicate a particular monet without copying, llms cannot guarantee perfect recall of a training fact.
+- **adaptability**: both can transfer their internalized style onto new subjects (artist painting a modern skyline; llm generating in a new domain).

package/dist/logic/roles/bhrain/.briefs/worders/knowledge.internalized.[demo].neural.md

@@ -0,0 +1,37 @@
+# 🧩 .brief.demo: `internalized knowledge in llm weights — neural memory frame`
+
+---
+
+## 🧠 demonstration
+
+imagine recalling the fact: **“paris is the capital of france.”**
+in a human brain, there is no single neuron labeled “capital of france.” instead:
+
+- thousands of neurons encode fragments — sounds, associations, map images, cultural cues.
+- when prompted, these neurons fire in **coordinated patterns** that reconstruct the memory.
+- the *pattern of activation* is the knowledge, not any one unit.
+
+---
+
+## 🔗 llm parallel
+
+- llm weights work the same way:
+  - no parameter contains “paris = france’s capital.”
+  - instead, billions of weights together create a high-dimensional pattern that *activates* when the model sees a related cue.
+  - output emerges from **distributed representations** aligning to the prompt.
+
+---
+
+## 📊 implications
+
+- **not a database** — knowledge isn’t stored as discrete rows or entries.
+- **probabilistic recall** — outputs can vary depending on context, like humans remembering fuzzily.
+- **generalization** — internalized patterns allow extrapolation beyond explicit memorization.
+
+---
+
+## ⚖️ takeaway
+
+just as human memory is **patterned activation** rather than a single storage cell,
+llm knowledge is **internalized in distributed weight patterns**,
+reconstructed dynamically when queried.

package/dist/logic/roles/bhrain/.briefs/worders/knowledge.internalized.[demo].pianist.md

@@ -0,0 +1,34 @@
+# 🧩 .brief.demo: `internalized knowledge in llm weights — muscle memory frame`
+
+---
+
+## 🏋️‍♂️ demonstration
+
+imagine a pianist sitting at the keyboard:
+- their fingers glide through a complex sonata without consciously recalling each individual note.
+- the *knowledge of the music* isn’t stored as a verbal list of notes in their mind — it is internalized in the coordination of muscles and neural circuits.
+- when prompted with the opening bars, the full sequence flows out through trained patterns.
+
+---
+
+## 🔑 intuition
+
+- **distributed**: no single muscle or neuron “contains” the sonata — it is spread across the system.
+- **implicit**: the pianist cannot always verbalize *how* they play; the knowledge is enacted, not explicitly recalled.
+- **emergent**: repeated practice shapes a network of pathways that allow fluent performance.
+
+---
+
+## 📊 mapping to llms
+
+- llm weights = the pianist’s trained muscles and neural pathways
+- prompts = the opening bars that trigger the sequence
+- completions = the flowing music generated from internalized patterns
+- internalized knowledge = the capacity to recall and generalize without explicit storage of “facts”
+
+---
+
+## ⚖️ takeaway
+
+just as a pianist embodies a song in trained muscle memory, llms embody world knowledge in their parameters.
+- both systems *don’t remember every detail explicitly* — instead, they perform by drawing on **internalized, distributed patterns** of practice.

package/dist/logic/roles/bhrain/.briefs/worders/limits.rhyme.md

@@ -0,0 +1,46 @@
+# 🧩 .brief: `llm ability to understand rhyme`
+
+## 🔑 what it implies
+
+since each token starts as a static embedding but then diverges into contextual hidden states, rhyme is not encoded in the hidden state by default — it has to be learned through patterns across embeddings and contexts.
+
+rhyme is about **phonological similarity** (shared suffix sounds). llms don’t hear sounds; they see tokens. so:
+
+- if the tokenizer splits words like “cat” and “hat” into full tokens, then their embeddings might end up closer in vector space because they co-occur in similar phonetic/poetic training data.
+- if the tokenizer breaks words into subwords, e.g. “##at”, rhyme similarity is captured more directly (both “cat” and “hat” share the suffix embedding).
+- during self-attention, heads could learn to connect tokens with similar endings, especially in rhyme-heavy text (poetry, song lyrics). this would look a lot like the “bank” demo: two different tokens forming stronger similarity in some heads because of shared suffix representations.
+
+---
+
+## 🎯 implications for rhyme recognition
+
+- **subword overlap**
+  - if the tokenizer preserves suffix chunks (`-at`, `-ight`), rhyme is easier.
+  - embeddings for those suffixes can become strong cues.
+
+- **attention heads**
+  - some heads may specialize in form-based similarity (orthographic/phonetic).
+  - others focus on semantics or syntax.
+  - multi-head attention enables parallel “views”: one could be capturing rhymes while another tracks meaning.
+
+- **disambiguation vs rhyme**
+  - in the “bank” case, heads attend differently to disambiguate meaning.
+  - in rhyme, heads might attend similarly across different words, reinforcing their phonetic link regardless of semantics.
+
+---
+
+## 🧩 example
+
+> “the **cat** wore a funny **hat**.”
+
+- **embeddings:** “cat” ≠ “hat,” but both contain suffix “-at.”
+- **hidden states:** self-attention might increase similarity because the q of “cat” matches the k of “hat” in a rhyme-sensitive head.
+- **value vectors:** both updated to reflect “these words rhyme.”
+
+---
+
+## 📊 insight
+
+- llms don’t have an innate sense of sound, but **subword embeddings + attention** let them approximate rhyme by picking up on visual/orthographic patterns.
+- rhyme perception is therefore **statistical, not phonological** — it depends on the tokenizer and training data distribution.
+- but the mechanism is parallel to disambiguating “bank”: attention binds tokens through **learned similarity in q/k space.**

package/dist/logic/roles/bhrain/.briefs/worders/limits.spell.md

@@ -0,0 +1,49 @@
+# 🧩 .brief: `llm ability to spell`
+
+## 🔑 what it implies
+
+since each token starts as a **static embedding** and spelling is distributed across subwords, an llm’s ability to spell is **not innate** but emerges from:
+
+- the **tokenizer**: if words are whole tokens, the model never “sees” individual letters, so it can only memorize spelling patterns for known words.
+- if the tokenizer breaks words into **character-like subwords**, the model can generalize spelling more flexibly (assemble words from parts).
+- **contextual hidden states**: spelling consistency isn’t reinforced the same way semantics or rhyme are. most training data emphasizes meaning, not orthographic correctness.
+- **self-attention**: heads may capture common letter/suffix chunks, but nothing forces them to maintain letter-by-letter accuracy unless trained specifically (e.g., code models, spelling correction).
+
+---
+
+## 🎯 implications for spelling ability
+
+- **memorization over generation**
+  - llms can reproduce spellings they’ve seen often.
+  - rare or novel words are harder because embeddings don’t break down fully into letters.
+
+- **tokenizer bias**
+  - byte-pair encodings (bpe) bias toward common subwords, not individual letters.
+  - spelling errors occur when tokenization splits a word into unusual or unseen chunks.
+
+- **generalization**
+  - some subword overlap allows limited spelling generalization (e.g., “##tion,” “##ing”).
+  - but full orthographic rules are weak unless trained at character level.
+
+- **multi-head dynamics**
+  - some heads may track morpheme or suffix consistency.
+  - others prioritize syntax or semantics, so spelling accuracy is not their focus.
+
+---
+
+## 🧩 example
+
+> generating “pharaoh”
+
+- **embedding level:** tokenization may split as `[“ph”, “ara”, “oh”]` or something arbitrary.
+- **hidden state evolution:** model predicts plausible continuation from context but may choose an alternate form (“pharoah”) if that variant appears in data.
+- **output:** correct spelling depends on frequency balance in training data, not explicit rules.
+
+---
+
+## 📊 insight
+
+- llms **do not inherently know spelling rules** — they approximate them statistically from text distributions.
+- good spelling emerges in proportion to **training data quality and tokenizer granularity**.
+- unlike rhyme (which can be reinforced by subword overlaps), spelling requires **fine-grained character awareness**, which many tokenizers blur.
+- in short: **llms spell by memory and pattern frequency, not by rule.**

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

@@ -0,0 +1,28 @@
+# 📊 effectiveness of teaching llms via example libraries
+
+## ✅ strengths
+- **highly effective for style & format control**
+  - the model will reliably mimic demonstrated structures (e.g. JSON schema, markdown brief, SQL pattern).
+- **task-specific alignment**
+  - if the examples cover the distribution of tasks, the model adapts very well in-session.
+- **fast & flexible**
+  - no retraining, just update the example set.
+
+---
+
+## ⚠️ limits
+- **shallow generalization**
+  - effectiveness drops if the input strays outside what the examples illustrate.
+- **rigid mimicry**
+  - the model tends to overfit: it copies examples rather than abstracting.
+- **context overhead**
+  - effectiveness shrinks as the example library grows beyond the model’s active attention window.
+- **no persistence**
+  - nothing is learned across sessions — you must re-teach every time.
+
+---
+
+## 🎯 bottom line
+- **short tasks, narrow domains:** very effective.
+- **broad reasoning, novel domains:** much less effective.
+- think of it as *teaching the llm to “act trained”* for one prompt — not actual durable learning.

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.d.ts

@@ -0,0 +1,61 @@
+import { GStitcher, Threads, RoleContext } from 'rhachet';
+import { Artifact } from 'rhachet-artifact';
+import { GitFile } from 'rhachet-artifact-git';
+import { Focus } from '../../../../_topublish/rhachet-roles-bhrain/src/domain/objects/Focus';
+import { ContextOpenAI } from '../../../../data/sdk/sdkOpenAi';
+export declare const BRIEFS_FOR_ARTICULATE: Artifact<typeof GitFile, string>[];
+type StitcherDesired = GStitcher<Threads<{
+    caller: RoleContext<'caller', {
+        ask: string;
+        art: {
+            feedback: Artifact<typeof GitFile>;
+            'foci.goal.concept': Focus['concept'];
+            'foci.goal.context': Focus['context'];
+            templates: Artifact<typeof GitFile>[];
+        };
+        refs: Artifact<typeof GitFile>[];
+    }>;
+    thinker: RoleContext<'thinker', {
+        art: {
+            'focus.concept': Focus['concept'];
+            'focus.context': Focus['context'];
+            'foci.ponder.ans.concept': Focus['concept'];
+        };
+        briefs: Artifact<typeof GitFile>[];
+    }>;
+}>, ContextOpenAI & GStitcher['context'], {
+    content: string;
+}>;
+export declare const stepArticulate: import("rhachet").Stitcher<StitcherDesired>;
+export declare const loopArticulate: import("rhachet").Stitcher<GStitcher<Threads<{
+    caller: RoleContext<"caller", {
+        ask: string;
+        art: {
+            feedback: Artifact<typeof GitFile>;
+            'foci.goal.concept': Focus['concept'];
+            'foci.goal.context': Focus['context'];
+            templates: Artifact<typeof GitFile>[];
+        };
+        refs: Artifact<typeof GitFile>[];
+    } & {
+        ask: string;
+        art: {
+            feedback: Artifact<typeof GitFile, string>;
+        };
+    }>;
+    thinker: RoleContext<"thinker", {
+        art: {
+            'focus.concept': Focus['concept'];
+            'focus.context': Focus['context'];
+            'foci.ponder.ans.concept': Focus['concept'];
+        };
+        briefs: Artifact<typeof GitFile>[];
+    } & {
+        art: {
+            "focus.concept": Artifact<typeof GitFile, string>;
+        };
+    }>;
+}>, ContextOpenAI & import("simple-log-methods").ContextLogTrail & import("rhachet").ContextStitchTrail, {
+    feedback: GitFile | null;
+}>>;
+export {};

package/dist/logic/roles/bhrain/brief.articulate/stepArticulate.integration.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uni_time_1 = require("@ehmpathy/uni-time");
+const rhachet_1 = require("rhachet");
+const rhachet_artifact_git_1 = require("rhachet-artifact-git");
+const test_fns_1 = require("test-fns");
+const genContextLogTrail_1 = require("../../../../.test/genContextLogTrail");
+const genContextStitchTrail_1 = require("../../../../.test/genContextStitchTrail");
+const getContextOpenAI_1 = require("../../../../.test/getContextOpenAI");
+const getBhrainBrief_1 = require("../getBhrainBrief");
+const stepArticulate_1 = require("./stepArticulate");
+jest.setTimeout((0, uni_time_1.toMilliseconds)({ minutes: 5 }));
+describe('stepArticulate', () => {
+    const context = {
+        ...(0, genContextLogTrail_1.genContextLogTrail)(),
+        ...(0, genContextStitchTrail_1.genContextStitchTrail)(),
+        ...(0, getContextOpenAI_1.getContextOpenAI)(),
+    };
+    const route = stepArticulate_1.stepArticulate;
+    const goal = `
+articulate the term "joke"; declare both the etymology and definition; include examples
+  `.trim();
+    const artifacts = {
+        caller: {
+            feedback: (0, rhachet_artifact_git_1.genArtifactGitFile)({ uri: __dirname + '/.temp/stepArticulate/caller.feedback.md' }, { versions: true }),
+            'foci.goal.concept': (0, rhachet_artifact_git_1.genArtifactGitFile)({
+                uri: __dirname + '/.temp/stepArticulate/caller.foci.goal.concept.md',
+            }, { versions: true }),
+            'foci.goal.context': (0, rhachet_artifact_git_1.genArtifactGitFile)({
+                uri: __dirname + '/.temp/stepArticulate/caller.foci.goal.context.md',
+            }, { versions: true }),
+        },
+        thinker: {
+            'focus.concept': (0, rhachet_artifact_git_1.genArtifactGitFile)({ uri: __dirname + '/.temp/stepArticulate/thinker.focus.concept.md' }, { versions: true }),
+            'focus.context': (0, rhachet_artifact_git_1.genArtifactGitFile)({ uri: __dirname + '/.temp/stepArticulate/thinker.focus.context.md' }, { versions: true }),
+            'foci.ponder.ans.concept': (0, rhachet_artifact_git_1.genArtifactGitFile)({
+                uri: __dirname +
+                    '/.temp/stepArticulate/thinker.foci.ponder.ans.concept.md',
+            }, { versions: true }),
+        },
+    };
+    (0, test_fns_1.given)('we want to articulate term joke', () => {
+        beforeEach(async () => {
+            await artifacts.caller.feedback.set({ content: '' });
+            await artifacts.caller['foci.goal.concept'].set({ content: goal });
+            await artifacts.thinker['focus.context'].set({
+                content: ['psychology', 'evolution', 'ecology'].join('\n'),
+            });
+            await artifacts.thinker['focus.concept'].set({
+                content: [].join('\n'),
+            });
+        });
+        (0, test_fns_1.when)('executed', () => {
+            const threads = (0, test_fns_1.usePrep)(async () => ({
+                caller: await (0, rhachet_1.enrollThread)({
+                    role: 'caller',
+                    stash: {
+                        ask: goal,
+                        art: {
+                            'foci.goal.concept': artifacts.caller['foci.goal.concept'],
+                            'foci.goal.context': artifacts.caller['foci.goal.context'],
+                            feedback: artifacts.caller.feedback,
+                            templates: [],
+                        },
+                        refs: [],
+                    },
+                }),
+                thinker: await (0, rhachet_1.enrollThread)({
+                    role: 'thinker',
+                    stash: {
+                        art: {
+                            'focus.context': artifacts.thinker['focus.context'],
+                            'focus.concept': artifacts.thinker['focus.concept'],
+                            'foci.ponder.ans.concept': artifacts.thinker['foci.ponder.ans.concept'],
+                        },
+                        briefs: [],
+                    },
+                    inherit: {
+                        traits: (0, getBhrainBrief_1.getBhrainBriefs)(['trait.ocd.md']),
+                    },
+                }),
+            }));
+            (0, test_fns_1.then)('upserts the thinker output', async () => {
+                const result = await (0, rhachet_1.enweaveOneStitcher)({ stitcher: route, threads }, context);
+                console.log(JSON.stringify(result.stitch, null, 2));
+                console.log(artifacts);
+                console.log(artifacts.thinker['focus.concept']);
+                const { content } = await artifacts.thinker['focus.concept']
+                    .get()
+                    .expect('isPresent');
+                expect(content.toLowerCase()).toContain('joke');
+            });
+        });
+    });
+});
+//# sourceMappingURL=stepArticulate.integration.test.js.map

package/dist/logic/roles/bhrain/brief.articulate/stepArticulate.integration.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepArticulate.integration.test.js","sourceRoot":"","sources":["../../../../../src/logic/roles/bhrain/brief.articulate/stepArticulate.integration.test.ts"],"names":[],"mappings":"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"}

package/dist/logic/roles/bhrain/brief.articulate/stepArticulate.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loopArticulate = exports.stepArticulate = exports.BRIEFS_FOR_ARTICULATE = void 0;
+const helpful_errors_1 = require("helpful-errors");
+const rhachet_1 = require("rhachet");
+const wrapper_fns_1 = require("wrapper-fns");
+const sdkOpenAi_1 = require("../../../../data/sdk/sdkOpenAi");
+const genLoopFeedback_1 = require("../../../artifact/genLoopFeedback");
+const genStepArtSet_1 = require("../../../artifact/genStepArtSet");
+const getBhrainBrief_1 = require("../getBhrainBrief");
+// exported so that we can pass them through to <ponder> too
+exports.BRIEFS_FOR_ARTICULATE = (0, getBhrainBrief_1.getBhrainBriefs)([
+    'trait.ocd.md',
+    'cognition/cog401.questions.._.md',
+    'cognition/cog000.overview.and.premise.md',
+    'cognition/cog101.concept.treestruct._.md',
+    'cognition/cog201.cortal.focus.p1.definition.md',
+    'cognition/cog301.traversal.1.motion.primitives._.md',
+    'cognition/cog401.questions.._.md',
+    'cognition/cog401.questions.2.1.primitives.rough._.md',
+    'cognition/cog201.cortal.focus.p2.acuity.md',
+    'cognition/cog301.traversal.1.motion.primitives.acuity.md',
+    'librarian.tactics/[brief].verbiage.outline.over.narrative.md',
+    'librarian.tactics/<articulate>._.[article].frame.cognitive.md',
+    'librarian.tactics/<articulate>._.[article].frame.tactical.md',
+    'librarian.tactics/<articulate>.tactic.[catalog].md',
+    'librarian.tactics/<articulate>.tactic.concept_dimension.examples.[article][seed].md',
+    'librarian.tactics/<articulate>.tactic.concept_dimension.invariants.[article].md',
+    'librarian.tactics/<articulate>.tactic.from.examples.md',
+    'librarian.tactics/<articulate>.tactic.from.seed.md',
+    'librarian.tactics/<articulate>.tactic.with.templates.[article].md',
+    'librarian.tactics/<articulate>.tone.bluecollar.[article][seed].md', // todo: review this
+]);
+const template = (0, rhachet_1.genTemplate)({
+    ref: { uri: __filename.replace('.ts', '.template.md') },
+    getVariables: async ({ threads }) => ({
+        ...(await (0, rhachet_1.getTemplateVarsFromRoleInherit)({ thread: threads.thinker })),
+        guide: {
+            goal: (await threads.caller.context.stash.art['foci.goal.concept'].get())
+                ?.content ||
+                helpful_errors_1.UnexpectedCodePathError.throw('goal not declared', {
+                    art: threads.caller.context.stash.art['foci.goal.concept'],
+                }),
+            feedback: (await threads.caller.context.stash.art.feedback.get())?.content || '',
+        },
+        focus: {
+            context: (await threads.thinker.context.stash.art['focus.context'].get())
+                ?.content ||
+                (await threads.caller.context.stash.art['foci.goal.context'].get()) // fallback to @[caller].focus[goal].context
+                    ?.content ||
+                '',
+            concept: (await threads.thinker.context.stash.art['focus.concept'].get())
+                ?.content || '',
+        },
+        ponderage: (await threads.thinker.context.stash.art['foci.ponder.ans.concept'].get())
+            ?.content || '',
+        templates: await (0, rhachet_1.getTemplateValFromArtifacts)({
+            artifacts: [...threads.caller.context.stash.art.templates],
+        }),
+        skill: {
+            briefs: await (0, rhachet_1.getTemplateValFromArtifacts)({
+                artifacts: [
+                    ...exports.BRIEFS_FOR_ARTICULATE,
+                    ...threads.thinker.context.stash.briefs,
+                ],
+            }),
+        },
+        references: await (0, rhachet_1.getTemplateValFromArtifacts)({
+            artifacts: threads.caller.context.stash.refs,
+        }),
+    }),
+});
+const stepImagine = (0, rhachet_1.genStepImagineViaTemplate)({
+    slug: '@[thinker]<articulate>',
+    stitchee: 'thinker',
+    readme: '',
+    template,
+    imagine: (0, wrapper_fns_1.withRetry)((0, wrapper_fns_1.withTimeout)(sdkOpenAi_1.sdkOpenAi.imagine, { threshold: { seconds: 60 } })),
+});
+const stepPersist = (0, genStepArtSet_1.genStepArtSet)({
+    stitchee: 'thinker',
+    artee: 'focus.concept',
+});
+exports.stepArticulate = (0, rhachet_1.asStitcherFlat)((0, rhachet_1.genStitchRoute)({
+    slug: '@[thinker]<articulate>',
+    readme: '@[thinker]<articulate> -> [article]',
+    sequence: [stepImagine, stepPersist],
+}));
+exports.loopArticulate = (0, genLoopFeedback_1.genLoopFeedback)({
+    stitchee: 'thinker',
+    artee: 'focus.concept',
+    repeatee: exports.stepArticulate,
+});
+//# sourceMappingURL=stepArticulate.js.map

package/dist/logic/roles/bhrain/brief.articulate/stepArticulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepArticulate.js","sourceRoot":"","sources":["../../../../../src/logic/roles/bhrain/brief.articulate/stepArticulate.ts"],"names":[],"mappings":";;;AAAA,mDAAyD;AACzD,qCAUiB;AAGjB,6CAAqD;AAGrD,8DAA0E;AAC1E,uEAAoE;AACpE,mEAAgE;AAChE,sDAAoD;AAEpD,4DAA4D;AAC/C,QAAA,qBAAqB,GAAG,IAAA,gCAAe,EAAC;IACnD,cAAc;IACd,kCAAkC;IAClC,0CAA0C;IAC1C,0CAA0C;IAC1C,gDAAgD;IAChD,qDAAqD;IACrD,kCAAkC;IAClC,sDAAsD;IACtD,4CAA4C;IAC5C,0DAA0D;IAC1D,8DAA8D;IAC9D,+DAA+D;IAC/D,8DAA8D;IAC9D,oDAAoD;IACpD,qFAAqF;IACrF,iFAAiF;IACjF,wDAAwD;IACxD,oDAAoD;IACpD,mEAAmE;IACnE,mEAAmE,EAAE,oBAAoB;CAC1F,CAAC,CAAC;AAiCH,MAAM,QAAQ,GAAG,IAAA,qBAAW,EAA6B;IACvD,GAAG,EAAE,EAAE,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,cAAc,CAAC,EAAE;IACvD,YAAY,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;QACpC,GAAG,CAAC,MAAM,IAAA,wCAA8B,EAAC,EAAE,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAEtE,KAAK,EAAE;YACL,IAAI,EACF,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,GAAG,EAAE,CAAC;gBACjE,EAAE,OAAO;gBACX,wCAAuB,CAAC,KAAK,CAAC,mBAAmB,EAAE;oBACjD,GAAG,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,mBAAmB,CAAC;iBAC3D,CAAC;YACJ,QAAQ,EACN,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,IAAI,EAAE;SACzE;QAED,KAAK,EAAE;YACL,OAAO,EACL,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,GAAG,EAAE,CAAC;gBAC9D,EAAE,OAAO;gBACX,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,4CAA4C;oBAC9G,EAAE,OAAO;gBACX,EAAE;YACJ,OAAO,EACL,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,GAAG,EAAE,CAAC;gBAC9D,EAAE,OAAO,IAAI,EAAE;SACpB;QAED,SAAS,EACP,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC,GAAG,EAAE,CAAC;YACxE,EAAE,OAAO,IAAI,EAAE;QAEnB,SAAS,EAAE,MAAM,IAAA,qCAA2B,EAAC;YAC3C,SAAS,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC;SAC3D,CAAC;QAEF,KAAK,EAAE;YACL,MAAM,EAAE,MAAM,IAAA,qCAA2B,EAAC;gBACxC,SAAS,EAAE;oBACT,GAAG,6BAAqB;oBACxB,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM;iBACxC;aACF,CAAC;SACH;QAED,UAAU,EAAE,MAAM,IAAA,qCAA2B,EAAC;YAC5C,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI;SAC7C,CAAC;KACH,CAAC;CACH,CAAC,CAAC;AAEH,MAAM,WAAW,GAAG,IAAA,mCAAyB,EAAkB;IAC7D,IAAI,EAAE,wBAAwB;IAC9B,QAAQ,EAAE,SAAS;IACnB,MAAM,EAAE,EAAE;IACV,QAAQ;IACR,OAAO,EAAE,IAAA,uBAAS,EAChB,IAAA,yBAAW,EAAC,qBAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,CAC/D;CACF,CAAC,CAAC;AAEH,MAAM,WAAW,GAAG,IAAA,6BAAa,EAAC;IAChC,QAAQ,EAAE,SAAS;IACnB,KAAK,EAAE,eAAe;CACvB,CAAC,CAAC;AAEU,QAAA,cAAc,GAAG,IAAA,wBAAc,EAC1C,IAAA,wBAAc,EAAC;IACb,IAAI,EAAE,wBAAwB;IAC9B,MAAM,EAAE,qCAAqC;IAC7C,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;CACrC,CAAC,CACH,CAAC;AAEW,QAAA,cAAc,GAAG,IAAA,iCAAe,EAAC;IAC5C,QAAQ,EAAE,SAAS;IACnB,KAAK,EAAE,eAAe;IACtB,QAAQ,EAAE,sBAAc;CACzB,CAAC,CAAC"}

package/dist/logic/roles/bhrain/brief.articulate/stepArticulate.skill.d.ts

@@ -0,0 +1,31 @@
+export declare const SKILL_ARTICULATE: import("rhachet").RoleSkill<import("rhachet").GStitcher<import("rhachet").Threads<{
+    caller: import("rhachet").RoleContext<"caller", {
+        ask: string;
+        art: {
+            feedback: import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+            'foci.goal.concept': import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+            'foci.goal.context': import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+            templates: import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>[];
+        };
+        refs: import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>[];
+    } & {
+        ask: string;
+        art: {
+            feedback: import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+        };
+    }>;
+    thinker: import("rhachet").RoleContext<"thinker", {
+        art: {
+            'focus.concept': import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+            'focus.context': import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+            'foci.ponder.ans.concept': import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+        };
+        briefs: import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>[];
+    } & {
+        art: {
+            "focus.concept": import("rhachet-artifact").Artifact<typeof import("rhachet-artifact-git").GitFile, string>;
+        };
+    }>;
+}>, import("../../../../data/sdk/sdkOpenAi").ContextOpenAI & import("simple-log-methods").ContextLogTrail & import("rhachet").ContextStitchTrail, {
+    feedback: import("rhachet-artifact-git").GitFile | null;
+}>>;