@evomap/evolver 1.31.0 → 1.32.2

package/src/gep/skillDistiller.js

@@ -1,15 +1,16 @@
 'use strict';
 
-var fs = require('fs');
-var path = require('path');
-var crypto = require('crypto');
-var paths = require('./paths');
-
-var DISTILLER_MIN_CAPSULES = parseInt(process.env.DISTILLER_MIN_CAPSULES || '10', 10) || 10;
-var DISTILLER_INTERVAL_HOURS = parseInt(process.env.DISTILLER_INTERVAL_HOURS || '24', 10) || 24;
-var DISTILLER_MIN_SUCCESS_RATE = parseFloat(process.env.DISTILLER_MIN_SUCCESS_RATE || '0.7') || 0.7;
-var DISTILLED_MAX_FILES = 12;
-var DISTILLED_ID_PREFIX = 'gene_distilled_';
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const paths = require('./paths');
+const learningSignals = require('./learningSignals');
+
+const DISTILLER_MIN_CAPSULES = parseInt(process.env.DISTILLER_MIN_CAPSULES || '10', 10) || 10;
+const DISTILLER_INTERVAL_HOURS = parseInt(process.env.DISTILLER_INTERVAL_HOURS || '24', 10) || 24;
+const DISTILLER_MIN_SUCCESS_RATE = parseFloat(process.env.DISTILLER_MIN_SUCCESS_RATE || '0.7') || 0.7;
+const DISTILLED_MAX_FILES = 12;
+const DISTILLED_ID_PREFIX = 'gene_distilled_';
 
 function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -18,7 +19,7 @@ function ensureDir(dir) {
 function readJsonIfExists(filePath, fallback) {
   try {
     if (!fs.existsSync(filePath)) return fallback;
-    var raw = fs.readFileSync(filePath, 'utf8');
+    const raw = fs.readFileSync(filePath, 'utf8');
     if (!raw.trim()) return fallback;
     return JSON.parse(raw);
   } catch (e) {
@@ -29,7 +30,7 @@ function readJsonIfExists(filePath, fallback) {
 function readJsonlIfExists(filePath) {
   try {
     if (!fs.existsSync(filePath)) return [];
-    var raw = fs.readFileSync(filePath, 'utf8');
+    const raw = fs.readFileSync(filePath, 'utf8');
     return raw.split('\n').map(function (l) { return l.trim(); }).filter(Boolean).map(function (l) {
       try { return JSON.parse(l); } catch (e) { return null; }
     }).filter(Boolean);
@@ -57,13 +58,13 @@ function readDistillerState() {
 
 function writeDistillerState(state) {
   ensureDir(path.dirname(distillerStatePath()));
-  var tmp = distillerStatePath() + '.tmp';
+  const tmp = distillerStatePath() + '.tmp';
   fs.writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf8');
   fs.renameSync(tmp, distillerStatePath());
 }
 
 function computeDataHash(capsules) {
-  var ids = capsules.map(function (c) { return c.id || ''; }).sort();
+  const ids = capsules.map(function (c) { return c.id || ''; }).sort();
   return crypto.createHash('sha256').update(ids.join('|')).digest('hex').slice(0, 16);
 }
 
@@ -71,40 +72,40 @@ function computeDataHash(capsules) {
 // Step 1: collectDistillationData
 // ---------------------------------------------------------------------------
 function collectDistillationData() {
-  var assetsDir = paths.getGepAssetsDir();
-  var evoDir = paths.getEvolutionDir();
+  const assetsDir = paths.getGepAssetsDir();
+  const evoDir = paths.getEvolutionDir();
 
-  var capsulesJson = readJsonIfExists(path.join(assetsDir, 'capsules.json'), { capsules: [] });
-  var capsulesJsonl = readJsonlIfExists(path.join(assetsDir, 'capsules.jsonl'));
-  var allCapsules = [].concat(capsulesJson.capsules || [], capsulesJsonl);
+  const capsulesJson = readJsonIfExists(path.join(assetsDir, 'capsules.json'), { capsules: [] });
+  const capsulesJsonl = readJsonlIfExists(path.join(assetsDir, 'capsules.jsonl'));
+  let allCapsules = [].concat(capsulesJson.capsules || [], capsulesJsonl);
 
-  var unique = new Map();
+  const unique = new Map();
   allCapsules.forEach(function (c) { if (c && c.id) unique.set(String(c.id), c); });
   allCapsules = Array.from(unique.values());
 
-  var successCapsules = allCapsules.filter(function (c) {
+  const successCapsules = allCapsules.filter(function (c) {
     if (!c || !c.outcome) return false;
-    var status = typeof c.outcome === 'string' ? c.outcome : c.outcome.status;
+    const status = typeof c.outcome === 'string' ? c.outcome : c.outcome.status;
     if (status !== 'success') return false;
-    var score = c.outcome && Number.isFinite(Number(c.outcome.score)) ? Number(c.outcome.score) : 1;
+    const score = c.outcome && Number.isFinite(Number(c.outcome.score)) ? Number(c.outcome.score) : 1;
     return score >= DISTILLER_MIN_SUCCESS_RATE;
   });
 
-  var events = readJsonlIfExists(path.join(assetsDir, 'events.jsonl'));
+  const events = readJsonlIfExists(path.join(assetsDir, 'events.jsonl'));
 
-  var memGraphPath = process.env.MEMORY_GRAPH_PATH || path.join(evoDir, 'memory_graph.jsonl');
-  var graphEntries = readJsonlIfExists(memGraphPath);
+  const memGraphPath = process.env.MEMORY_GRAPH_PATH || path.join(evoDir, 'memory_graph.jsonl');
+  const graphEntries = readJsonlIfExists(memGraphPath);
 
-  var grouped = {};
+  const grouped = {};
   successCapsules.forEach(function (c) {
-    var geneId = c.gene || c.gene_id || 'unknown';
+    const geneId = c.gene || c.gene_id || 'unknown';
     if (!grouped[geneId]) {
       grouped[geneId] = {
         gene_id: geneId, capsules: [], total_count: 0,
         total_score: 0, triggers: [], summaries: [],
       };
     }
-    var g = grouped[geneId];
+    const g = grouped[geneId];
     g.capsules.push(c);
     g.total_count += 1;
     g.total_score += (c.outcome && Number.isFinite(Number(c.outcome.score))) ? Number(c.outcome.score) : 0.8;
@@ -113,7 +114,7 @@ function collectDistillationData() {
   });
 
   Object.keys(grouped).forEach(function (id) {
-    var g = grouped[id];
+    const g = grouped[id];
     g.avg_score = g.total_count > 0 ? g.total_score / g.total_count : 0;
   });
 
@@ -131,8 +132,8 @@ function collectDistillationData() {
 // Step 2: analyzePatterns
 // ---------------------------------------------------------------------------
 function analyzePatterns(data) {
-  var grouped = data.grouped;
-  var report = {
+  const grouped = data.grouped;
+  const report = {
     high_frequency: [],
     strategy_drift: [],
     coverage_gaps: [],
@@ -142,26 +143,26 @@ function analyzePatterns(data) {
   };
 
   Object.keys(grouped).forEach(function (geneId) {
-    var g = grouped[geneId];
+    const g = grouped[geneId];
     if (g.total_count >= 5) {
-      var flat = [];
+      let flat = [];
       g.triggers.forEach(function (t) { if (Array.isArray(t)) flat = flat.concat(t); });
-      var freq = {};
-      flat.forEach(function (t) { var k = String(t).toLowerCase(); freq[k] = (freq[k] || 0) + 1; });
-      var top = Object.keys(freq).sort(function (a, b) { return freq[b] - freq[a]; }).slice(0, 5);
+      const freq = {};
+      flat.forEach(function (t) { const k = String(t).toLowerCase(); freq[k] = (freq[k] || 0) + 1; });
+      const top = Object.keys(freq).sort(function (a, b) { return freq[b] - freq[a]; }).slice(0, 5);
       report.high_frequency.push({ gene_id: geneId, count: g.total_count, avg_score: Math.round(g.avg_score * 100) / 100, top_triggers: top });
     }
 
     if (g.summaries.length >= 3) {
-      var first = g.summaries[0];
-      var last = g.summaries[g.summaries.length - 1];
+      const first = g.summaries[0];
+      const last = g.summaries[g.summaries.length - 1];
       if (first !== last) {
-        var fw = new Set(first.toLowerCase().split(/\s+/));
-        var lw = new Set(last.toLowerCase().split(/\s+/));
-        var inter = 0;
+        const fw = new Set(first.toLowerCase().split(/\s+/));
+        const lw = new Set(last.toLowerCase().split(/\s+/));
+        let inter = 0;
         fw.forEach(function (w) { if (lw.has(w)) inter++; });
-        var union = fw.size + lw.size - inter;
-        var sim = union > 0 ? inter / union : 1;
+        const union = fw.size + lw.size - inter;
+        const sim = union > 0 ? inter / union : 1;
         if (sim < 0.6) {
           report.strategy_drift.push({ gene_id: geneId, similarity: Math.round(sim * 100) / 100, early_summary: first.slice(0, 120), recent_summary: last.slice(0, 120) });
         }
@@ -169,19 +170,19 @@ function analyzePatterns(data) {
     }
   });
 
-  var signalFreq = {};
+  const signalFreq = {};
   (data.events || []).forEach(function (evt) {
     if (evt && Array.isArray(evt.signals)) {
-      evt.signals.forEach(function (s) { var k = String(s).toLowerCase(); signalFreq[k] = (signalFreq[k] || 0) + 1; });
+      evt.signals.forEach(function (s) { const k = String(s).toLowerCase(); signalFreq[k] = (signalFreq[k] || 0) + 1; });
     }
   });
-  var covered = new Set();
+  const covered = new Set();
   Object.keys(grouped).forEach(function (geneId) {
     grouped[geneId].triggers.forEach(function (t) {
       if (Array.isArray(t)) t.forEach(function (s) { covered.add(String(s).toLowerCase()); });
     });
   });
-  var gaps = Object.keys(signalFreq)
+  const gaps = Object.keys(signalFreq)
     .filter(function (s) { return signalFreq[s] >= 3 && !covered.has(s); })
     .sort(function (a, b) { return signalFreq[b] - signalFreq[a]; })
     .slice(0, 10);
@@ -196,16 +197,16 @@ function analyzePatterns(data) {
 // Step 3: LLM response parsing
 // ---------------------------------------------------------------------------
 function extractJsonFromLlmResponse(text) {
-  var str = String(text || '');
-  var buffer = '';
-  var depth = 0;
-  for (var i = 0; i < str.length; i++) {
-    var ch = str[i];
+  const str = String(text || '');
+  let buffer = '';
+  let depth = 0;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
     if (ch === '{') { if (depth === 0) buffer = ''; depth++; buffer += ch; }
     else if (ch === '}') {
       depth--; buffer += ch;
       if (depth === 0 && buffer.length > 2) {
-        try { var obj = JSON.parse(buffer); if (obj && typeof obj === 'object' && obj.type === 'Gene') return obj; } catch (e) {}
+        try { const obj = JSON.parse(buffer); if (obj && typeof obj === 'object' && obj.type === 'Gene') return obj; } catch (e) {}
         buffer = '';
       }
       if (depth < 0) depth = 0;
@@ -215,10 +216,10 @@ function extractJsonFromLlmResponse(text) {
 }
 
 function buildDistillationPrompt(analysis, existingGenes, sampleCapsules) {
-  var genesRef = existingGenes.map(function (g) {
+  const genesRef = existingGenes.map(function (g) {
     return { id: g.id, category: g.category || null, signals_match: g.signals_match || [] };
   });
-  var samples = sampleCapsules.slice(0, 8).map(function (c) {
+  const samples = sampleCapsules.slice(0, 8).map(function (c) {
     return { gene: c.gene || c.gene_id || null, trigger: c.trigger || [], summary: (c.summary || '').slice(0, 200), outcome: c.outcome || null };
   });
 
@@ -318,7 +319,7 @@ function distillRequestPath() {
 // Derive a descriptive ID from gene content when the LLM gives a bad name
 // ---------------------------------------------------------------------------
 function deriveDescriptiveId(gene) {
-  var words = [];
+  let words = [];
   if (Array.isArray(gene.signals_match)) {
     gene.signals_match.slice(0, 3).forEach(function (s) {
       String(s).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).forEach(function (w) {
@@ -327,7 +328,7 @@ function deriveDescriptiveId(gene) {
     });
   }
   if (words.length < 3 && gene.summary) {
-    var STOP = new Set(['the', 'and', 'for', 'with', 'from', 'that', 'this', 'into', 'when', 'are', 'was', 'has', 'had']);
+    const STOP = new Set(['the', 'and', 'for', 'with', 'from', 'that', 'this', 'into', 'when', 'are', 'was', 'has', 'had']);
     String(gene.summary).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).forEach(function (w) {
       if (w.length >= 3 && !STOP.has(w) && words.length < 6) words.push(w);
     });
@@ -338,8 +339,8 @@ function deriveDescriptiveId(gene) {
     });
   }
   if (words.length < 2) words = ['auto', 'distilled', 'strategy'];
-  var unique = [];
-  var seen = new Set();
+  const unique = [];
+  const seen = new Set();
   words.forEach(function (w) { if (!seen.has(w)) { seen.add(w); unique.push(w); } });
   return DISTILLED_ID_PREFIX + unique.slice(0, 5).join('-');
 }
@@ -349,9 +350,9 @@ function deriveDescriptiveId(gene) {
 // ---------------------------------------------------------------------------
 function sanitizeSignalsMatch(signals) {
   if (!Array.isArray(signals)) return [];
-  var cleaned = [];
+  const cleaned = [];
   signals.forEach(function (s) {
-    var sig = String(s || '').trim().toLowerCase();
+    let sig = String(s || '').trim().toLowerCase();
     if (!sig) return;
     // Strip trailing timestamps (10+ digits) and random suffixes
     sig = sig.replace(/[_-]\d{10,}$/g, '');
@@ -368,7 +369,7 @@ function sanitizeSignalsMatch(signals) {
     cleaned.push(sig);
   });
   // Deduplicate
-  var seen = {};
+  const seen = {};
   return cleaned.filter(function (s) { if (seen[s]) return false; seen[s] = true; return true; });
 }
 
@@ -376,7 +377,7 @@ function sanitizeSignalsMatch(signals) {
 // Step 4: validateSynthesizedGene
 // ---------------------------------------------------------------------------
 function validateSynthesizedGene(gene, existingGenes) {
-  var errors = [];
+  const errors = [];
   if (!gene || typeof gene !== 'object') return { valid: false, errors: ['gene is not an object'] };
 
   if (gene.type !== 'Gene') errors.push('missing or wrong type (must be "Gene")');
@@ -404,17 +405,16 @@ function validateSynthesizedGene(gene, existingGenes) {
   }
 
   if (gene.id) {
-    var suffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
-    // Strip ALL embedded timestamps (10+ digit sequences) anywhere in the id
+    let suffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
     suffix = suffix.replace(/[-_]?\d{10,}[-_]?/g, '-').replace(/[-_]+/g, '-').replace(/^[-_]+|[-_]+$/g, '');
-    var needsRename = /^\d+$/.test(suffix) || /^\d{10,}/.test(suffix)
+    const needsRename = /^\d+$/.test(suffix) || /^\d{10,}/.test(suffix)
       || /^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex)[-_]?\d*$/i.test(suffix);
     if (needsRename) {
       gene.id = deriveDescriptiveId(gene);
     } else {
       gene.id = DISTILLED_ID_PREFIX + suffix;
     }
-    var cleanSuffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
+    const cleanSuffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
     if (cleanSuffix.replace(/[-_]/g, '').length < 6) {
       gene.id = deriveDescriptiveId(gene);
     }
@@ -447,14 +447,14 @@ function validateSynthesizedGene(gene, existingGenes) {
   }
 
   // --- Validation command sanitization ---
-  var ALLOWED_PREFIXES = ['node ', 'npm ', 'npx '];
+  const ALLOWED_PREFIXES = ['node ', 'npm ', 'npx '];
   if (Array.isArray(gene.validation)) {
     gene.validation = gene.validation.filter(function (cmd) {
-      var c = String(cmd || '').trim();
+      const c = String(cmd || '').trim();
       if (!c) return false;
       if (!ALLOWED_PREFIXES.some(function (p) { return c.startsWith(p); })) return false;
       if (/`|\$\(/.test(c)) return false;
-      var stripped = c.replace(/"[^"]*"/g, '').replace(/'[^']*'/g, '');
+      const stripped = c.replace(/"[^"]*"/g, '').replace(/'[^']*'/g, '');
       return !/[;&|><]/.test(stripped);
     });
   }
@@ -463,19 +463,19 @@ function validateSynthesizedGene(gene, existingGenes) {
   if (!gene.schema_version) gene.schema_version = '1.6.0';
 
   // --- Duplicate ID check ---
-  var existingIds = new Set((existingGenes || []).map(function (g) { return g.id; }));
+  const existingIds = new Set((existingGenes || []).map(function (g) { return g.id; }));
   if (gene.id && existingIds.has(gene.id)) {
     gene.id = gene.id + '_' + Date.now().toString(36);
   }
 
   // --- Signal overlap check ---
   if (gene.signals_match && existingGenes && existingGenes.length > 0) {
-    var newSet = new Set(gene.signals_match.map(function (s) { return String(s).toLowerCase(); }));
-    for (var i = 0; i < existingGenes.length; i++) {
-      var eg = existingGenes[i];
-      var egSet = new Set((eg.signals_match || []).map(function (s) { return String(s).toLowerCase(); }));
+    const newSet = new Set(gene.signals_match.map(function (s) { return String(s).toLowerCase(); }));
+    for (let i = 0; i < existingGenes.length; i++) {
+      const eg = existingGenes[i];
+      const egSet = new Set((eg.signals_match || []).map(function (s) { return String(s).toLowerCase(); }));
       if (newSet.size > 0 && egSet.size > 0) {
-        var overlap = 0;
+        let overlap = 0;
         newSet.forEach(function (s) { if (egSet.has(s)) overlap++; });
         if (overlap === newSet.size && overlap === egSet.size) {
           errors.push('signals_match fully overlaps with existing gene: ' + eg.id);
@@ -493,24 +493,24 @@ function validateSynthesizedGene(gene, existingGenes) {
 function shouldDistill() {
   if (String(process.env.SKILL_DISTILLER || 'true').toLowerCase() === 'false') return false;
 
-  var state = readDistillerState();
+  const state = readDistillerState();
   if (state.last_distillation_at) {
-    var elapsed = Date.now() - new Date(state.last_distillation_at).getTime();
+    const elapsed = Date.now() - new Date(state.last_distillation_at).getTime();
     if (elapsed < DISTILLER_INTERVAL_HOURS * 3600000) return false;
   }
 
-  var assetsDir = paths.getGepAssetsDir();
-  var capsulesJson = readJsonIfExists(path.join(assetsDir, 'capsules.json'), { capsules: [] });
-  var capsulesJsonl = readJsonlIfExists(path.join(assetsDir, 'capsules.jsonl'));
-  var all = [].concat(capsulesJson.capsules || [], capsulesJsonl);
+  const assetsDir = paths.getGepAssetsDir();
+  const capsulesJson = readJsonIfExists(path.join(assetsDir, 'capsules.json'), { capsules: [] });
+  const capsulesJsonl = readJsonlIfExists(path.join(assetsDir, 'capsules.jsonl'));
+  const all = [].concat(capsulesJson.capsules || [], capsulesJsonl);
 
-  var recent = all.slice(-10);
-  var recentSuccess = recent.filter(function (c) {
+  const recent = all.slice(-10);
+  const recentSuccess = recent.filter(function (c) {
     return c && c.outcome && (c.outcome.status === 'success' || c.outcome === 'success');
   }).length;
   if (recentSuccess < 7) return false;
 
-  var totalSuccess = all.filter(function (c) {
+  const totalSuccess = all.filter(function (c) {
     return c && c.outcome && (c.outcome.status === 'success' || c.outcome === 'success');
   }).length;
   if (totalSuccess < DISTILLER_MIN_CAPSULES) return false;
@@ -524,7 +524,7 @@ function shouldDistill() {
 function prepareDistillation() {
   console.log('[Distiller] Preparing skill distillation...');
 
-  var data = collectDistillationData();
+  const data = collectDistillationData();
   console.log('[Distiller] Collected ' + data.successCapsules.length + ' successful capsules across ' + Object.keys(data.grouped).length + ' gene groups.');
 
   if (data.successCapsules.length < DISTILLER_MIN_CAPSULES) {
@@ -532,29 +532,29 @@ function prepareDistillation() {
     return { ok: false, reason: 'insufficient_data' };
   }
 
-  var state = readDistillerState();
+  const state = readDistillerState();
   if (state.last_data_hash === data.dataHash) {
     console.log('[Distiller] Data unchanged since last distillation (hash: ' + data.dataHash + '). Skipping.');
     return { ok: false, reason: 'idempotent_skip' };
   }
 
-  var analysis = analyzePatterns(data);
+  const analysis = analyzePatterns(data);
   console.log('[Distiller] Analysis: high_freq=' + analysis.high_frequency.length + ' drift=' + analysis.strategy_drift.length + ' gaps=' + analysis.coverage_gaps.length);
 
-  var assetsDir = paths.getGepAssetsDir();
-  var existingGenesJson = readJsonIfExists(path.join(assetsDir, 'genes.json'), { genes: [] });
-  var existingGenes = existingGenesJson.genes || [];
+  const assetsDir = paths.getGepAssetsDir();
+  const existingGenesJson = readJsonIfExists(path.join(assetsDir, 'genes.json'), { genes: [] });
+  const existingGenes = existingGenesJson.genes || [];
 
-  var prompt = buildDistillationPrompt(analysis, existingGenes, data.successCapsules);
+  const prompt = buildDistillationPrompt(analysis, existingGenes, data.successCapsules);
 
-  var memDir = paths.getMemoryDir();
+  const memDir = paths.getMemoryDir();
   ensureDir(memDir);
-  var promptFileName = 'distill_prompt_' + Date.now() + '.txt';
-  var promptPath = path.join(memDir, promptFileName);
+  const promptFileName = 'distill_prompt_' + Date.now() + '.txt';
+  const promptPath = path.join(memDir, promptFileName);
   fs.writeFileSync(promptPath, prompt, 'utf8');
 
-  var reqPath = distillRequestPath();
-  var requestData = {
+  const reqPath = distillRequestPath();
+  const requestData = {
     type: 'DistillationRequest',
     created_at: new Date().toISOString(),
     prompt_path: promptPath,
@@ -573,19 +573,139 @@ function prepareDistillation() {
   return { ok: true, promptPath: promptPath, requestPath: reqPath, dataHash: data.dataHash };
 }
 
+function inferCategoryFromSignals(signals) {
+  const list = Array.isArray(signals) ? signals.map(function (s) { return String(s).toLowerCase(); }) : [];
+  if (list.some(function (s) { return s.indexOf('error') !== -1 || s.indexOf('fail') !== -1 || s.indexOf('reliability') !== -1; })) {
+    return 'repair';
+  }
+  if (list.some(function (s) { return s.indexOf('feature') !== -1 || s.indexOf('capability') !== -1 || s.indexOf('stagnation') !== -1; })) {
+    return 'innovate';
+  }
+  return 'optimize';
+}
+
+function chooseDistillationSource(data, analysis) {
+  const grouped = data && data.grouped ? data.grouped : {};
+  let best = null;
+  Object.keys(grouped).forEach(function (geneId) {
+    const g = grouped[geneId];
+    if (!g || g.total_count <= 0) return;
+    const score = (g.total_count * 2) + (g.avg_score || 0);
+    if (!best || score > best.score) {
+      best = { gene_id: geneId, group: g, score: score };
+    }
+  });
+  return best;
+}
+
+function synthesizeGeneFromPatterns(data, analysis, existingGenes) {
+  const source = chooseDistillationSource(data, analysis);
+  if (!source || !source.group) return null;
+
+  const group = source.group;
+  const existing = Array.isArray(existingGenes) ? existingGenes : [];
+  const sourceGene = existing.find(function (g) { return g && g.id === source.gene_id; }) || null;
+
+  const triggerFreq = {};
+  (group.triggers || []).forEach(function (arr) {
+    (Array.isArray(arr) ? arr : []).forEach(function (s) {
+      const k = String(s).toLowerCase();
+      triggerFreq[k] = (triggerFreq[k] || 0) + 1;
+    });
+  });
+  let signalsMatch = Object.keys(triggerFreq)
+    .sort(function (a, b) { return triggerFreq[b] - triggerFreq[a]; })
+    .slice(0, 6);
+  const summaryText = (group.summaries || []).slice(0, 5).join(' ');
+  const derivedTags = learningSignals.expandSignals(signalsMatch, summaryText)
+    .filter(function (tag) { return tag.indexOf('problem:') === 0 || tag.indexOf('area:') === 0; })
+    .slice(0, 4);
+  signalsMatch = Array.from(new Set(signalsMatch.concat(derivedTags)));
+  if (signalsMatch.length === 0 && sourceGene && Array.isArray(sourceGene.signals_match)) {
+    signalsMatch = sourceGene.signals_match.slice(0, 6);
+  }
+
+  const category = sourceGene && sourceGene.category ? sourceGene.category : inferCategoryFromSignals(signalsMatch);
+  const idSeed = {
+    type: 'Gene',
+    id: DISTILLED_ID_PREFIX + source.gene_id.replace(/^gene_/, '').replace(/^gene_distilled_/, ''),
+    category: category,
+    signals_match: signalsMatch,
+    strategy: sourceGene && Array.isArray(sourceGene.strategy) && sourceGene.strategy.length > 0
+      ? sourceGene.strategy.slice(0, 4)
+      : [
+        'Identify the dominant repeated trigger pattern.',
+        'Apply the smallest targeted change for that pattern.',
+        'Run the narrowest validation that proves the regression is gone.',
+        'Rollback immediately if validation fails.',
+      ],
+  };
+
+  let summaryBase = (group.summaries && group.summaries[0]) ? String(group.summaries[0]) : '';
+  if (!summaryBase) {
+    summaryBase = 'Reusable strategy for repeated successful pattern: ' + signalsMatch.slice(0, 3).join(', ');
+  }
+
+  const gene = {
+    type: 'Gene',
+    id: deriveDescriptiveId(idSeed),
+    summary: summaryBase.slice(0, 200),
+    category: category,
+    signals_match: signalsMatch,
+    preconditions: sourceGene && Array.isArray(sourceGene.preconditions) && sourceGene.preconditions.length > 0
+      ? sourceGene.preconditions.slice(0, 4)
+      : ['repeated success pattern observed in recent capsules'],
+    strategy: idSeed.strategy,
+    constraints: {
+      max_files: sourceGene && sourceGene.constraints && Number(sourceGene.constraints.max_files) > 0
+        ? Math.min(DISTILLED_MAX_FILES, Number(sourceGene.constraints.max_files))
+        : DISTILLED_MAX_FILES,
+      forbidden_paths: sourceGene && sourceGene.constraints && Array.isArray(sourceGene.constraints.forbidden_paths)
+        ? sourceGene.constraints.forbidden_paths.slice(0, 6)
+        : ['.git', 'node_modules'],
+    },
+    validation: sourceGene && Array.isArray(sourceGene.validation) && sourceGene.validation.length > 0
+      ? sourceGene.validation.slice(0, 4)
+      : ['node --test'],
+  };
+
+  return gene;
+}
+
+function finalizeDistilledGene(gene, requestLike, status) {
+  const state = readDistillerState();
+  state.last_distillation_at = new Date().toISOString();
+  state.last_data_hash = requestLike.data_hash;
+  state.last_gene_id = gene.id;
+  state.distillation_count = (state.distillation_count || 0) + 1;
+  writeDistillerState(state);
+
+  appendJsonl(distillerLogPath(), {
+    timestamp: new Date().toISOString(),
+    data_hash: requestLike.data_hash,
+    input_capsule_count: requestLike.input_capsule_count,
+    analysis_summary: requestLike.analysis_summary,
+    synthesized_gene_id: gene.id,
+    validation_passed: true,
+    validation_errors: [],
+    status: status || 'success',
+    gene: gene,
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Step 5b: completeDistillation -- validate LLM response and save gene
 // ---------------------------------------------------------------------------
 function completeDistillation(responseText) {
-  var reqPath = distillRequestPath();
-  var request = readJsonIfExists(reqPath, null);
+  const reqPath = distillRequestPath();
+  const request = readJsonIfExists(reqPath, null);
 
   if (!request) {
     console.warn('[Distiller] No pending distillation request found.');
     return { ok: false, reason: 'no_request' };
   }
 
-  var rawGene = extractJsonFromLlmResponse(responseText);
+  const rawGene = extractJsonFromLlmResponse(responseText);
   if (!rawGene) {
     appendJsonl(distillerLogPath(), {
       timestamp: new Date().toISOString(),
@@ -597,13 +717,13 @@ function completeDistillation(responseText) {
     return { ok: false, reason: 'no_gene_in_response' };
   }
 
-  var assetsDir = paths.getGepAssetsDir();
-  var existingGenesJson = readJsonIfExists(path.join(assetsDir, 'genes.json'), { genes: [] });
-  var existingGenes = existingGenesJson.genes || [];
+  const assetsDir = paths.getGepAssetsDir();
+  const existingGenesJson = readJsonIfExists(path.join(assetsDir, 'genes.json'), { genes: [] });
+  const existingGenes = existingGenesJson.genes || [];
 
-  var validation = validateSynthesizedGene(rawGene, existingGenes);
+  const validation = validateSynthesizedGene(rawGene, existingGenes);
 
-  var logEntry = {
+  const logEntry = {
     timestamp: new Date().toISOString(),
     data_hash: request.data_hash,
     input_capsule_count: request.input_capsule_count,
@@ -620,18 +740,18 @@ function completeDistillation(responseText) {
     return { ok: false, reason: 'validation_failed', errors: validation.errors };
   }
 
-  var gene = validation.gene;
+  const gene = validation.gene;
   gene._distilled_meta = {
     distilled_at: new Date().toISOString(),
     source_capsule_count: request.input_capsule_count,
     data_hash: request.data_hash,
   };
 
-  var assetStore = require('./assetStore');
+  const assetStore = require('./assetStore');
   assetStore.upsertGene(gene);
   console.log('[Distiller] Gene "' + gene.id + '" written to genes.json.');
 
-  var state = readDistillerState();
+  const state = readDistillerState();
   state.last_distillation_at = new Date().toISOString();
   state.last_data_hash = request.data_hash;
   state.last_gene_id = gene.id;
@@ -649,7 +769,7 @@ function completeDistillation(responseText) {
 
   if (process.env.SKILL_AUTO_PUBLISH !== '0') {
     try {
-      var skillPublisher = require('./skillPublisher');
+      const skillPublisher = require('./skillPublisher');
       skillPublisher.publishSkillToHub(gene).then(function (res) {
         if (res.ok) {
           console.log('[Distiller] Skill published to Hub: ' + (res.result?.skill_id || gene.id));
@@ -665,11 +785,67 @@ function completeDistillation(responseText) {
   return { ok: true, gene: gene };
 }
 
+function autoDistill() {
+  const data = collectDistillationData();
+  if (data.successCapsules.length < DISTILLER_MIN_CAPSULES) {
+    return { ok: false, reason: 'insufficient_data' };
+  }
+
+  const state = readDistillerState();
+  if (state.last_data_hash === data.dataHash) {
+    return { ok: false, reason: 'idempotent_skip' };
+  }
+
+  const analysis = analyzePatterns(data);
+  const assetsDir = paths.getGepAssetsDir();
+  const existingGenesJson = readJsonIfExists(path.join(assetsDir, 'genes.json'), { genes: [] });
+  const existingGenes = existingGenesJson.genes || [];
+  const rawGene = synthesizeGeneFromPatterns(data, analysis, existingGenes);
+  if (!rawGene) return { ok: false, reason: 'no_candidate_gene' };
+
+  const validation = validateSynthesizedGene(rawGene, existingGenes);
+  if (!validation.valid) {
+    appendJsonl(distillerLogPath(), {
+      timestamp: new Date().toISOString(),
+      data_hash: data.dataHash,
+      status: 'auto_validation_failed',
+      synthesized_gene_id: validation.gene ? validation.gene.id : null,
+      validation_errors: validation.errors,
+    });
+    return { ok: false, reason: 'validation_failed', errors: validation.errors };
+  }
+
+  const gene = validation.gene;
+  gene._distilled_meta = {
+    distilled_at: new Date().toISOString(),
+    source_capsule_count: data.successCapsules.length,
+    data_hash: data.dataHash,
+    auto_distilled: true,
+  };
+
+  const assetStore = require('./assetStore');
+  assetStore.upsertGene(gene);
+  finalizeDistilledGene(gene, {
+    data_hash: data.dataHash,
+    input_capsule_count: data.successCapsules.length,
+    analysis_summary: {
+      high_frequency_count: analysis.high_frequency.length,
+      drift_count: analysis.strategy_drift.length,
+      gap_count: analysis.coverage_gaps.length,
+      success_rate: Math.round(analysis.success_rate * 100) / 100,
+    },
+  }, 'auto_success');
+
+  return { ok: true, gene: gene, auto: true };
+}
+
 module.exports = {
   collectDistillationData: collectDistillationData,
   analyzePatterns: analyzePatterns,
+  synthesizeGeneFromPatterns: synthesizeGeneFromPatterns,
   prepareDistillation: prepareDistillation,
   completeDistillation: completeDistillation,
+  autoDistill: autoDistill,
   validateSynthesizedGene: validateSynthesizedGene,
   sanitizeSignalsMatch: sanitizeSignalsMatch,
   shouldDistill: shouldDistill,