@seanhogg/builderforce-memory 2026.6.35 → 2026.7.11

package/src/workflow/templates.ts

@@ -69,7 +69,73 @@ export const TRAIN_LLM: WorkflowConfig = {
   ],
 };
 
-export const WORKFLOW_TEMPLATES: WorkflowConfig[] = [AGENTIC_SEVEN_LAYER, TRAIN_LLM];
+/**
+ * Out-of-the-box (prompt → code) exemplars so "Teach Evermind to Code" runs with
+ * no network. Each carries execution `cases` so the same best-of-N / exec-filter
+ * path a live run uses is exercised offline (an exemplar whose code fails its
+ * cases is dropped, never trained on).
+ *
+ * A real run instead sets a teacher PANEL on the `distill-corpus` step —
+ * `teachers: [{provider:"anthropic", model:"claude-opus-4-8", apiKey},
+ *             {provider:"openai", baseUrl:<gateway>, model:<coder>, apiKey}]`
+ * (strongest first) — plus `tasks: [{prompt, cases}]`. Per task every teacher is
+ * queried, only completions that PASS the cases survive, and the strongest
+ * correct answer is kept: Opus is the authority, cheaper models contribute only
+ * where they are verifiably right.
+ */
+const CODE_DISTILL_PAIRS = [
+  { prompt: "Write a JS function add(a, b) that returns their sum.", completion: "function add(a, b) {\n  return a + b;\n}", cases: [{ call: "add(2, 3)", expect: 5 }] },
+  { prompt: "Write a JS function isEven(n) that returns true when n is even.", completion: "function isEven(n) {\n  return n % 2 === 0;\n}", cases: [{ call: "isEven(4)", expect: true }, { call: "isEven(7)", expect: false }] },
+  { prompt: "Write a JS function max(a, b) returning the larger value.", completion: "function max(a, b) {\n  return a > b ? a : b;\n}", cases: [{ call: "max(2, 9)", expect: 9 }] },
+  { prompt: "Write a JS function reverse(s) that reverses a string.", completion: "function reverse(s) {\n  return s.split('').reverse().join('');\n}", cases: [{ call: "reverse('abc')", expect: "cba" }] },
+  { prompt: "Write a JS function clamp(x, lo, hi) bounding x to [lo, hi].", completion: "function clamp(x, lo, hi) {\n  return Math.min(hi, Math.max(lo, x));\n}", cases: [{ call: "clamp(12, 0, 10)", expect: 10 }] },
+  { prompt: "Write a JS function sum(xs) that adds an array of numbers.", completion: "function sum(xs) {\n  return xs.reduce((a, b) => a + b, 0);\n}", cases: [{ call: "sum([1, 2, 3])", expect: 6 }] },
+];
+
+/**
+ * Teach Evermind to Code — the foundation pipeline for the coding skill.
+ *
+ * Distil a PANEL of teacher coders — Opus as the authority plus any cheaper
+ * models (gateway/OpenRouter/local) — into an execution-verified (prompt → code)
+ * corpus (best-of-N: only completions that pass their tests survive), learn a
+ * code tokenizer (train fresh by default; set `hfTokenizerUrl` on the tokenizer
+ * step to import merges from a proven code tokenizer instead), train the model,
+ * and gate it with the standard convergence/benchmark checks PLUS code-specific
+ * ones: structural/parse validity and an execution-grounded test reward.
+ *
+ * The code gates ship report-only (no thresholds) so the template completes and
+ * surfaces metrics; a real run sets `minScore` / `minPassRate` to enforce them.
+ */
+export const TEACH_CODE: WorkflowConfig = {
+  id: "teach-code",
+  name: "Teach Evermind to Code",
+  description:
+    "Distil a teacher coder into a (prompt → code) corpus, train an EvermindLM on it, and validate with code-aware gates: structural parse + an execution test reward. Tokenizer supports both train-fresh and import-merges.",
+  steps: [
+    { id: "distill", type: "distill-corpus", params: { pairs: CODE_DISTILL_PAIRS } },
+    { id: "tok", type: "train-tokenizer", params: { numMerges: 200 } },
+    { id: "data", type: "dataset-quality", params: { minSequences: 3, minWords: 20 } },
+    { id: "model", type: "train-model", params: { epochs: 60, dModel: 24, numLayers: 2, hiddenDim: 32 } },
+    { id: "converge", type: "convergence" },
+    { id: "eval", type: "evaluate", params: { prompt: "function" } },
+    { id: "gen", type: "generate-check", params: { prompt: "function" } },
+    { id: "parse", type: "code-parse-check", params: { language: "js" } },
+    { id: "reward", type: "code-eval", params: { cases: [{ call: "add(2, 3)", expect: 5 }] } },
+    { id: "bench", type: "benchmark" },
+    // Held-out pass@1 — measures whether the student can GENERATE passing code on
+    // unseen prompts (symmetric with `bench`'s held-out perplexity). Ungated here
+    // (a demo-scale model won't pass) so it reports the metric without failing the
+    // pipeline; real corpora set `minPass1` to enforce a student-quality floor.
+    { id: "codebench", type: "code-benchmark", params: { tasks: [
+      { prompt: "function subtract", cases: [{ call: "subtract(5, 2)", expect: 3 }] },
+      { prompt: "function isEven", cases: [{ call: "isEven(4)", expect: true }, { call: "isEven(3)", expect: false }] },
+    ] } },
+    { id: "pkg", type: "roundtrip", params: { name: "evermind-coder" } },
+    { id: "export", type: "export", params: { format: "huggingface", name: "evermind-coder", version: "1.0.0" } },
+  ],
+};
+
+export const WORKFLOW_TEMPLATES: WorkflowConfig[] = [AGENTIC_SEVEN_LAYER, TRAIN_LLM, TEACH_CODE];
 
 export function getTemplate(id: string): WorkflowConfig | undefined {
   return WORKFLOW_TEMPLATES.find((t) => t.id === id);