@evomap/evolver 1.29.0 → 1.29.2

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.2",
   "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/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 = {

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/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,158 @@
+'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('');
+    });
+  }
+
+  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,
+};