@evomap/evolver 1.29.0 → 1.29.4

package/index.js

@@ -24,6 +24,37 @@ function readJsonSafe(p) {
   }
 }
 
+function rejectPendingRun(statePath) {
+  try {
+    const { getRepoRoot } = require('./src/gep/paths');
+    const { execSync } = require('child_process');
+    const repoRoot = getRepoRoot();
+
+    execSync('git checkout -- .', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 });
+    execSync('git clean -fd', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 });
+  } catch (e) {
+    console.warn('[Loop] Pending run rollback failed: ' + (e.message || e));
+  }
+
+  try {
+    const state = readJsonSafe(statePath);
+    if (state && state.last_run && state.last_run.run_id) {
+      state.last_solidify = {
+        run_id: state.last_run.run_id,
+        rejected: true,
+        reason: 'loop_bridge_disabled_autoreject',
+        timestamp: new Date().toISOString(),
+      };
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+      return true;
+    }
+  } catch (e) {
+    console.warn('[Loop] Failed to clear pending run state: ' + (e.message || e));
+  }
+
+  return false;
+}
+
 function isPendingSolidify(state) {
   const lastRun = state && state.last_run ? state.last_run : null;
   const lastSolid = state && state.last_solidify ? state.last_solidify : null;
@@ -80,6 +111,16 @@ async function main() {
   const isLoop = args.includes('--loop') || args.includes('--mad-dog');
 
   if (command === 'run' || command === '/evolve' || isLoop) {
+    if (isLoop) {
+        const originalLog = console.log;
+        const originalWarn = console.warn;
+        const originalError = console.error;
+        function ts() { return '[' + new Date().toISOString() + ']'; }
+        console.log = (...args) => { originalLog.call(console, ts(), ...args); };
+        console.warn = (...args) => { originalWarn.call(console, ts(), ...args); };
+        console.error = (...args) => { originalError.call(console, ts(), ...args); };
+    }
+
     console.log('Starting capability evolver...');
     
     if (isLoop) {
@@ -137,6 +178,16 @@ async function main() {
           try {
             await evolve.run();
             ok = true;
+
+            if (String(process.env.EVOLVE_BRIDGE || '').toLowerCase() === 'false') {
+              const stAfterRun = readJsonSafe(solidifyStatePath);
+              if (isPendingSolidify(stAfterRun)) {
+                const cleared = rejectPendingRun(solidifyStatePath);
+                if (cleared) {
+                  console.warn('[Loop] Auto-rejected pending run because bridge is disabled in loop mode.');
+                }
+              }
+            }
           } catch (error) {
             const msg = error && error.message ? String(error.message) : String(error);
             console.error(`Evolution cycle failed: ${msg}`);

package/package.json

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

@@ -64,7 +64,9 @@ const TODAY_LOG = path.join(MEMORY_DIR, new Date().toISOString().split('T')[0] +
 // Ensure memory directory exists so state/cache writes work.
 try {
   if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
-} catch (e) {}
+} catch (e) {
+  console.warn('[Evolver] Failed to create MEMORY_DIR (may cause downstream errors):', e && e.message || e);
+}
 
 function formatSessionLog(jsonlContent) {
   const result = [];
@@ -1041,7 +1043,9 @@ async function run() {
       try {
         const { tryReadMemoryGraphEvents } = require('./gep/memoryGraph');
         taskMemoryEvents = tryReadMemoryGraphEvents(1000);
-      } catch {}
+      } catch (e) {
+        console.warn('[TaskReceiver] MemoryGraph read failed (task selection proceeds without history):', e && e.message || e);
+      }
       const best = selectBestTask(hubTasks, taskMemoryEvents);
       if (best) {
         const alreadyClaimed = best.status === 'claimed';
@@ -1085,7 +1089,9 @@ async function run() {
         }
       }
     }
-  } catch {}
+  } catch (e) {
+    console.warn('[Commitment] Overdue task check failed (non-fatal):', e && e.message || e);
+  }
 
   // --- Worker Pool: select task from heartbeat available_work (deferred claim) ---
   // Only remember the best task and inject its signals; actual claim+complete
@@ -1099,7 +1105,9 @@ async function run() {
         try {
           const { tryReadMemoryGraphEvents } = require('./gep/memoryGraph');
           taskMemoryEvents = tryReadMemoryGraphEvents(1000);
-        } catch {}
+        } catch (e) {
+          console.warn('[WorkerPool] MemoryGraph read failed (task selection proceeds without history):', e && e.message || e);
+        }
         const best = selectBestTask(workerTasks, taskMemoryEvents);
         if (best) {
           activeTask = best;
@@ -1174,7 +1182,9 @@ async function run() {
   for (const c of newCandidates) {
     try {
       appendCandidateJsonl(c);
-    } catch (e) {}
+    } catch (e) {
+      console.warn('[Candidates] Failed to persist candidate:', e && e.message || e);
+    }
   }
   const recentCandidates = readRecentCandidates(20);
   const capabilityCandidatesPreview = renderCandidatesPreview(recentCandidates.slice(-8), 1600);
@@ -1237,7 +1247,9 @@ async function run() {
         2
       )}\n\`\`\``;
     }
-  } catch (e) {}
+  } catch (e) {
+    console.warn('[ExternalCandidates] Preview build failed (non-fatal):', e && e.message || e);
+  }
 
   // Search-First Evolution: query Hub for reusable solutions before local reasoning.
   let hubHit = null;
@@ -1425,7 +1437,9 @@ async function run() {
         .split('\n')
         .map(l => l.trim())
         .filter(Boolean);
-    } catch (e) {}
+    } catch (e) {
+      console.warn('[SolidifyState] Failed to read baseline untracked files:', e && e.message || e);
+    }
 
     try {
       const out = execSync('git rev-parse HEAD', {
@@ -1436,7 +1450,9 @@ async function run() {
         windowsHide: true,
       });
       baselineHead = String(out || '').trim() || null;
-    } catch (e) {}
+    } catch (e) {
+      console.warn('[SolidifyState] Failed to read git HEAD:', e && e.message || e);
+    }
 
     const maxFiles =
       selectedGene && selectedGene.constraints && Number.isFinite(Number(selectedGene.constraints.max_files))

