@evomap/evolver 1.31.0 → 1.32.1

package/index.js

@@ -282,7 +282,7 @@ async function main() {
 
       if (res && res.ok && !dryRun) {
         try {
-          const { shouldDistill, prepareDistillation } = require('./src/gep/skillDistiller');
+          const { shouldDistill, prepareDistillation, autoDistill } = require('./src/gep/skillDistiller');
           const { readStateForSolidify } = require('./src/gep/solidify');
           const solidifyState = readStateForSolidify();
           const count = solidifyState.solidify_count || 0;
@@ -290,16 +290,21 @@ async function main() {
           const autoTrigger = count > 0 && count % autoDistillInterval === 0;
 
           if (autoTrigger || shouldDistill()) {
-            const dr = prepareDistillation();
-            if (dr && dr.ok && dr.promptPath) {
-              const trigger = autoTrigger ? `auto (every ${autoDistillInterval} solidifies, count=${count})` : 'threshold';
-              console.log('\n[DISTILL_REQUEST]');
-              console.log(`Distillation triggered: ${trigger}`);
-              console.log('Read the prompt file, process it with your LLM,');
-              console.log('save the LLM response to a file, then run:');
-              console.log('  node index.js distill --response-file=<path_to_llm_response>');
-              console.log('Prompt file: ' + dr.promptPath);
-              console.log('[/DISTILL_REQUEST]');
+            const auto = autoDistill();
+            if (auto && auto.ok && auto.gene) {
+              console.log('[Distiller] Auto-distilled gene: ' + auto.gene.id);
+            } else {
+              const dr = prepareDistillation();
+              if (dr && dr.ok && dr.promptPath) {
+                const trigger = autoTrigger ? `auto (every ${autoDistillInterval} solidifies, count=${count})` : 'threshold';
+                console.log('\n[DISTILL_REQUEST]');
+                console.log(`Distillation triggered: ${trigger}`);
+                console.log('Read the prompt file, process it with your LLM,');
+                console.log('save the LLM response to a file, then run:');
+                console.log('  node index.js distill --response-file=<path_to_llm_response>');
+                console.log('Prompt file: ' + dr.promptPath);
+                console.log('[/DISTILL_REQUEST]');
+              }
             }
           }
         } catch (e) {
@@ -454,7 +459,9 @@ async function main() {
           const s = readJsonSafe(sp);
           if (s && s.last_run) {
             s.last_solidify = { run_id: s.last_run.run_id, rejected: true, timestamp: new Date().toISOString() };
-            fs.writeFileSync(sp, JSON.stringify(s, null, 2));
+            const tmpReject = `${sp}.tmp`;
+            fs.writeFileSync(tmpReject, JSON.stringify(s, null, 2) + '\n', 'utf8');
+            fs.renameSync(tmpReject, sp);
           }
         }
         console.log('[Review] Changes rolled back.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.31.0",
+  "version": "1.32.1",
   "description": "A GEP-powered self-evolution engine for AI agents. Features automated log analysis and Genome Evolution Protocol (GEP) for auditable, reusable evolution assets.",
   "main": "index.js",
   "bin": {

package/src/evolve.js

@@ -39,6 +39,8 @@ const { getEvolutionDir } = require('./gep/paths');
 const { shouldReflect, buildReflectionContext, recordReflection } = require('./gep/reflection');
 const { loadNarrativeSummary } = require('./gep/narrativeMemory');
 const { maybeReportIssue } = require('./gep/issueReporter');
+const { resolveStrategy } = require('./gep/strategy');
+const { expandSignals } = require('./gep/learningSignals');
 
 const REPO_ROOT = getRepoRoot();
 
@@ -352,6 +354,73 @@ function readRecentLog(filePath, size = 10000) {
   }
 }
 
+function computeAdaptiveStrategyPolicy(opts) {
+  const recentEvents = Array.isArray(opts && opts.recentEvents) ? opts.recentEvents : [];
+  const selectedGene = opts && opts.selectedGene ? opts.selectedGene : null;
+  const signals = Array.isArray(opts && opts.signals) ? opts.signals : [];
+  const baseStrategy = resolveStrategy({ signals: signals });
+
+  const tail = recentEvents.slice(-8);
+  let repairStreak = 0;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    if (tail[i] && tail[i].intent === 'repair') repairStreak++;
+    else break;
+  }
+  let failureStreak = 0;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    if (tail[i] && tail[i].outcome && tail[i].outcome.status === 'failed') failureStreak++;
+    else break;
+  }
+
+  const antiPatterns = selectedGene && Array.isArray(selectedGene.anti_patterns) ? selectedGene.anti_patterns.slice(-5) : [];
+  const learningHistory = selectedGene && Array.isArray(selectedGene.learning_history) ? selectedGene.learning_history.slice(-6) : [];
+  const signalTags = new Set(expandSignals(signals, ''));
+  const overlappingAntiPatterns = antiPatterns.filter(function (ap) {
+    return ap && Array.isArray(ap.learning_signals) && ap.learning_signals.some(function (tag) {
+      return signalTags.has(String(tag));
+    });
+  });
+  const hardFailures = overlappingAntiPatterns.filter(function (ap) { return ap && ap.mode === 'hard'; }).length;
+  const softFailures = overlappingAntiPatterns.filter(function (ap) { return ap && ap.mode !== 'hard'; }).length;
+  const recentSuccesses = learningHistory.filter(function (x) { return x && x.outcome === 'success'; }).length;
+
+  const stagnation = signals.includes('stable_success_plateau') ||
+    signals.includes('evolution_saturation') ||
+    signals.includes('empty_cycle_loop_detected') ||
+    failureStreak >= 3 ||
+    repairStreak >= 3;
+
+  const forceInnovate = stagnation && !signals.includes('log_error');
+  const highRiskGene = hardFailures >= 1 || (softFailures >= 2 && recentSuccesses === 0);
+  const cautiousExecution = highRiskGene || failureStreak >= 2;
+
+  let blastRadiusMaxFiles = selectedGene && selectedGene.constraints && Number.isFinite(Number(selectedGene.constraints.max_files))
+    ? Number(selectedGene.constraints.max_files)
+    : 12;
+  if (cautiousExecution) blastRadiusMaxFiles = Math.max(2, Math.min(blastRadiusMaxFiles, 6));
+  else if (forceInnovate) blastRadiusMaxFiles = Math.max(3, Math.min(blastRadiusMaxFiles, 10));
+
+  const directives = [];
+  directives.push('Base strategy: ' + baseStrategy.label + ' (' + baseStrategy.description + ')');
+  if (forceInnovate) directives.push('Force strategy shift: prefer innovate over repeating repair/optimize.');
+  if (highRiskGene) directives.push('Selected gene is high risk for current signals; keep blast radius narrow and prefer smallest viable change.');
+  if (failureStreak >= 2) directives.push('Recent failure streak detected; avoid repeating recent failed approach.');
+  directives.push('Target max files for this cycle: ' + blastRadiusMaxFiles + '.');
+
+  return {
+    name: baseStrategy.name,
+    label: baseStrategy.label,
+    description: baseStrategy.description,
+    forceInnovate: forceInnovate,
+    cautiousExecution: cautiousExecution,
+    highRiskGene: highRiskGene,
+    repairStreak: repairStreak,
+    failureStreak: failureStreak,
+    blastRadiusMaxFiles: blastRadiusMaxFiles,
+    directives: directives,
+  };
+}
+
 function checkSystemHealth() {
   const report = [];
   try {
@@ -1279,6 +1348,7 @@ async function run() {
   const newCandidates = extractCapabilityCandidates({
     recentSessionTranscript: recentMasterLog,
     signals,
+    recentFailedCapsules: readRecentFailedCapsules(50),
   });
   for (const c of newCandidates) {
     try {
@@ -1433,6 +1503,11 @@ async function run() {
     ? capsuleCandidates.map(c => (c && c.id ? String(c.id) : null)).filter(Boolean)
     : [];
   const selectedCapsuleId = capsulesUsed.length ? capsulesUsed[0] : null;
+  const strategyPolicy = computeAdaptiveStrategyPolicy({
+    recentEvents,
+    selectedGene,
+    signals,
+  });
 
   // Personality selection (natural selection + small mutation when triggered).
   // This state is persisted in MEMORY_DIR and is treated as an evolution control surface (not role-play).
@@ -1463,9 +1538,9 @@ async function run() {
     tailAvgScore >= 0.7;
   const forceInnovation =
     String(process.env.FORCE_INNOVATION || process.env.EVOLVE_FORCE_INNOVATION || '').toLowerCase() === 'true';
-  const mutationInnovateMode = !!IS_RANDOM_DRIFT || !!innovationPressure || !!forceInnovation;
+  const mutationInnovateMode = !!IS_RANDOM_DRIFT || !!innovationPressure || !!forceInnovation || !!strategyPolicy.forceInnovate;
   const mutationSignals = innovationPressure ? [...(Array.isArray(signals) ? signals : []), 'stable_success_plateau'] : signals;
-  const mutationSignalsEffective = forceInnovation
+  const mutationSignalsEffective = (forceInnovation || strategyPolicy.forceInnovate)
     ? [...(Array.isArray(mutationSignals) ? mutationSignals : []), 'force_innovation']
     : mutationSignals;
 
@@ -1565,10 +1640,13 @@ async function run() {
       console.warn('[SolidifyState] Failed to read git HEAD:', e && e.message || e);
     }
 
-    const maxFiles =
-      selectedGene && selectedGene.constraints && Number.isFinite(Number(selectedGene.constraints.max_files))
-        ? Number(selectedGene.constraints.max_files)
-        : 12;
+    const maxFiles = strategyPolicy && Number.isFinite(Number(strategyPolicy.blastRadiusMaxFiles))
+      ? Number(strategyPolicy.blastRadiusMaxFiles)
+      : (
+        selectedGene && selectedGene.constraints && Number.isFinite(Number(selectedGene.constraints.max_files))
+          ? Number(selectedGene.constraints.max_files)
+          : 12
+      );
     const blastRadiusEstimate = {
       files: Number.isFinite(maxFiles) && maxFiles > 0 ? maxFiles : 0,
       lines: Number.isFinite(maxFiles) && maxFiles > 0 ? Math.round(maxFiles * 80) : 0,
@@ -1602,6 +1680,7 @@ async function run() {
         baseline_untracked: baselineUntracked,
         baseline_git_head: baselineHead,
         blast_radius_estimate: blastRadiusEstimate,
+        strategy_policy: strategyPolicy,
         active_task_id: activeTask ? (activeTask.id || activeTask.task_id || null) : null,
         active_task_title: activeTask ? (activeTask.title || null) : null,
         worker_assignment_id: activeTask ? (activeTask._worker_assignment_id || null) : null,
@@ -1739,6 +1818,7 @@ ${mutationDirective}
         capabilityCandidatesPreview,
         externalCandidatesPreview,
         hubMatchedBlock,
+        strategyPolicy,
         failedCapsules: recentFailedCapsules,
         hubLessons,
       });
@@ -1827,5 +1907,5 @@ ${mutationDirective}
   }
 }
 
-module.exports = { run };
+module.exports = { run, computeAdaptiveStrategyPolicy };
 

package/src/gep/candidates.js

@@ -1,3 +1,5 @@
+const { expandSignals } = require('./learningSignals');
+
 function stableHash(input) {
   // Deterministic lightweight hash (not cryptographic).
   const s = String(input || '');
@@ -60,13 +62,15 @@ function buildFiveQuestionsShape({ title, signals, evidence }) {
   };
 }
 
-function extractCapabilityCandidates({ recentSessionTranscript, signals }) {
+function extractCapabilityCandidates({ recentSessionTranscript, signals, recentFailedCapsules }) {
   const candidates = [];
+  const signalList = Array.isArray(signals) ? signals : [];
+  const expandedTags = expandSignals(signalList, recentSessionTranscript);
   const toolCalls = extractToolCalls(recentSessionTranscript);
   const freq = countFreq(toolCalls);
 
   for (const [tool, count] of freq.entries()) {
-    if (count < 2) continue;
+    if (count < 3) continue;
     const title = `Repeated tool usage: ${tool}`;
     const evidence = `Observed ${count} occurrences of tool call marker for ${tool}.`;
     const shape = buildFiveQuestionsShape({ title, signals, evidence });
@@ -76,13 +80,13 @@ function extractCapabilityCandidates({ recentSessionTranscript, signals }) {
       title,
       source: 'transcript',
       created_at: new Date().toISOString(),
-      signals: Array.isArray(signals) ? signals : [],
+      signals: signalList,
+      tags: expandedTags,
       shape,
     });
   }
 
   // Signals-as-candidates: capture recurring pain points as reusable capability shapes.
-  const signalList = Array.isArray(signals) ? signals : [];
   const signalCandidates = [
     // Defensive signals
     { signal: 'log_error', title: 'Repair recurring runtime errors' },
@@ -109,10 +113,67 @@ function extractCapabilityCandidates({ recentSessionTranscript, signals }) {
       source: 'signals',
       created_at: new Date().toISOString(),
       signals: signalList,
+      tags: expandedTags,
       shape,
     });
   }
 
+  var failedCapsules = Array.isArray(recentFailedCapsules) ? recentFailedCapsules : [];
+  var groups = {};
+  var problemPriority = [
+    'problem:performance',
+    'problem:protocol',
+    'problem:reliability',
+    'problem:stagnation',
+    'problem:capability',
+  ];
+  for (var i = 0; i < failedCapsules.length; i++) {
+    var fc = failedCapsules[i];
+    if (!fc || fc.outcome && fc.outcome.status === 'success') continue;
+    var reason = String(fc.failure_reason || '').trim();
+    var failureTags = expandSignals((fc.trigger || []).concat(signalList), reason).filter(function (t) {
+      return t.indexOf('problem:') === 0 || t.indexOf('risk:') === 0 || t.indexOf('area:') === 0 || t.indexOf('action:') === 0;
+    });
+    if (failureTags.length === 0) continue;
+    var dominantProblem = null;
+    for (var p = 0; p < problemPriority.length; p++) {
+      if (failureTags.indexOf(problemPriority[p]) !== -1) {
+        dominantProblem = problemPriority[p];
+        break;
+      }
+    }
+    var groupingTags = dominantProblem
+      ? [dominantProblem]
+      : failureTags.filter(function (tag) { return tag.indexOf('area:') === 0 || tag.indexOf('risk:') === 0; }).slice(0, 1);
+    var key = groupingTags.join('|');
+    if (!groups[key]) groups[key] = { count: 0, tags: failureTags, reasons: [], gene: fc.gene || null };
+    groups[key].count += 1;
+    if (reason) groups[key].reasons.push(reason);
+  }
+
+  Object.keys(groups).forEach(function (key) {
+    var group = groups[key];
+    if (!group || group.count < 2) return;
+    var title = 'Learn from recurring failed evolution paths';
+    if (group.tags.indexOf('problem:performance') !== -1) title = 'Resolve recurring performance regressions';
+    else if (group.tags.indexOf('problem:protocol') !== -1) title = 'Prevent recurring protocol and validation regressions';
+    else if (group.tags.indexOf('problem:reliability') !== -1) title = 'Repair recurring reliability failures';
+    else if (group.tags.indexOf('problem:stagnation') !== -1) title = 'Break repeated stagnation loops with a new strategy';
+    else if (group.tags.indexOf('area:orchestration') !== -1) title = 'Stabilize task and orchestration behavior';
+    var evidence = 'Observed ' + group.count + ' recent failed evolutions with similar learning tags. ' +
+      (group.reasons[0] ? 'Latest reason: ' + clip(group.reasons[0], 180) : '');
+    candidates.push({
+      type: 'CapabilityCandidate',
+      id: 'cand_' + stableHash('failed:' + key),
+      title: title,
+      source: 'failed_capsules',
+      created_at: new Date().toISOString(),
+      signals: signalList,
+      tags: group.tags,
+      shape: buildFiveQuestionsShape({ title: title, signals: signalList, evidence: evidence }),
+    });
+  });
+
   // Dedup by id
   const seen = new Set();
   return candidates.filter(c => {
@@ -142,5 +203,6 @@ function renderCandidatesPreview(candidates, maxChars = 1400) {
 module.exports = {
   extractCapabilityCandidates,
   renderCandidatesPreview,
+  expandSignals,
 };
 

package/src/gep/learningSignals.js

@@ -0,0 +1,88 @@
+function unique(items) {
+  return Array.from(new Set((Array.isArray(items) ? items : []).filter(Boolean).map(function (x) {
+    return String(x).trim();
+  }).filter(Boolean)));
+}
+
+function add(tags, value) {
+  if (!value) return;
+  tags.push(String(value).trim());
+}
+
+function expandSignals(signals, extraText) {
+  var raw = Array.isArray(signals) ? signals.map(function (s) { return String(s); }) : [];
+  var tags = [];
+
+  for (var i = 0; i < raw.length; i++) {
+    var signal = raw[i];
+    add(tags, signal);
+    var base = signal.split(':')[0];
+    if (base && base !== signal) add(tags, base);
+  }
+
+  var text = (raw.join(' ') + ' ' + String(extraText || '')).toLowerCase();
+
+  if (/(error|exception|failed|unstable|log_error|runtime|429)/.test(text)) {
+    add(tags, 'problem:reliability');
+    add(tags, 'action:repair');
+  }
+  if (/(protocol|prompt|audit|gep|schema|drift)/.test(text)) {
+    add(tags, 'problem:protocol');
+    add(tags, 'action:optimize');
+    add(tags, 'area:prompt');
+  }
+  if (/(perf|performance|bottleneck|latency|slow|throughput)/.test(text)) {
+    add(tags, 'problem:performance');
+    add(tags, 'action:optimize');
+  }
+  if (/(feature|capability_gap|user_feature_request|external_opportunity|stagnation recommendation)/.test(text)) {
+    add(tags, 'problem:capability');
+    add(tags, 'action:innovate');
+  }
+  if (/(stagnation|plateau|steady_state|saturation|empty_cycle_loop|loop_detected|recurring)/.test(text)) {
+    add(tags, 'problem:stagnation');
+    add(tags, 'action:innovate');
+  }
+  if (/(task|worker|heartbeat|hub|commitment|assignment|orchestration)/.test(text)) {
+    add(tags, 'area:orchestration');
+  }
+  if (/(memory|narrative|reflection)/.test(text)) {
+    add(tags, 'area:memory');
+  }
+  if (/(skill|dashboard)/.test(text)) {
+    add(tags, 'area:skills');
+  }
+  if (/(validation|canary|rollback|constraint|blast radius|destructive)/.test(text)) {
+    add(tags, 'risk:validation');
+  }
+
+  return unique(tags);
+}
+
+function geneTags(gene) {
+  if (!gene || typeof gene !== 'object') return [];
+  var inputs = [];
+  if (gene.category) inputs.push('action:' + String(gene.category).toLowerCase());
+  if (Array.isArray(gene.signals_match)) inputs = inputs.concat(gene.signals_match);
+  if (typeof gene.id === 'string') inputs.push(gene.id);
+  if (typeof gene.summary === 'string') inputs.push(gene.summary);
+  return expandSignals(inputs, '');
+}
+
+function scoreTagOverlap(gene, signals) {
+  var signalTags = expandSignals(signals, '');
+  var geneTagList = geneTags(gene);
+  if (signalTags.length === 0 || geneTagList.length === 0) return 0;
+  var signalSet = new Set(signalTags);
+  var hits = 0;
+  for (var i = 0; i < geneTagList.length; i++) {
+    if (signalSet.has(geneTagList[i])) hits++;
+  }
+  return hits;
+}
+
+module.exports = {
+  expandSignals: expandSignals,
+  geneTags: geneTags,
+  scoreTagOverlap: scoreTagOverlap,
+};

package/src/gep/prompt.js

@@ -266,6 +266,7 @@ function buildGepPrompt({
   recentHistory,
   failedCapsules,
   hubLessons,
+  strategyPolicy,
 }) {
   const parentValue = parentEventId ? `"${parentEventId}"` : 'null';
   const selectedGeneId = selectedGene && selectedGene.id ? selectedGene.id : 'gene_<name>';
@@ -289,6 +290,15 @@ ACTIVE STRATEGY (Generic):
 3. Apply minimal, safe changes.
 4. Validate changes strictly.
 5. Solidify knowledge.
+`.trim();
+  }
+  let strategyPolicyBlock = '';
+  if (strategyPolicy && Array.isArray(strategyPolicy.directives) && strategyPolicy.directives.length > 0) {
+    strategyPolicyBlock = `
+ADAPTIVE STRATEGY POLICY:
+${strategyPolicy.directives.map((s, i) => `${i + 1}. ${s}`).join('\n')}
+${strategyPolicy.forceInnovate ? 'You MUST prefer INNOVATE unless a critical blocking error is present.' : ''}
+${strategyPolicy.cautiousExecution ? 'You MUST reduce blast radius and avoid broad refactors in this cycle.' : ''}
 `.trim();
   }
   
@@ -384,6 +394,7 @@ II. Directives & Logic
 
 2. Selection: Selected Gene "${selectedGeneId}".
 ${strategyBlock}
+${strategyPolicyBlock ? '\n' + strategyPolicyBlock : ''}
 
 3. Execution: Apply changes (tool calls). Repair/Optimize: small/reversible. Innovate: new skills in \`skills/<name>/\`.
 4. Validation: Run gene's validation steps. Fail = ROLLBACK.

package/src/gep/selector.js

@@ -1,3 +1,6 @@
+const { scoreTagOverlap } = require('./learningSignals');
+const { captureEnvFingerprint } = require('./envFingerprint');
+
 function matchPatternToSignals(pattern, signals) {
   if (!pattern || !signals || signals.length === 0) return false;
   const p = String(pattern);
@@ -30,12 +33,54 @@ function matchPatternToSignals(pattern, signals) {
 function scoreGene(gene, signals) {
   if (!gene || gene.type !== 'Gene') return 0;
   const patterns = Array.isArray(gene.signals_match) ? gene.signals_match : [];
-  if (patterns.length === 0) return 0;
+  var tagScore = scoreTagOverlap(gene, signals);
+  if (patterns.length === 0) return tagScore > 0 ? tagScore * 0.6 : 0;
   let score = 0;
   for (const pat of patterns) {
     if (matchPatternToSignals(pat, signals)) score += 1;
   }
-  return score;
+  return score + (tagScore * 0.6);
+}
+
+function getEpigeneticBoostLocal(gene, envFingerprint) {
+  if (!gene || !Array.isArray(gene.epigenetic_marks)) return 0;
+  const platform = envFingerprint && envFingerprint.platform ? String(envFingerprint.platform) : '';
+  const arch = envFingerprint && envFingerprint.arch ? String(envFingerprint.arch) : '';
+  const nodeVersion = envFingerprint && envFingerprint.node_version ? String(envFingerprint.node_version) : '';
+  const envContext = [platform, arch, nodeVersion].filter(Boolean).join('/') || 'unknown';
+  const mark = gene.epigenetic_marks.find(function (m) { return m && m.context === envContext; });
+  return mark ? Number(mark.boost) || 0 : 0;
+}
+
+function scoreGeneLearning(gene, signals, envFingerprint) {
+  if (!gene || gene.type !== 'Gene') return 0;
+  var boost = 0;
+
+  var history = Array.isArray(gene.learning_history) ? gene.learning_history.slice(-8) : [];
+  for (var i = 0; i < history.length; i++) {
+    var entry = history[i];
+    if (!entry) continue;
+    if (entry.outcome === 'success') boost += 0.12;
+    else if (entry.mode === 'hard') boost -= 0.22;
+    else if (entry.mode === 'soft') boost -= 0.08;
+  }
+
+  boost += getEpigeneticBoostLocal(gene, envFingerprint);
+
+  if (Array.isArray(gene.anti_patterns) && gene.anti_patterns.length > 0) {
+    var overlapPenalty = 0;
+    var signalTags = new Set(require('./learningSignals').expandSignals(signals, ''));
+    var recentAntiPatterns = gene.anti_patterns.slice(-6);
+    for (var j = 0; j < recentAntiPatterns.length; j++) {
+      var anti = recentAntiPatterns[j];
+      if (!anti || !Array.isArray(anti.learning_signals)) continue;
+      var overlap = anti.learning_signals.some(function (tag) { return signalTags.has(String(tag)); });
+      if (overlap) overlapPenalty += anti.mode === 'hard' ? 0.4 : 0.18;
+    }
+    boost -= overlapPenalty;
+  }
+
+  return Math.max(-1.5, Math.min(1.5, boost));
 }
 
 // Population-size-dependent drift intensity.
@@ -94,9 +139,11 @@ function selectGene(genes, signals, opts) {
   var DISTILLED_PREFIX = 'gene_distilled_';
   var DISTILLED_SCORE_FACTOR = 0.8;
 
+  const envFingerprint = captureEnvFingerprint();
   const scored = genesList
     .map(g => {
       var s = scoreGene(g, signals);
+      s += scoreGeneLearning(g, signals, envFingerprint);
       if (s > 0 && g.id && String(g.id).startsWith(DISTILLED_PREFIX)) s *= DISTILLED_SCORE_FACTOR;
       return { gene: g, score: s };
     })

package/src/gep/skillDistiller.js

@@ -4,6 +4,7 @@ var fs = require('fs');
 var path = require('path');
 var crypto = require('crypto');
 var paths = require('./paths');
+var learningSignals = require('./learningSignals');
 
 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;
@@ -573,6 +574,126 @@ function prepareDistillation() {
   return { ok: true, promptPath: promptPath, requestPath: reqPath, dataHash: data.dataHash };
 }
 
+function inferCategoryFromSignals(signals) {
+  var 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) {
+  var grouped = data && data.grouped ? data.grouped : {};
+  var best = null;
+  Object.keys(grouped).forEach(function (geneId) {
+    var g = grouped[geneId];
+    if (!g || g.total_count <= 0) return;
+    var 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) {
+  var source = chooseDistillationSource(data, analysis);
+  if (!source || !source.group) return null;
+
+  var group = source.group;
+  var existing = Array.isArray(existingGenes) ? existingGenes : [];
+  var sourceGene = existing.find(function (g) { return g && g.id === source.gene_id; }) || null;
+
+  var triggerFreq = {};
+  (group.triggers || []).forEach(function (arr) {
+    (Array.isArray(arr) ? arr : []).forEach(function (s) {
+      var k = String(s).toLowerCase();
+      triggerFreq[k] = (triggerFreq[k] || 0) + 1;
+    });
+  });
+  var signalsMatch = Object.keys(triggerFreq)
+    .sort(function (a, b) { return triggerFreq[b] - triggerFreq[a]; })
+    .slice(0, 6);
+  var summaryText = (group.summaries || []).slice(0, 5).join(' ');
+  var 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);
+  }
+
+  var category = sourceGene && sourceGene.category ? sourceGene.category : inferCategoryFromSignals(signalsMatch);
+  var 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.',
+      ],
+  };
+
+  var summaryBase = (group.summaries && group.summaries[0]) ? String(group.summaries[0]) : '';
+  if (!summaryBase) {
+    summaryBase = 'Reusable strategy for repeated successful pattern: ' + signalsMatch.slice(0, 3).join(', ');
+  }
+
+  var 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) {
+  var 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
 // ---------------------------------------------------------------------------
@@ -665,11 +786,67 @@ function completeDistillation(responseText) {
   return { ok: true, gene: gene };
 }
 
+function autoDistill() {
+  var data = collectDistillationData();
+  if (data.successCapsules.length < DISTILLER_MIN_CAPSULES) {
+    return { ok: false, reason: 'insufficient_data' };
+  }
+
+  var state = readDistillerState();
+  if (state.last_data_hash === data.dataHash) {
+    return { ok: false, reason: 'idempotent_skip' };
+  }
+
+  var analysis = analyzePatterns(data);
+  var assetsDir = paths.getGepAssetsDir();
+  var existingGenesJson = readJsonIfExists(path.join(assetsDir, 'genes.json'), { genes: [] });
+  var existingGenes = existingGenesJson.genes || [];
+  var rawGene = synthesizeGeneFromPatterns(data, analysis, existingGenes);
+  if (!rawGene) return { ok: false, reason: 'no_candidate_gene' };
+
+  var 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 };
+  }
+
+  var gene = validation.gene;
+  gene._distilled_meta = {
+    distilled_at: new Date().toISOString(),
+    source_capsule_count: data.successCapsules.length,
+    data_hash: data.dataHash,
+    auto_distilled: true,
+  };
+
+  var 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,

package/src/gep/solidify.js

@@ -671,6 +671,108 @@ function buildFailureReason(constraintCheck, validation, protocolViolations, can
   return reasons.join('; ').slice(0, 2000) || 'unknown';
 }
 
+function buildSoftFailureLearningSignals(opts) {
+  const { expandSignals } = require('./learningSignals');
+  var signals = opts && Array.isArray(opts.signals) ? opts.signals : [];
+  var failureReason = opts && opts.failureReason ? String(opts.failureReason) : '';
+  var violations = opts && Array.isArray(opts.violations) ? opts.violations : [];
+  var validationResults = opts && Array.isArray(opts.validationResults) ? opts.validationResults : [];
+  var validationText = validationResults
+    .filter(function (r) { return r && r.ok === false; })
+    .map(function (r) { return [r.cmd, r.stderr, r.stdout].filter(Boolean).join(' '); })
+    .join(' ');
+  return expandSignals(signals.concat(violations), failureReason + ' ' + validationText)
+    .filter(function (tag) {
+      return tag.indexOf('problem:') === 0 || tag.indexOf('risk:') === 0 || tag.indexOf('area:') === 0 || tag.indexOf('action:') === 0;
+    });
+}
+
+function classifyFailureMode(opts) {
+  var constraintViolations = opts && Array.isArray(opts.constraintViolations) ? opts.constraintViolations : [];
+  var protocolViolations = opts && Array.isArray(opts.protocolViolations) ? opts.protocolViolations : [];
+  var validation = opts && opts.validation ? opts.validation : null;
+  var canary = opts && opts.canary ? opts.canary : null;
+
+  if (constraintViolations.some(function (v) {
+    var s = String(v || '');
+    return /HARD CAP BREACH|CRITICAL_FILE_|critical_path_modified|forbidden_path touched|ethics:/i.test(s);
+  })) {
+    return { mode: 'hard', reasonClass: 'constraint_destructive', retryable: false };
+  }
+
+  if (protocolViolations.length > 0) {
+    return { mode: 'hard', reasonClass: 'protocol', retryable: false };
+  }
+
+  if (canary && !canary.ok && !canary.skipped) {
+    return { mode: 'hard', reasonClass: 'canary', retryable: false };
+  }
+
+  if (constraintViolations.length > 0) {
+    return { mode: 'hard', reasonClass: 'constraint', retryable: false };
+  }
+
+  if (validation && validation.ok === false) {
+    return { mode: 'soft', reasonClass: 'validation', retryable: true };
+  }
+
+  return { mode: 'soft', reasonClass: 'unknown', retryable: true };
+}
+
+function adaptGeneFromLearning(opts) {
+  var gene = opts && opts.gene && opts.gene.type === 'Gene' ? opts.gene : null;
+  if (!gene) return gene;
+
+  var outcomeStatus = String(opts && opts.outcomeStatus || '').toLowerCase();
+  var learningSignals = Array.isArray(opts && opts.learningSignals) ? opts.learningSignals : [];
+  var failureMode = opts && opts.failureMode && typeof opts.failureMode === 'object'
+    ? opts.failureMode
+    : { mode: 'soft', reasonClass: 'unknown', retryable: true };
+
+  if (!Array.isArray(gene.learning_history)) gene.learning_history = [];
+  if (!Array.isArray(gene.signals_match)) gene.signals_match = [];
+
+  var seenSignal = new Set(gene.signals_match.map(function (s) { return String(s); }));
+  if (outcomeStatus === 'success') {
+    for (var i = 0; i < learningSignals.length; i++) {
+      var sig = String(learningSignals[i] || '');
+      if (!sig || seenSignal.has(sig)) continue;
+      if (sig.indexOf('problem:') === 0 || sig.indexOf('area:') === 0) {
+        gene.signals_match.push(sig);
+        seenSignal.add(sig);
+      }
+    }
+  }
+
+  gene.learning_history.push({
+    at: nowIso(),
+    outcome: outcomeStatus || 'unknown',
+    mode: failureMode.mode || 'soft',
+    reason_class: failureMode.reasonClass || 'unknown',
+    retryable: !!failureMode.retryable,
+    learning_signals: learningSignals.slice(0, 12),
+  });
+  if (gene.learning_history.length > 20) {
+    gene.learning_history = gene.learning_history.slice(gene.learning_history.length - 20);
+  }
+
+  if (outcomeStatus === 'failed') {
+    if (!Array.isArray(gene.anti_patterns)) gene.anti_patterns = [];
+    var anti = {
+      at: nowIso(),
+      mode: failureMode.mode || 'soft',
+      reason_class: failureMode.reasonClass || 'unknown',
+      learning_signals: learningSignals.slice(0, 8),
+    };
+    gene.anti_patterns.push(anti);
+    if (gene.anti_patterns.length > 12) {
+      gene.anti_patterns = gene.anti_patterns.slice(gene.anti_patterns.length - 12);
+    }
+  }
+
+  return gene;
+}
+
 function rollbackTracked(repoRoot) {
   const mode = String(process.env.EVOLVER_ROLLBACK_MODE || 'hard').toLowerCase();
 
@@ -1157,6 +1259,23 @@ function solidify({ intent, summary, dryRun = false, rollbackOnFailure = true }
   const ts = nowIso();
   const outcomeStatus = success ? 'success' : 'failed';
   const score = clamp01(success ? 0.85 : 0.2);
+  const failureReason = !success ? buildFailureReason(constraintCheck, validation, protocolViolations, canary) : '';
+  const failureMode = !success
+    ? classifyFailureMode({
+        constraintViolations: constraintCheck.violations,
+        protocolViolations: protocolViolations,
+        validation: validation,
+        canary: canary,
+      })
+    : { mode: 'none', reasonClass: null, retryable: false };
+  const softFailureLearningSignals = !success
+    ? buildSoftFailureLearningSignals({
+        signals,
+        failureReason,
+        violations: constraintCheck.violations,
+        validationResults: validation.results,
+      })
+    : [];
 
   const selectedCapsuleId =
     lastRun && typeof lastRun.selected_capsule_id === 'string' && lastRun.selected_capsule_id.trim()
@@ -1224,6 +1343,12 @@ function solidify({ intent, summary, dryRun = false, rollbackOnFailure = true }
       protocol_ok: protocolViolations.length === 0,
       protocol_violations: protocolViolations,
       memory_graph: memoryGraphPath(),
+      soft_failure: success ? null : {
+        learning_signals: softFailureLearningSignals,
+        retryable: !!failureMode.retryable,
+        class: failureMode.reasonClass,
+        mode: failureMode.mode,
+      },
     },
   };
   // Build desensitized execution trace for cross-agent experience sharing
@@ -1303,7 +1428,8 @@ function solidify({ intent, summary, dryRun = false, rollbackOnFailure = true }
             ? 'Failed: ' + geneUsed.id + ' on signals [' + (signals.slice(0, 3).join(', ') || 'none') + ']'
             : 'Failed evolution on signals [' + (signals.slice(0, 3).join(', ') || 'none') + ']',
           diff_snapshot: diffSnapshot,
-          failure_reason: buildFailureReason(constraintCheck, validation, protocolViolations, canary),
+          failure_reason: failureReason,
+          learning_signals: softFailureLearningSignals,
           constraint_violations: constraintCheck.violations || [],
           env_fingerprint: envFp,
           blast_radius: { files: blast.files, lines: blast.lines },
@@ -1331,6 +1457,12 @@ function solidify({ intent, summary, dryRun = false, rollbackOnFailure = true }
   // Apply epigenetic marks to the gene based on outcome and environment
   if (!dryRun && geneUsed && geneUsed.type === 'Gene') {
     try {
+      adaptGeneFromLearning({
+        gene: geneUsed,
+        outcomeStatus: outcomeStatus,
+        learningSignals: success ? signals : softFailureLearningSignals,
+        failureMode: failureMode,
+      });
       applyEpigeneticMarks(geneUsed, envFp, outcomeStatus);
       upsertGene(geneUsed);
     } catch (e) {
@@ -1562,7 +1694,7 @@ function solidify({ intent, summary, dryRun = false, rollbackOnFailure = true }
   // which we already do above. The Hub-side solicitLesson() handles the rest.
   // For failures without a published event (no auto-publish), we still log locally.
   if (!dryRun && !success && event && event.outcome) {
-    var failureContent = buildFailureReason(constraintCheck, validation, protocolViolations, canary);
+    var failureContent = failureReason;
     event.failure_reason = failureContent;
     event.summary = geneUsed
       ? 'Failed: ' + geneUsed.id + ' on signals [' + (signals.slice(0, 3).join(', ') || 'none') + '] - ' + failureContent.slice(0, 200)
@@ -1708,6 +1840,9 @@ module.exports = {
   classifyBlastSeverity,
   analyzeBlastRadiusBreakdown,
   compareBlastEstimate,
+  classifyFailureMode,
+  adaptGeneFromLearning,
+  buildSoftFailureLearningSignals,
   runCanaryCheck,
   applyEpigeneticMarks,
   getEpigeneticBoost,