Release v1.34.1

Author: evolver-publish

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.34.0",
+  "version": "1.34.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": {

src/evolve.js

@@ -44,35 +44,35 @@ const { expandSignals } = require('./gep/learningSignals');
 
 const REPO_ROOT = getRepoRoot();
 
-// Verbose logging helper. Checks EVOLVER_VERBOSE env var (set by --verbose flag in index.js).
+// Verbose logging helper. Checks EVOLVER_VERBOSE env const (set by --verbose flag in index.js).
 function verbose() {
   if (String(process.env.EVOLVER_VERBOSE || '').toLowerCase() !== 'true') return;
-  var args = Array.prototype.slice.call(arguments);
+  const args = Array.prototype.slice.call(arguments);
   args.unshift('[Verbose]');
   console.log.apply(console, args);
 }
 
 // Idle-cycle gating: track last Hub fetch to avoid redundant API calls during saturation.
 // When evolver is saturated (no actionable signals), Hub calls are throttled to at most
 // once per EVOLVER_IDLE_FETCH_INTERVAL_MS (default 30 min) instead of every cycle.
-var _lastHubFetchMs = 0;
+let _lastHubFetchMs = 0;
 
 function shouldSkipHubCalls(signals) {
   if (!Array.isArray(signals)) return false;
-  var saturationIndicators = ['force_steady_state', 'evolution_saturation', 'empty_cycle_loop_detected'];
-  var hasSaturation = false;
-  for (var si = 0; si < saturationIndicators.length; si++) {
+  const saturationIndicators = ['force_steady_state', 'evolution_saturation', 'empty_cycle_loop_detected'];
+  let hasSaturation = false;
+  for (let si = 0; si < saturationIndicators.length; si++) {
     if (signals.indexOf(saturationIndicators[si]) !== -1) { hasSaturation = true; break; }
   }
   if (!hasSaturation) return false;
 
-  var actionablePatterns = [
+  const actionablePatterns = [
     'log_error', 'recurring_error', 'capability_gap', 'perf_bottleneck',
     'external_task', 'bounty_task', 'overdue_task', 'urgent',
     'unsupported_input_type',
   ];
-  for (var ai = 0; ai < signals.length; ai++) {
-    var s = signals[ai];
+  for (let ai = 0; ai < signals.length; ai++) {
+    const s = signals[ai];
     if (actionablePatterns.indexOf(s) !== -1) return false;
     if (s.indexOf('errsig:') === 0) return false;
     if (s.indexOf('user_feature_request:') === 0 && s.length > 21) return false;
@@ -556,14 +556,14 @@ function getMutationDirective(logContent) {
 
 const STATE_FILE = path.join(getEvolutionDir(), 'evolution_state.json');
 const DORMANT_HYPOTHESIS_FILE = path.join(getEvolutionDir(), 'dormant_hypothesis.json');
-var DORMANT_TTL_MS = 3600 * 1000;
+const DORMANT_TTL_MS = 3600 * 1000;
 
 function writeDormantHypothesis(data) {
   try {
-    var dir = getEvolutionDir();
+    const dir = getEvolutionDir();
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    var obj = Object.assign({}, data, { created_at: new Date().toISOString(), ttl_ms: DORMANT_TTL_MS });
-    var tmp = DORMANT_HYPOTHESIS_FILE + '.tmp';
+    const obj = Object.assign({}, data, { created_at: new Date().toISOString(), ttl_ms: DORMANT_TTL_MS });
+    const tmp = DORMANT_HYPOTHESIS_FILE + '.tmp';
     fs.writeFileSync(tmp, JSON.stringify(obj, null, 2) + '\n', 'utf8');
     fs.renameSync(tmp, DORMANT_HYPOTHESIS_FILE);
     console.log('[DormantHypothesis] Saved partial state before backoff: ' + (data.backoff_reason || 'unknown'));
@@ -575,11 +575,11 @@ function writeDormantHypothesis(data) {
 function readDormantHypothesis() {
   try {
     if (!fs.existsSync(DORMANT_HYPOTHESIS_FILE)) return null;
-    var raw = fs.readFileSync(DORMANT_HYPOTHESIS_FILE, 'utf8');
+    const raw = fs.readFileSync(DORMANT_HYPOTHESIS_FILE, 'utf8');
     if (!raw.trim()) return null;
-    var obj = JSON.parse(raw);
-    var createdAt = obj.created_at ? new Date(obj.created_at).getTime() : 0;
-    var ttl = Number.isFinite(Number(obj.ttl_ms)) ? Number(obj.ttl_ms) : DORMANT_TTL_MS;
+    const obj = JSON.parse(raw);
+    const createdAt = obj.created_at ? new Date(obj.created_at).getTime() : 0;
+    const ttl = Number.isFinite(Number(obj.ttl_ms)) ? Number(obj.ttl_ms) : DORMANT_TTL_MS;
     if (Date.now() - createdAt > ttl) {
       clearDormantHypothesis();
       console.log('[DormantHypothesis] Expired (age: ' + Math.round((Date.now() - createdAt) / 1000) + 's). Discarded.');
@@ -974,7 +974,7 @@ async function run() {
     return;
   }
 
-  var dormantHypothesis = readDormantHypothesis();
+  const dormantHypothesis = readDormantHypothesis();
   if (dormantHypothesis) {
     console.log('[DormantHypothesis] Recovered partial state from previous backoff: ' + (dormantHypothesis.backoff_reason || 'unknown'));
     clearDormantHypothesis();
@@ -1186,9 +1186,9 @@ async function run() {
   verbose('Recent events: ' + recentEvents.length + ', session log size: ' + recentMasterLog.length + ' chars');
 
   if (dormantHypothesis && Array.isArray(dormantHypothesis.signals) && dormantHypothesis.signals.length > 0) {
-    var dormantSignals = dormantHypothesis.signals;
-    var injected = 0;
-    for (var dsi = 0; dsi < dormantSignals.length; dsi++) {
+    const dormantSignals = dormantHypothesis.signals;
+    let injected = 0;
+    for (let dsi = 0; dsi < dormantSignals.length; dsi++) {
       if (!signals.includes(dormantSignals[dsi])) {
         signals.push(dormantSignals[dsi]);
         injected++;
@@ -1200,12 +1200,12 @@ async function run() {
   }
 
   // --- Idle-cycle gating: skip Hub API calls during saturation to save credits ---
-  var _idleFetchInterval = parseInt(String(process.env.EVOLVER_IDLE_FETCH_INTERVAL_MS || ''), 10);
+  let _idleFetchInterval = parseInt(String(process.env.EVOLVER_IDLE_FETCH_INTERVAL_MS || ''), 10);
   if (!Number.isFinite(_idleFetchInterval) || _idleFetchInterval <= 0) _idleFetchInterval = 1800000;
-  var skipHubCalls = false;
+  let skipHubCalls = false;
 
   if (shouldSkipHubCalls(signals)) {
-    var _elapsed = Date.now() - _lastHubFetchMs;
+    const _elapsed = Date.now() - _lastHubFetchMs;
     if (_lastHubFetchMs > 0 && _elapsed < _idleFetchInterval) {
       skipHubCalls = true;
       console.log('[IdleGating] Saturated with no actionable signals. Skipping Hub API calls (last fetch ' + Math.round(_elapsed / 1000) + 's ago, threshold ' + Math.round(_idleFetchInterval / 1000) + 's).');
@@ -1543,18 +1543,18 @@ async function run() {
     console.log('[Reflection] Failed (non-fatal): ' + (e && e.message ? e.message : e));
   }
 
-  var recentFailedCapsules = [];
+  let recentFailedCapsules = [];
   try {
     recentFailedCapsules = readRecentFailedCapsules(50);
   } catch (e) {
     console.log('[FailedCapsules] Read failed (non-fatal): ' + e.message);
   }
 
   // Heartbeat hints: novelty score and capability gaps for diversity-directed drift
-  var heartbeatNovelty = null;
-  var heartbeatCapGaps = [];
+  let heartbeatNovelty = null;
+  let heartbeatCapGaps = [];
   try {
-    var { getNoveltyHint, getCapabilityGaps: getCapGaps } = require('./gep/a2aProtocol');
+    const { getNoveltyHint, getCapabilityGaps: getCapGaps } = require('./gep/a2aProtocol');
     heartbeatNovelty = getNoveltyHint();
     heartbeatCapGaps = getCapGaps() || [];
   } catch (e) {}

src/gep/selector.js

@@ -33,7 +33,7 @@ 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 : [];
-  var tagScore = scoreTagOverlap(gene, signals);
+  const tagScore = scoreTagOverlap(gene, signals);
   if (patterns.length === 0) return tagScore > 0 ? tagScore * 0.6 : 0;
   let score = 0;
   for (const pat of patterns) {
@@ -54,11 +54,11 @@ function getEpigeneticBoostLocal(gene, envFingerprint) {
 
 function scoreGeneLearning(gene, signals, envFingerprint) {
   if (!gene || gene.type !== 'Gene') return 0;
-  var boost = 0;
+  let 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];
+  const history = Array.isArray(gene.learning_history) ? gene.learning_history.slice(-8) : [];
+  for (let i = 0; i < history.length; i++) {
+    const entry = history[i];
     if (!entry) continue;
     if (entry.outcome === 'success') boost += 0.12;
     else if (entry.mode === 'hard') boost -= 0.22;
@@ -68,13 +68,13 @@ function scoreGeneLearning(gene, signals, envFingerprint) {
   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];
+    let overlapPenalty = 0;
+    const signalTags = new Set(require('./learningSignals').expandSignals(signals, ''));
+    const recentAntiPatterns = gene.anti_patterns.slice(-6);
+    for (let j = 0; j < recentAntiPatterns.length; j++) {
+      const anti = recentAntiPatterns[j];
       if (!anti || !Array.isArray(anti.learning_signals)) continue;
-      var overlap = anti.learning_signals.some(function (tag) { return signalTags.has(String(tag)); });
+      const overlap = anti.learning_signals.some(function (tag) { return signalTags.has(String(tag)); });
       if (overlap) overlapPenalty += anti.mode === 'hard' ? 0.4 : 0.18;
     }
     boost -= overlapPenalty;
@@ -90,19 +90,19 @@ function scoreGeneLearning(gene, signals, envFingerprint) {
 // This replaces the binary driftEnabled flag with a continuous spectrum.
 function computeDriftIntensity(opts) {
   // If explicitly enabled/disabled, use that as the baseline
-  var driftEnabled = !!(opts && opts.driftEnabled);
+  const driftEnabled = !!(opts && opts.driftEnabled);
 
   // Effective population size: active gene count in the pool
-  var effectivePopulationSize = opts && Number.isFinite(Number(opts.effectivePopulationSize))
+  const effectivePopulationSize = opts && Number.isFinite(Number(opts.effectivePopulationSize))
     ? Number(opts.effectivePopulationSize)
     : null;
 
   // If no Ne provided, fall back to gene pool size
-  var genePoolSize = opts && Number.isFinite(Number(opts.genePoolSize))
+  const genePoolSize = opts && Number.isFinite(Number(opts.genePoolSize))
     ? Number(opts.genePoolSize)
     : null;
 
-  var ne = effectivePopulationSize || genePoolSize || null;
+  const ne = effectivePopulationSize || genePoolSize || null;
 
   if (driftEnabled) {
     // Explicit drift: use moderate-to-high intensity
@@ -125,24 +125,24 @@ function selectGene(genes, signals, opts) {
   const preferredGeneId = opts && typeof opts.preferredGeneId === 'string' ? opts.preferredGeneId : null;
 
   // Diversity-directed drift: capability_gaps from Hub heartbeat
-  var capabilityGaps = opts && Array.isArray(opts.capabilityGaps) ? opts.capabilityGaps : [];
-  var noveltyScore = opts && Number.isFinite(Number(opts.noveltyScore)) ? Number(opts.noveltyScore) : null;
+  const capabilityGaps = opts && Array.isArray(opts.capabilityGaps) ? opts.capabilityGaps : [];
+  const noveltyScore = opts && Number.isFinite(Number(opts.noveltyScore)) ? Number(opts.noveltyScore) : null;
 
   // Compute continuous drift intensity based on effective population size
-  var driftIntensity = computeDriftIntensity({
+  const driftIntensity = computeDriftIntensity({
     driftEnabled: driftEnabled,
     effectivePopulationSize: opts && opts.effectivePopulationSize,
     genePoolSize: genesList.length,
   });
-  var useDrift = driftEnabled || driftIntensity > 0.15;
+  const useDrift = driftEnabled || driftIntensity > 0.15;
 
-  var DISTILLED_PREFIX = 'gene_distilled_';
-  var DISTILLED_SCORE_FACTOR = 0.8;
+  const DISTILLED_PREFIX = 'gene_distilled_';
+  const DISTILLED_SCORE_FACTOR = 0.8;
 
   const envFingerprint = captureEnvFingerprint();
   const scored = genesList
     .map(g => {
-      var s = scoreGene(g, signals);
+      let 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 };
@@ -174,26 +174,26 @@ function selectGene(genes, signals, opts) {
   // Diversity-directed drift: when capability gaps are available, prefer genes that
   // cover gap areas instead of pure random selection. This replaces the blind
   // random drift with an informed exploration toward under-covered capabilities.
-  var selectedIdx = 0;
-  var driftMode = 'selection';
+  let selectedIdx = 0;
+  let driftMode = 'selection';
   if (driftIntensity > 0 && filtered.length > 1 && Math.random() < driftIntensity) {
     if (capabilityGaps.length > 0) {
       // Directed drift: score each candidate by how well its signals_match
       // covers the capability gap dimensions
-      var gapScores = filtered.map(function(entry, idx) {
-        var g = entry.gene;
-        var patterns = Array.isArray(g.signals_match) ? g.signals_match : [];
-        var gapHits = 0;
-        for (var gi = 0; gi < capabilityGaps.length && gi < 5; gi++) {
-          var gapSignal = capabilityGaps[gi];
+      const gapScores = filtered.map(function(entry, idx) {
+        const g = entry.gene;
+        const patterns = Array.isArray(g.signals_match) ? g.signals_match : [];
+        let gapHits = 0;
+        for (let gi = 0; gi < capabilityGaps.length && gi < 5; gi++) {
+          const gapSignal = capabilityGaps[gi];
           if (typeof gapSignal === 'string' && patterns.some(function(p) { return matchPatternToSignals(p, [gapSignal]); })) {
             gapHits++;
           }
         }
         return { idx: idx, gapHits: gapHits, baseScore: entry.score };
       });
 
-      var hasGapHits = gapScores.some(function(gs) { return gs.gapHits > 0; });
+      const hasGapHits = gapScores.some(function(gs) { return gs.gapHits > 0; });
       if (hasGapHits) {
         // Sort by gap coverage first, then by base score
         gapScores.sort(function(a, b) {
@@ -203,7 +203,7 @@ function selectGene(genes, signals, opts) {
         driftMode = 'diversity_directed';
       } else {
         // No gap match: fall back to novelty-weighted random selection
-        var topN = Math.min(filtered.length, Math.max(2, Math.ceil(filtered.length * driftIntensity)));
+        let topN = Math.min(filtered.length, Math.max(2, Math.ceil(filtered.length * driftIntensity)));
         // If novelty score is low (agent is too similar to others), increase exploration range
         if (noveltyScore != null && noveltyScore < 0.3 && topN < filtered.length) {
           topN = Math.min(filtered.length, topN + 1);
@@ -213,7 +213,7 @@ function selectGene(genes, signals, opts) {
       }
     } else {
       // No capability gap data: original random drift behavior
-      var topN = Math.min(filtered.length, Math.max(2, Math.ceil(filtered.length * driftIntensity)));
+      const topN = Math.min(filtered.length, Math.max(2, Math.ceil(filtered.length * driftIntensity)));
       selectedIdx = Math.floor(Math.random() * topN);
       driftMode = 'random';
     }
@@ -242,31 +242,31 @@ function selectCapsule(capsules, signals) {
 function computeSignalOverlap(signalsA, signalsB) {
   if (!Array.isArray(signalsA) || !Array.isArray(signalsB)) return 0;
   if (signalsA.length === 0 || signalsB.length === 0) return 0;
-  var setB = new Set(signalsB.map(function (s) { return String(s).toLowerCase(); }));
-  var hits = 0;
-  for (var i = 0; i < signalsA.length; i++) {
+  const setB = new Set(signalsB.map(function (s) { return String(s).toLowerCase(); }));
+  let hits = 0;
+  for (let i = 0; i < signalsA.length; i++) {
     if (setB.has(String(signalsA[i]).toLowerCase())) hits++;
   }
   return hits / Math.max(signalsA.length, 1);
 }
 
-var FAILED_CAPSULE_BAN_THRESHOLD = 2;
-var FAILED_CAPSULE_OVERLAP_MIN = 0.6;
+const FAILED_CAPSULE_BAN_THRESHOLD = 2;
+const FAILED_CAPSULE_OVERLAP_MIN = 0.6;
 
 function banGenesFromFailedCapsules(failedCapsules, signals, existingBans) {
-  var bans = existingBans instanceof Set ? new Set(existingBans) : new Set();
+  const bans = existingBans instanceof Set ? new Set(existingBans) : new Set();
   if (!Array.isArray(failedCapsules) || failedCapsules.length === 0) return bans;
-  var geneFailCounts = {};
-  for (var i = 0; i < failedCapsules.length; i++) {
-    var fc = failedCapsules[i];
+  const geneFailCounts = {};
+  for (let i = 0; i < failedCapsules.length; i++) {
+    const fc = failedCapsules[i];
     if (!fc || !fc.gene) continue;
-    var overlap = computeSignalOverlap(signals, fc.trigger || []);
+    const overlap = computeSignalOverlap(signals, fc.trigger || []);
     if (overlap < FAILED_CAPSULE_OVERLAP_MIN) continue;
-    var gid = String(fc.gene);
+    const gid = String(fc.gene);
     geneFailCounts[gid] = (geneFailCounts[gid] || 0) + 1;
   }
-  var keys = Object.keys(geneFailCounts);
-  for (var j = 0; j < keys.length; j++) {
+  const keys = Object.keys(geneFailCounts);
+  for (let j = 0; j < keys.length; j++) {
     if (geneFailCounts[keys[j]] >= FAILED_CAPSULE_BAN_THRESHOLD) {
       bans.add(keys[j]);
     }
@@ -279,7 +279,7 @@ function selectGeneAndCapsule({ genes, capsules, signals, memoryAdvice, driftEna
     memoryAdvice && memoryAdvice.bannedGeneIds instanceof Set ? memoryAdvice.bannedGeneIds : new Set();
   const preferredGeneId = memoryAdvice && memoryAdvice.preferredGeneId ? memoryAdvice.preferredGeneId : null;
 
-  var effectiveBans = banGenesFromFailedCapsules(
+  const effectiveBans = banGenesFromFailedCapsules(
     Array.isArray(failedCapsules) ? failedCapsules : [],
     signals,
     bannedGeneIds