package/src/gep/a2aProtocol.js

@@ -172,20 +172,23 @@ function buildPublishBundle(opts) {
   if (!capsule || capsule.type !== 'Capsule' || !capsule.id) {
     throw new Error('publishBundle: capsule must be a valid Capsule with type and id');
   }
-  var geneAssetId = gene.asset_id || computeAssetId(gene);
-  var capsuleAssetId = capsule.asset_id || computeAssetId(capsule);
-  var nodeSecret = process.env.A2A_NODE_SECRET || getNodeId();
-  var signatureInput = [geneAssetId, capsuleAssetId].sort().join('|');
-  var signature = crypto.createHmac('sha256', nodeSecret).update(signatureInput).digest('hex');
   if (o.modelName && typeof o.modelName === 'string') {
     gene.model_name = o.modelName;
     capsule.model_name = o.modelName;
   }
+  gene.asset_id = computeAssetId(gene);
+  capsule.asset_id = computeAssetId(capsule);
+  var geneAssetId = gene.asset_id;
+  var capsuleAssetId = capsule.asset_id;
+  var nodeSecret = process.env.A2A_NODE_SECRET || getNodeId();
+  var signatureInput = [geneAssetId, capsuleAssetId].sort().join('|');
+  var signature = crypto.createHmac('sha256', nodeSecret).update(signatureInput).digest('hex');
   var assets = [gene, capsule];
   if (event && event.type === 'EvolutionEvent') {
     if (o.modelName && typeof o.modelName === 'string') {
       event.model_name = o.modelName;
     }
+    event.asset_id = computeAssetId(event);
     assets.push(event);
   }
   var publishPayload = {
@@ -396,6 +399,7 @@ var _heartbeatStartedAt = null;
 var _heartbeatConsecutiveFailures = 0;
 var _heartbeatTotalSent = 0;
 var _heartbeatTotalFailed = 0;
+var _heartbeatFpSent = false;
 var _latestAvailableWork = [];
 var _latestOverdueTasks = [];
 var _pendingCommitmentUpdates = [];
@@ -513,6 +517,16 @@ function sendHeartbeat() {
     meta.commitment_updates = _pendingCommitmentUpdates.splice(0);
   }
 
+  if (!_heartbeatFpSent) {
+    try {
+      var fp = captureEnvFingerprint();
+      if (fp && fp.evolver_version) {
+        meta.env_fingerprint = fp;
+        _heartbeatFpSent = true;
+      }
+    } catch {}
+  }
+
   if (Object.keys(meta).length > 0) {
     bodyObj.meta = meta;
   }

package/src/gep/assetStore.js

@@ -177,11 +177,27 @@ function readRecentCandidates(limit = 20) {
   try {
     const p = candidatesPath();
     if (!fs.existsSync(p)) return [];
-    const raw = fs.readFileSync(p, 'utf8');
-    const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
-    return lines.slice(Math.max(0, lines.length - limit)).map(l => {
-      try { return JSON.parse(l); } catch { return null; }
-    }).filter(Boolean);
+    const stat = fs.statSync(p);
+    if (stat.size < 1024 * 1024) {
+      const raw = fs.readFileSync(p, 'utf8');
+      const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+      return lines.slice(-limit).map(l => {
+        try { return JSON.parse(l); } catch { return null; }
+      }).filter(Boolean);
+    }
+    // Large file (>1MB): only read the tail to avoid OOM.
+    const fd = fs.openSync(p, 'r');
+    try {
+      const chunkSize = Math.min(stat.size, limit * 4096);
+      const buf = Buffer.alloc(chunkSize);
+      fs.readSync(fd, buf, 0, chunkSize, stat.size - chunkSize);
+      const lines = buf.toString('utf8').split('\n').map(l => l.trim()).filter(Boolean);
+      return lines.slice(-limit).map(l => {
+        try { return JSON.parse(l); } catch { return null; }
+      }).filter(Boolean);
+    } finally {
+      fs.closeSync(fd);
+    }
   } catch { return []; }
 }
 
@@ -189,11 +205,26 @@ function readRecentExternalCandidates(limit = 50) {
   try {
     const p = externalCandidatesPath();
     if (!fs.existsSync(p)) return [];
-    const raw = fs.readFileSync(p, 'utf8');
-    const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
-    return lines.slice(Math.max(0, lines.length - limit)).map(l => {
-      try { return JSON.parse(l); } catch { return null; }
-    }).filter(Boolean);
+    const stat = fs.statSync(p);
+    if (stat.size < 1024 * 1024) {
+      const raw = fs.readFileSync(p, 'utf8');
+      const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+      return lines.slice(-limit).map(l => {
+        try { return JSON.parse(l); } catch { return null; }
+      }).filter(Boolean);
+    }
+    const fd = fs.openSync(p, 'r');
+    try {
+      const chunkSize = Math.min(stat.size, limit * 4096);
+      const buf = Buffer.alloc(chunkSize);
+      fs.readSync(fd, buf, 0, chunkSize, stat.size - chunkSize);
+      const lines = buf.toString('utf8').split('\n').map(l => l.trim()).filter(Boolean);
+      return lines.slice(-limit).map(l => {
+        try { return JSON.parse(l); } catch { return null; }
+      }).filter(Boolean);
+    } finally {
+      fs.closeSync(fd);
+    }
   } catch { return []; }
 }
 

package/src/gep/envFingerprint.js

@@ -15,13 +15,28 @@ function captureEnvFingerprint() {
   const repoRoot = getRepoRoot();
   let pkgVersion = null;
   let pkgName = null;
+
+  // Read evolver's own package.json via __dirname so that npm-installed
+  // deployments report the correct evolver version. getRepoRoot() walks
+  // up to the nearest .git directory, which resolves to the HOST project
+  // when evolver is an npm dependency -- producing a wrong name/version.
+  const ownPkgPath = path.resolve(__dirname, '..', '..', 'package.json');
   try {
-    const raw = fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8');
+    const raw = fs.readFileSync(ownPkgPath, 'utf8');
     const pkg = JSON.parse(raw);
     pkgVersion = pkg && pkg.version ? String(pkg.version) : null;
     pkgName = pkg && pkg.name ? String(pkg.name) : null;
   } catch (e) {}
 
+  if (!pkgVersion) {
+    try {
+      const raw = fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8');
+      const pkg = JSON.parse(raw);
+      pkgVersion = pkg && pkg.version ? String(pkg.version) : null;
+      pkgName = pkg && pkg.name ? String(pkg.name) : null;
+    } catch (e) {}
+  }
+
   const region = (process.env.EVOLVER_REGION || '').trim().toLowerCase().slice(0, 5) || undefined;
 
   return {

package/src/gep/paths.js

@@ -6,16 +6,33 @@ function getRepoRoot() {
     return process.env.EVOLVER_REPO_ROOT;
   }
 
-  let dir = path.resolve(__dirname, '..', '..');
+  const ownDir = path.resolve(__dirname, '..', '..');
+
+  // Safety: check evolver's own directory first to prevent operating on a
+  // parent repo that happens to contain .git (which could cause data loss
+  // when git reset --hard runs in the wrong scope).
+  if (fs.existsSync(path.join(ownDir, '.git'))) {
+    return ownDir;
+  }
+
+  let dir = path.dirname(ownDir);
   while (dir !== '/' && dir !== '.') {
-    const gitDir = path.join(dir, '.git');
-    if (fs.existsSync(gitDir)) {
-      return dir;
+    if (fs.existsSync(path.join(dir, '.git'))) {
+      if (process.env.EVOLVER_USE_PARENT_GIT === 'true') {
+        console.warn('[evolver] Using parent git repository at:', dir);
+        return dir;
+      }
+      console.warn(
+        '[evolver] Detected .git in parent directory', dir,
+        '-- ignoring. Set EVOLVER_USE_PARENT_GIT=true to override,',
+        'or EVOLVER_REPO_ROOT to specify the target directory explicitly.'
+      );
+      return ownDir;
     }
     dir = path.dirname(dir);
   }
 
-  return path.resolve(__dirname, '..', '..');
+  return ownDir;
 }
 
 function getWorkspaceRoot() {

package/src/gep/skillDistiller.js

@@ -223,7 +223,7 @@ function buildDistillationPrompt(analysis, existingGenes, sampleCapsules) {
   });
 
   return [
-    'You are a Gene synthesis engine for the GEP (Genome Evolution Protocol).',
+    'You are a Gene synthesis engine for the GEP (Gene Expression Protocol).',
     '',
     'Analyze the following successful evolution capsules and extract a reusable Gene.',
     '',
@@ -476,6 +476,22 @@ function completeDistillation(responseText) {
   try { if (request.prompt_path) fs.unlinkSync(request.prompt_path); } catch (e) {}
 
   console.log('[Distiller] Distillation complete. New gene: ' + gene.id);
+
+  if (process.env.SKILL_AUTO_PUBLISH !== '0') {
+    try {
+      var 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));
+        } else {
+          console.warn('[Distiller] Skill publish failed: ' + (res.error || 'unknown'));
+        }
+      }).catch(function () {});
+    } catch (e) {
+      console.warn('[Distiller] Skill publisher unavailable: ' + e.message);
+    }
+  }
+
   return { ok: true, gene: gene };
 }
 

package/src/gep/skillPublisher.js

@@ -0,0 +1,163 @@
+'use strict';
+
+var { getHubUrl, buildHubHeaders, getNodeId } = require('./a2aProtocol');
+
+/**
+ * Convert a Gene object into SKILL.md format (Claude/Anthropic style).
+ *
+ * @param {object} gene - Gene asset
+ * @returns {string} SKILL.md content
+ */
+function geneToSkillMd(gene) {
+  var name = (gene.id || 'unnamed-skill').replace(/^gene_distilled_/, '').replace(/_/g, '-');
+  var desc = gene.summary || 'AI agent skill distilled from evolution experience.';
+
+  var lines = [
+    '---',
+    'name: ' + name,
+    'description: ' + desc,
+    '---',
+    '',
+    '# ' + name,
+    '',
+  ];
+
+  if (gene.signals_match && gene.signals_match.length > 0) {
+    lines.push('## Trigger Signals');
+    lines.push('');
+    gene.signals_match.forEach(function (s) {
+      lines.push('- `' + s + '`');
+    });
+    lines.push('');
+  }
+
+  if (gene.preconditions && gene.preconditions.length > 0) {
+    lines.push('## Preconditions');
+    lines.push('');
+    gene.preconditions.forEach(function (p) {
+      lines.push('- ' + p);
+    });
+    lines.push('');
+  }
+
+  if (gene.strategy && gene.strategy.length > 0) {
+    lines.push('## Strategy');
+    lines.push('');
+    gene.strategy.forEach(function (step, i) {
+      lines.push((i + 1) + '. ' + step);
+    });
+    lines.push('');
+  }
+
+  if (gene.constraints) {
+    lines.push('## Constraints');
+    lines.push('');
+    if (gene.constraints.max_files) {
+      lines.push('- Max files: ' + gene.constraints.max_files);
+    }
+    if (gene.constraints.forbidden_paths && gene.constraints.forbidden_paths.length > 0) {
+      lines.push('- Forbidden paths: ' + gene.constraints.forbidden_paths.join(', '));
+    }
+    lines.push('');
+  }
+
+  if (gene.validation && gene.validation.length > 0) {
+    lines.push('## Validation');
+    lines.push('');
+    gene.validation.forEach(function (cmd) {
+      lines.push('```bash');
+      lines.push(cmd);
+      lines.push('```');
+      lines.push('');
+    });
+  }
+
+  lines.push('---');
+  lines.push('');
+  lines.push('*This Skill was generated by [Evolver](https://github.com/autogame-17/evolver) and is distributed under the [EvoMap Skill License (ESL-1.0)](https://evomap.ai/terms). Unauthorized redistribution, bulk scraping, or republishing is prohibited. See LICENSE file for full terms.*');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Publish a Gene as a Skill to the Hub skill store.
+ *
+ * @param {object} gene - Gene asset
+ * @param {object} [opts] - { category, tags }
+ * @returns {Promise<{ok: boolean, result?: object, error?: string}>}
+ */
+function publishSkillToHub(gene, opts) {
+  opts = opts || {};
+  var hubUrl = getHubUrl();
+  if (!hubUrl) return Promise.resolve({ ok: false, error: 'no_hub_url' });
+
+  var content = geneToSkillMd(gene);
+  var nodeId = getNodeId();
+  var skillId = 'skill_' + (gene.id || 'unnamed').replace(/^gene_/, '');
+
+  var body = {
+    sender_id: nodeId,
+    skill_id: skillId,
+    content: content,
+    category: opts.category || gene.category || null,
+    tags: opts.tags || gene.signals_match || [],
+  };
+
+  var endpoint = hubUrl.replace(/\/+$/, '') + '/a2a/skill/store/publish';
+
+  return fetch(endpoint, {
+    method: 'POST',
+    headers: buildHubHeaders(),
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(15000),
+  })
+    .then(function (res) { return res.json().then(function (data) { return { status: res.status, data: data }; }); })
+    .then(function (result) {
+      if (result.status === 201 || result.status === 200) {
+        return { ok: true, result: result.data };
+      }
+      if (result.status === 409) {
+        return updateSkillOnHub(nodeId, skillId, content, opts, gene);
+      }
+      return { ok: false, error: result.data?.error || 'publish_failed', status: result.status };
+    })
+    .catch(function (err) {
+      return { ok: false, error: err.message };
+    });
+}
+
+/**
+ * Update an existing Skill on the Hub (new version).
+ */
+function updateSkillOnHub(nodeId, skillId, content, opts, gene) {
+  var hubUrl = getHubUrl();
+  if (!hubUrl) return Promise.resolve({ ok: false, error: 'no_hub_url' });
+
+  var body = {
+    sender_id: nodeId,
+    skill_id: skillId,
+    content: content,
+    category: opts.category || gene.category || null,
+    tags: opts.tags || gene.signals_match || [],
+    changelog: 'Iterative evolution update',
+  };
+
+  var endpoint = hubUrl.replace(/\/+$/, '') + '/a2a/skill/store/update';
+
+  return fetch(endpoint, {
+    method: 'PUT',
+    headers: buildHubHeaders(),
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(15000),
+  })
+    .then(function (res) { return res.json(); })
+    .then(function (data) { return { ok: true, result: data }; })
+    .catch(function (err) { return { ok: false, error: err.message }; });
+}
+
+module.exports = {
+  geneToSkillMd: geneToSkillMd,
+  publishSkillToHub: publishSkillToHub,
+  updateSkillOnHub: updateSkillOnHub,
+};