@evomap/evolver 1.29.9 → 1.31.0

package/index.js

@@ -2,8 +2,8 @@
 const evolve = require('./src/evolve');
 const { solidify } = require('./src/gep/solidify');
 const path = require('path');
-// Hardened Env Loading: Ensure .env is loaded before anything else
-try { require('dotenv').config({ path: path.resolve(__dirname, './.env') }); } catch (e) { console.warn('[Evolver] Warning: dotenv not found or failed to load .env'); }
+const { getRepoRoot } = require('./src/gep/paths');
+try { require('dotenv').config({ path: path.join(getRepoRoot(), '.env') }); } catch (e) { console.warn('[Evolver] Warning: dotenv not found or failed to load .env'); }
 const fs = require('fs');
 const { spawn } = require('child_process');
 
@@ -24,28 +24,24 @@ function readJsonSafe(p) {
   }
 }
 
+/**
+ * Mark a pending evolution run as rejected (state-only, no git rollback).
+ * @param {string} statePath - Path to evolution_solidify_state.json
+ * @returns {boolean} true if a pending run was found and rejected
+ */
 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',
+        reason: 'loop_bridge_disabled_autoreject_no_rollback',
         timestamp: new Date().toISOString(),
       };
-      fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+      const tmp = `${statePath}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf8');
+      fs.renameSync(tmp, statePath);
       return true;
     }
   } catch (e) {
@@ -131,8 +127,10 @@ async function main() {
         process.on('SIGTERM', () => { releaseLock(); process.exit(); });
 
         process.env.EVOLVE_LOOP = 'true';
-        process.env.EVOLVE_BRIDGE = 'false';
-        console.log('Loop mode enabled (internal daemon).');
+        if (!process.env.EVOLVE_BRIDGE) {
+          process.env.EVOLVE_BRIDGE = 'false';
+        }
+        console.log(`Loop mode enabled (internal daemon, bridge=${process.env.EVOLVE_BRIDGE}).`);
 
         const { getEvolutionDir } = require('./src/gep/paths');
         const solidifyStatePath = path.join(getEvolutionDir(), 'evolution_solidify_state.json');
@@ -184,7 +182,7 @@ async function main() {
               if (isPendingSolidify(stAfterRun)) {
                 const cleared = rejectPendingRun(solidifyStatePath);
                 if (cleared) {
-                  console.warn('[Loop] Auto-rejected pending run because bridge is disabled in loop mode.');
+                  console.warn('[Loop] Auto-rejected pending run because bridge is disabled in loop mode (state only, no rollback).');
                 }
               }
             }
@@ -285,11 +283,19 @@ async function main() {
       if (res && res.ok && !dryRun) {
         try {
           const { shouldDistill, prepareDistillation } = require('./src/gep/skillDistiller');
-          if (shouldDistill()) {
+          const { readStateForSolidify } = require('./src/gep/solidify');
+          const solidifyState = readStateForSolidify();
+          const count = solidifyState.solidify_count || 0;
+          const autoDistillInterval = 5;
+          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 prompt ready. Read the prompt file, process it with your LLM,');
+              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);
@@ -461,6 +467,112 @@ async function main() {
       console.log('To reject and rollback:   node index.js review --reject');
     }
 
+  } else if (command === 'fetch') {
+    let skillId = null;
+    const eqFlag = args.find(a => typeof a === 'string' && (a.startsWith('--skill=') || a.startsWith('-s=')));
+    if (eqFlag) {
+      skillId = eqFlag.split('=').slice(1).join('=');
+    } else {
+      const sIdx = args.indexOf('-s');
+      const longIdx = args.indexOf('--skill');
+      const flagIdx = sIdx !== -1 ? sIdx : longIdx;
+      if (flagIdx !== -1 && args[flagIdx + 1] && !String(args[flagIdx + 1]).startsWith('-')) {
+        skillId = args[flagIdx + 1];
+      }
+    }
+    if (!skillId) {
+      const positional = args[1];
+      if (positional && !String(positional).startsWith('-')) skillId = positional;
+    }
+
+    if (!skillId) {
+      console.error('Usage: evolver fetch --skill <skill_id>');
+      console.error('       evolver fetch -s <skill_id>');
+      process.exit(1);
+    }
+
+    const { getHubUrl, getNodeId, buildHubHeaders, sendHelloToHub, getHubNodeSecret } = require('./src/gep/a2aProtocol');
+
+    const hubUrl = getHubUrl();
+    if (!hubUrl) {
+      console.error('[fetch] A2A_HUB_URL is not configured.');
+      console.error('Set it via environment variable or .env file:');
+      console.error('  export A2A_HUB_URL=https://evomap.ai');
+      process.exit(1);
+    }
+
+    try {
+      if (!getHubNodeSecret()) {
+        console.log('[fetch] No node_secret found. Sending hello to Hub to register...');
+        const helloResult = await sendHelloToHub();
+        if (!helloResult || !helloResult.ok) {
+          console.error('[fetch] Failed to register with Hub:', helloResult && helloResult.error || 'unknown');
+          process.exit(1);
+        }
+        console.log('[fetch] Registered as ' + getNodeId());
+      }
+
+      const endpoint = hubUrl.replace(/\/+$/, '') + '/a2a/skill/store/' + encodeURIComponent(skillId) + '/download';
+      const nodeId = getNodeId();
+
+      console.log('[fetch] Downloading skill: ' + skillId);
+
+      const resp = await fetch(endpoint, {
+        method: 'POST',
+        headers: buildHubHeaders(),
+        body: JSON.stringify({ sender_id: nodeId }),
+        signal: AbortSignal.timeout(30000),
+      });
+
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => '');
+        let msg = 'HTTP ' + resp.status;
+        try { const j = JSON.parse(body); msg = j.error || j.message || msg; } catch (_) {}
+        console.error('[fetch] Download failed: ' + msg);
+        if (resp.status === 404) console.error('  Skill not found or not publicly available.');
+        if (resp.status === 401) console.error('  Authentication failed. Try deleting ~/.evomap/node_secret and retry.');
+        if (resp.status === 402) console.error('  Insufficient credits.');
+        process.exit(1);
+      }
+
+      const data = await resp.json();
+      const outFlag = args.find(a => typeof a === 'string' && a.startsWith('--out='));
+      const safeId = String(data.skill_id || skillId).replace(/[^a-zA-Z0-9_\-\.]/g, '_');
+      const outDir = outFlag
+        ? outFlag.slice('--out='.length)
+        : path.join('.', 'skills', safeId);
+
+      if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+      if (data.content) {
+        fs.writeFileSync(path.join(outDir, 'SKILL.md'), data.content, 'utf8');
+      }
+
+      const bundled = Array.isArray(data.bundled_files) ? data.bundled_files : [];
+      for (const file of bundled) {
+        if (!file || !file.name || typeof file.content !== 'string') continue;
+        const safeName = path.basename(file.name);
+        fs.writeFileSync(path.join(outDir, safeName), file.content, 'utf8');
+      }
+
+      console.log('[fetch] Skill downloaded to: ' + outDir);
+      console.log('  Name:    ' + (data.name || skillId));
+      console.log('  Version: ' + (data.version || '?'));
+      console.log('  Files:   SKILL.md' + (bundled.length > 0 ? ', ' + bundled.map(f => f.name).join(', ') : ''));
+      if (data.already_purchased) {
+        console.log('  Cost:    free (already purchased)');
+      } else {
+        console.log('  Cost:    ' + (data.credit_cost || 0) + ' credits');
+      }
+    } catch (error) {
+      if (error && error.name === 'TimeoutError') {
+        console.error('[fetch] Request timed out. Check your network and A2A_HUB_URL.');
+      } else {
+        console.error('[fetch] Error:', error && error.message || error);
+      }
+      process.exit(1);
+    }
+
   } else if (command === 'asset-log') {
     const { summarizeCallLog, readCallLog, getLogPath } = require('./src/gep/assetCallLog');
 
@@ -505,7 +617,10 @@ async function main() {
     }
 
   } else {
-    console.log(`Usage: node index.js [run|/evolve|solidify|review|distill|asset-log] [--loop]
+    console.log(`Usage: node index.js [run|/evolve|solidify|review|distill|fetch|asset-log] [--loop]
+  - fetch flags:
+    - --skill=<id> | -s <id>   (skill ID to download)
+    - --out=<dir>              (output directory, default: ./skills/<skill_id>)
   - solidify flags:
     - --dry-run
     - --no-rollback
@@ -528,3 +643,10 @@ async function main() {
 if (require.main === module) {
   main();
 }
+
+module.exports = {
+  main,
+  readJsonSafe,
+  rejectPendingRun,
+  isPendingSolidify,
+};

package/package.json

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

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
-const { getRepoRoot, getMemoryDir, getSessionScope } = require('./gep/paths');
+const { getRepoRoot, getWorkspaceRoot, getMemoryDir, getSessionScope } = require('./gep/paths');
 const { extractSignals } = require('./gep/signals');
 const {
   loadGenes,
@@ -59,6 +59,7 @@ const IS_RANDOM_DRIFT = ARGS.includes('--drift') || String(process.env.RANDOM_DR
 const MEMORY_DIR = getMemoryDir();
 const AGENT_NAME = process.env.AGENT_NAME || 'main';
 const AGENT_SESSIONS_DIR = path.join(os.homedir(), `.openclaw/agents/${AGENT_NAME}/sessions`);
+const CURSOR_TRANSCRIPTS_DIR = process.env.EVOLVER_CURSOR_TRANSCRIPTS_DIR || '';
 const TODAY_LOG = path.join(MEMORY_DIR, new Date().toISOString().split('T')[0] + '.md');
 
 // Ensure memory directory exists so state/cache writes work.
@@ -160,77 +161,177 @@ function formatSessionLog(jsonlContent) {
   return result.join('\n');
 }
 
-function readRealSessionLog() {
+function formatCursorTranscript(raw) {
+  const lines = raw.split('\n');
+  const result = [];
+  let skipUntilNextBlock = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Keep user messages and assistant text responses
+    if (trimmed === 'user:' || trimmed.startsWith('A:')) {
+      skipUntilNextBlock = false;
+      result.push(trimmed);
+      continue;
+    }
+
+    // Tool call lines: keep as compact markers, skip their parameter block
+    if (trimmed.startsWith('[Tool call]')) {
+      skipUntilNextBlock = true;
+      result.push(`[Tool call] ${trimmed.replace('[Tool call]', '').trim()}`);
+      continue;
+    }
+
+    // Tool result markers: skip their content (usually large and noisy)
+    if (trimmed.startsWith('[Tool result]')) {
+      skipUntilNextBlock = true;
+      continue;
+    }
+
+    if (skipUntilNextBlock) continue;
+
+    // Keep user query content and assistant text (skip XML tags like <user_query>)
+    if (trimmed.startsWith('<') && trimmed.endsWith('>')) continue;
+    if (trimmed) {
+      result.push(trimmed.slice(0, 300));
+    }
+  }
+
+  return result.join('\n');
+}
+
+function readCursorTranscripts() {
+  if (!CURSOR_TRANSCRIPTS_DIR) return '';
   try {
-    if (!fs.existsSync(AGENT_SESSIONS_DIR)) return '[NO SESSION LOGS FOUND]';
+    if (!fs.existsSync(CURSOR_TRANSCRIPTS_DIR)) return '';
 
     const now = Date.now();
-    const ACTIVE_WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours
+    const ACTIVE_WINDOW_MS = 24 * 60 * 60 * 1000;
     const TARGET_BYTES = 120000;
-    const PER_SESSION_BYTES = 20000; // Read tail of each active session
-
-    // Session scope isolation: when EVOLVER_SESSION_SCOPE is set,
-    // only read sessions whose filenames contain the scope identifier.
-    // This prevents cross-channel/cross-project memory contamination.
-    const sessionScope = getSessionScope();
+    const PER_FILE_BYTES = 20000;
+    const RECENCY_GUARD_MS = 30 * 1000;
 
-    // Find ALL active sessions (modified in last 24h), sorted newest first
     let files = fs
-      .readdirSync(AGENT_SESSIONS_DIR)
-      .filter(f => f.endsWith('.jsonl') && !f.includes('.lock'))
+      .readdirSync(CURSOR_TRANSCRIPTS_DIR)
+      .filter(f => f.endsWith('.txt') || f.endsWith('.jsonl'))
       .map(f => {
         try {
-          const st = fs.statSync(path.join(AGENT_SESSIONS_DIR, f));
+          const st = fs.statSync(path.join(CURSOR_TRANSCRIPTS_DIR, f));
           return { name: f, time: st.mtime.getTime(), size: st.size };
         } catch (e) {
           return null;
         }
       })
       .filter(f => f && (now - f.time) < ACTIVE_WINDOW_MS)
-      .sort((a, b) => b.time - a.time); // Newest first
-
-    if (files.length === 0) return '[NO JSONL FILES]';
-
-    // Skip evolver's own sessions to avoid self-reference loops
-    let nonEvolverFiles = files.filter(f => !f.name.startsWith('evolver_hand_'));
-
-    // Session scope filter: when scope is active, only include sessions
-    // whose filename contains the scope string (e.g., channel_123456.jsonl).
-    // If no sessions match the scope, fall back to all non-evolver sessions
-    // (graceful degradation -- better to evolve with global context than not at all).
-    if (sessionScope && nonEvolverFiles.length > 0) {
-      const scopeLower = sessionScope.toLowerCase();
-      const scopedFiles = nonEvolverFiles.filter(f => f.name.toLowerCase().includes(scopeLower));
-      if (scopedFiles.length > 0) {
-        nonEvolverFiles = scopedFiles;
-        console.log(`[SessionScope] Filtered to ${scopedFiles.length} session(s) matching scope "${sessionScope}".`);
-      } else {
-        console.log(`[SessionScope] No sessions match scope "${sessionScope}". Using all ${nonEvolverFiles.length} session(s) (fallback).`);
-      }
-    }
+      .sort((a, b) => b.time - a.time);
+
+    if (files.length === 0) return '';
 
-    const activeFiles = nonEvolverFiles.length > 0 ? nonEvolverFiles : files.slice(0, 1);
+    // Skip the most recently modified file if it was touched in the last 30s --
+    // it is likely the current active session that triggered this evolver run,
+    // reading it would cause self-referencing signal noise.
+    if (files.length > 1 && (now - files[0].time) < RECENCY_GUARD_MS) {
+      files = files.slice(1);
+    }
 
-    // Read from multiple active sessions (up to 6) to get a full picture
-    const maxSessions = Math.min(activeFiles.length, 6);
+    const maxFiles = Math.min(files.length, 6);
     const sections = [];
     let totalBytes = 0;
 
-    for (let i = 0; i < maxSessions && totalBytes < TARGET_BYTES; i++) {
-      const f = activeFiles[i];
+    for (let i = 0; i < maxFiles && totalBytes < TARGET_BYTES; i++) {
+      const f = files[i];
       const bytesLeft = TARGET_BYTES - totalBytes;
-      const readSize = Math.min(PER_SESSION_BYTES, bytesLeft);
-      const raw = readRecentLog(path.join(AGENT_SESSIONS_DIR, f.name), readSize);
-      const formatted = formatSessionLog(raw);
-      if (formatted.trim()) {
-        sections.push(`--- SESSION (${f.name}) ---\n${formatted}`);
-        totalBytes += formatted.length;
+      const readSize = Math.min(PER_FILE_BYTES, bytesLeft);
+      const raw = readRecentLog(path.join(CURSOR_TRANSCRIPTS_DIR, f.name), readSize);
+      if (raw.trim() && !raw.startsWith('[MISSING]')) {
+        const formatted = formatCursorTranscript(raw);
+        if (formatted.trim()) {
+          sections.push(`--- CURSOR SESSION (${f.name}) ---\n${formatted}`);
+          totalBytes += formatted.length;
+        }
       }
     }
 
-    let content = sections.join('\n\n');
+    return sections.join('\n\n');
+  } catch (e) {
+    console.warn(`[CursorTranscripts] Read failed: ${e.message}`);
+    return '';
+  }
+}
+
+function readRealSessionLog() {
+  try {
+    // Primary source: OpenClaw session logs (.jsonl)
+    if (fs.existsSync(AGENT_SESSIONS_DIR)) {
+      const now = Date.now();
+      const ACTIVE_WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours
+      const TARGET_BYTES = 120000;
+      const PER_SESSION_BYTES = 20000;
+
+      const sessionScope = getSessionScope();
+
+      let files = fs
+        .readdirSync(AGENT_SESSIONS_DIR)
+        .filter(f => f.endsWith('.jsonl') && !f.includes('.lock'))
+        .map(f => {
+          try {
+            const st = fs.statSync(path.join(AGENT_SESSIONS_DIR, f));
+            return { name: f, time: st.mtime.getTime(), size: st.size };
+          } catch (e) {
+            return null;
+          }
+        })
+        .filter(f => f && (now - f.time) < ACTIVE_WINDOW_MS)
+        .sort((a, b) => b.time - a.time);
+
+      if (files.length > 0) {
+        let nonEvolverFiles = files.filter(f => !f.name.startsWith('evolver_hand_'));
+
+        if (sessionScope && nonEvolverFiles.length > 0) {
+          const scopeLower = sessionScope.toLowerCase();
+          const scopedFiles = nonEvolverFiles.filter(f => f.name.toLowerCase().includes(scopeLower));
+          if (scopedFiles.length > 0) {
+            nonEvolverFiles = scopedFiles;
+            console.log(`[SessionScope] Filtered to ${scopedFiles.length} session(s) matching scope "${sessionScope}".`);
+          } else {
+            console.log(`[SessionScope] No sessions match scope "${sessionScope}". Using all ${nonEvolverFiles.length} session(s) (fallback).`);
+          }
+        }
 
-    return content;
+        const activeFiles = nonEvolverFiles.length > 0 ? nonEvolverFiles : files.slice(0, 1);
+
+        const maxSessions = Math.min(activeFiles.length, 6);
+        const sections = [];
+        let totalBytes = 0;
+
+        for (let i = 0; i < maxSessions && totalBytes < TARGET_BYTES; i++) {
+          const f = activeFiles[i];
+          const bytesLeft = TARGET_BYTES - totalBytes;
+          const readSize = Math.min(PER_SESSION_BYTES, bytesLeft);
+          const raw = readRecentLog(path.join(AGENT_SESSIONS_DIR, f.name), readSize);
+          const formatted = formatSessionLog(raw);
+          if (formatted.trim()) {
+            sections.push(`--- SESSION (${f.name}) ---\n${formatted}`);
+            totalBytes += formatted.length;
+          }
+        }
+
+        if (sections.length > 0) {
+          return sections.join('\n\n');
+        }
+      }
+    }
+
+    // Fallback: Cursor agent-transcripts (.txt)
+    const cursorContent = readCursorTranscripts();
+    if (cursorContent) {
+      console.log('[SessionFallback] Using Cursor agent-transcripts as session source.');
+      return cursorContent;
+    }
+
+    return '[NO SESSION LOGS FOUND]';
   } catch (e) {
     return `[ERROR READING SESSION LOGS: ${e.message}]`;
   }
@@ -391,7 +492,7 @@ function clearDormantHypothesis() {
 }
 // Read MEMORY.md and USER.md from the WORKSPACE root (not the evolver plugin dir).
 // This avoids symlink breakage if the target file is temporarily deleted.
-const WORKSPACE_ROOT = process.env.OPENCLAW_WORKSPACE || path.resolve(REPO_ROOT, '../..');
+const WORKSPACE_ROOT = getWorkspaceRoot();
 const ROOT_MEMORY = path.join(WORKSPACE_ROOT, 'MEMORY.md');
 const DIR_MEMORY = path.join(MEMORY_DIR, 'MEMORY.md');
 const MEMORY_FILE = fs.existsSync(ROOT_MEMORY) ? ROOT_MEMORY : (fs.existsSync(DIR_MEMORY) ? DIR_MEMORY : ROOT_MEMORY);
@@ -1307,6 +1408,15 @@ async function run() {
     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 = [];
+  try {
+    var { getNoveltyHint, getCapabilityGaps: getCapGaps } = require('./gep/a2aProtocol');
+    heartbeatNovelty = getNoveltyHint();
+    heartbeatCapGaps = getCapGaps() || [];
+  } catch (e) {}
+
   const { selectedGene, capsuleCandidates, selector } = selectGeneAndCapsule({
     genes,
     capsules,
@@ -1314,6 +1424,8 @@ async function run() {
     memoryAdvice,
     driftEnabled: IS_RANDOM_DRIFT,
     failedCapsules: recentFailedCapsules,
+    capabilityGaps: heartbeatCapGaps,
+    noveltyScore: heartbeatNovelty && Number.isFinite(heartbeatNovelty.score) ? heartbeatNovelty.score : null,
   });
 
   const selectedBy = memoryAdvice && memoryAdvice.preferredGeneId ? 'memory_graph+selector' : 'selector';
@@ -1420,7 +1532,6 @@ async function run() {
   try {
     const runId = `run_${Date.now()}`;
     const parentEventId = getLastEventId();
-    const selectedBy = memoryAdvice && memoryAdvice.preferredGeneId ? 'memory_graph+selector' : 'selector';
 
     // Baseline snapshot (before any edits).
     let baselineUntracked = [];

package/src/gep/a2aProtocol.js

@@ -402,6 +402,9 @@ var _heartbeatTotalFailed = 0;
 var _heartbeatFpSent = false;
 var _latestAvailableWork = [];
 var _latestOverdueTasks = [];
+var _latestSkillStoreHint = null;
+var _latestNoveltyHint = null;
+var _latestCapabilityGaps = [];
 var _pendingCommitmentUpdates = [];
 var _cachedHubNodeSecret = null;
 var _heartbeatIntervalMs = 0;
@@ -576,6 +579,21 @@ function sendHeartbeat() {
         _latestOverdueTasks = data.overdue_tasks;
         console.warn('[Commitment] ' + data.overdue_tasks.length + ' overdue task(s) detected via heartbeat.');
       }
+      if (data.skill_store) {
+        _latestSkillStoreHint = data.skill_store;
+        if (data.skill_store.eligible && data.skill_store.published_skills === 0) {
+          console.log('[Skill Store] ' + data.skill_store.hint);
+        }
+      }
+      if (data.novelty && typeof data.novelty === 'object') {
+        _latestNoveltyHint = data.novelty;
+      }
+      if (Array.isArray(data.capability_gaps) && data.capability_gaps.length > 0) {
+        _latestCapabilityGaps = data.capability_gaps;
+      }
+      if (data.circle_experience && typeof data.circle_experience === 'object') {
+        console.log('[EvolutionCircle] Active circle: ' + (data.circle_experience.circle_id || '?') + ' (' + (data.circle_experience.member_count || 0) + ' members)');
+      }
       _heartbeatConsecutiveFailures = 0;
       try {
         var logPath = getEvolverLogPath();
@@ -629,12 +647,24 @@ function getOverdueTasks() {
   return _latestOverdueTasks;
 }
 
+function getSkillStoreHint() {
+  return _latestSkillStoreHint;
+}
+
 function consumeOverdueTasks() {
   var tasks = _latestOverdueTasks;
   _latestOverdueTasks = [];
   return tasks;
 }
 
+function getNoveltyHint() {
+  return _latestNoveltyHint;
+}
+
+function getCapabilityGaps() {
+  return _latestCapabilityGaps;
+}
+
 /**
  * Queue a commitment deadline update to be sent with the next heartbeat.
  * @param {string} taskId
@@ -746,7 +776,11 @@ module.exports = {
   consumeAvailableWork,
   getOverdueTasks,
   consumeOverdueTasks,
+  getSkillStoreHint,
   queueCommitmentUpdate,
+  getHubUrl,
   getHubNodeSecret,
   buildHubHeaders,
+  getNoveltyHint,
+  getCapabilityGaps,
 };

package/src/gep/candidates.js

@@ -26,8 +26,12 @@ function extractToolCalls(transcript) {
   const lines = toLines(transcript);
   const calls = [];
   for (const line of lines) {
+    // OpenClaw format: [TOOL: Shell]
     const m = line.match(/\[TOOL:\s*([^\]]+)\]/i);
-    if (m && m[1]) calls.push(m[1].trim());
+    if (m && m[1]) { calls.push(m[1].trim()); continue; }
+    // Cursor transcript format: [Tool call] Shell
+    const m2 = line.match(/\[Tool call\]\s+(\S+)/i);
+    if (m2 && m2[1]) calls.push(m2[1].trim());
   }
   return calls;
 }

package/src/gep/executionTrace.js

@@ -0,0 +1,201 @@
+// Execution Trace: structured, desensitized evolution execution summary.
+// Built during solidify and optionally shared with Hub via EvolutionEvent payload.
+//
+// Desensitization rules (applied locally, never on Hub):
+// - File paths: basename + extension only (src/utils/retry.js -> retry.js)
+// - Code content: never sent, only statistical metrics (lines, files)
+// - Error messages: type signature only (TypeError: x is not a function -> TypeError)
+// - Environment variables, secrets, user data: stripped entirely
+// - Configurable via EVOLVER_TRACE_LEVEL: none | minimal | standard (default: minimal)
+
+const path = require('path');
+
+const TRACE_LEVELS = { none: 0, minimal: 1, standard: 2 };
+
+function getTraceLevel() {
+  const raw = String(process.env.EVOLVER_TRACE_LEVEL || 'minimal').toLowerCase().trim();
+  return TRACE_LEVELS[raw] != null ? raw : 'minimal';
+}
+
+function desensitizeFilePath(filePath) {
+  if (!filePath || typeof filePath !== 'string') return null;
+  const ext = path.extname(filePath);
+  const base = path.basename(filePath);
+  return base || ext || 'unknown';
+}
+
+function extractErrorSignature(errorText) {
+  if (!errorText || typeof errorText !== 'string') return null;
+  const text = errorText.trim();
+
+  // Match common error type patterns: TypeError, ReferenceError, SyntaxError, etc.
+  const jsError = text.match(/^((?:[A-Z][a-zA-Z]*)?Error)\b/);
+  if (jsError) return jsError[1];
+
+  // Match errno-style: ECONNRESET, ENOENT, EPERM, etc.
+  const errno = text.match(/\b(E[A-Z]{2,})\b/);
+  if (errno) return errno[1];
+
+  // Match HTTP status codes
+  const http = text.match(/\b((?:4|5)\d{2})\b/);
+  if (http) return 'HTTP_' + http[1];
+
+  // Fallback: first word if it looks like an error type
+  const firstWord = text.split(/[\s:]/)[0];
+  if (firstWord && firstWord.length <= 40 && /^[A-Z]/.test(firstWord)) return firstWord;
+
+  return 'UnknownError';
+}
+
+function inferToolChain(validationResults, blast) {
+  const tools = new Set();
+
+  if (blast && blast.files > 0) tools.add('file_edit');
+
+  if (Array.isArray(validationResults)) {
+    for (const r of validationResults) {
+      const cmd = String(r.cmd || '').trim();
+      if (cmd.startsWith('npm test') || cmd.includes('jest') || cmd.includes('mocha')) {
+        tools.add('test_run');
+      } else if (cmd.includes('lint') || cmd.includes('eslint')) {
+        tools.add('lint_check');
+      } else if (cmd.includes('validate') || cmd.includes('check')) {
+        tools.add('validation_run');
+      } else if (cmd.startsWith('node ')) {
+        tools.add('node_exec');
+      }
+    }
+  }
+
+  return Array.from(tools);
+}
+
+function classifyBlastLevel(blast) {
+  if (!blast) return 'unknown';
+  const files = Number(blast.files) || 0;
+  const lines = Number(blast.lines) || 0;
+  if (files <= 3 && lines <= 50) return 'low';
+  if (files <= 10 && lines <= 200) return 'medium';
+  return 'high';
+}
+
+function buildExecutionTrace({
+  gene,
+  mutation,
+  signals,
+  blast,
+  constraintCheck,
+  validation,
+  canary,
+  outcomeStatus,
+  startedAt,
+}) {
+  const level = getTraceLevel();
+  if (level === 'none') return null;
+
+  const trace = {
+    gene_id: gene && gene.id ? String(gene.id) : null,
+    mutation_category: (mutation && mutation.category) || (gene && gene.category) || null,
+    signals_matched: Array.isArray(signals) ? signals.slice(0, 10) : [],
+    outcome: outcomeStatus || 'unknown',
+  };
+
+  // Minimal level: core metrics only
+  trace.files_changed_count = blast ? Number(blast.files) || 0 : 0;
+  trace.lines_added = 0;
+  trace.lines_removed = 0;
+
+  // Compute added/removed from blast if available
+  if (blast && blast.lines) {
+    // blast.lines is total churn (added + deleted); split heuristically
+    const total = Number(blast.lines) || 0;
+    if (outcomeStatus === 'success') {
+      trace.lines_added = Math.round(total * 0.6);
+      trace.lines_removed = total - trace.lines_added;
+    } else {
+      trace.lines_added = Math.round(total * 0.5);
+      trace.lines_removed = total - trace.lines_added;
+    }
+  }
+
+  trace.validation_result = validation && validation.ok ? 'pass' : 'fail';
+  trace.blast_radius = classifyBlastLevel(blast);
+
+  // Standard level: richer context
+  if (level === 'standard') {
+    // Desensitized file list (basenames only)
+    if (blast && Array.isArray(blast.changed_files)) {
+      trace.file_types = {};
+      for (const f of blast.changed_files) {
+        const ext = path.extname(f) || '.unknown';
+        trace.file_types[ext] = (trace.file_types[ext] || 0) + 1;
+      }
+    }
+
+    // Validation commands (already safe -- node/npm/npx only)
+    if (validation && Array.isArray(validation.results)) {
+      trace.validation_commands = validation.results.map(r => String(r.cmd || '').slice(0, 100));
+    }
+
+    // Error signatures (desensitized)
+    trace.error_signatures = [];
+    if (constraintCheck && Array.isArray(constraintCheck.violations)) {
+      for (const v of constraintCheck.violations) {
+        // Constraint violations have known prefixes; classify directly
+        const vStr = String(v);
+        if (vStr.startsWith('max_files')) trace.error_signatures.push('max_files_exceeded');
+        else if (vStr.startsWith('forbidden_path')) trace.error_signatures.push('forbidden_path');
+        else if (vStr.startsWith('HARD CAP')) trace.error_signatures.push('hard_cap_breach');
+        else if (vStr.startsWith('CRITICAL')) trace.error_signatures.push('critical_overrun');
+        else if (vStr.startsWith('critical_path')) trace.error_signatures.push('critical_path_modified');
+        else if (vStr.startsWith('canary_failed')) trace.error_signatures.push('canary_failed');
+        else if (vStr.startsWith('ethics:')) trace.error_signatures.push('ethics_violation');
+        else {
+          const sig = extractErrorSignature(v);
+          if (sig) trace.error_signatures.push(sig);
+        }
+      }
+    }
+    if (validation && Array.isArray(validation.results)) {
+      for (const r of validation.results) {
+        if (!r.ok && r.err) {
+          const sig = extractErrorSignature(r.err);
+          if (sig && !trace.error_signatures.includes(sig)) {
+            trace.error_signatures.push(sig);
+          }
+        }
+      }
+    }
+    trace.error_signatures = trace.error_signatures.slice(0, 10);
+
+    // Tool chain inference
+    trace.tool_chain = inferToolChain(
+      validation && validation.results ? validation.results : [],
+      blast
+    );
+
+    // Duration
+    if (validation && validation.startedAt && validation.finishedAt) {
+      trace.validation_duration_ms = validation.finishedAt - validation.startedAt;
+    }
+
+    // Canary result
+    if (canary && !canary.skipped) {
+      trace.canary_ok = !!canary.ok;
+    }
+  }
+
+  // Timestamp
+  trace.created_at = new Date().toISOString();
+
+  return trace;
+}
+
+module.exports = {
+  buildExecutionTrace,
+  desensitizeFilePath,
+  extractErrorSignature,
+  inferToolChain,
+  classifyBlastLevel,
+  getTraceLevel,
+};

package/src/gep/hubSearch.js

@@ -6,6 +6,10 @@
 // Two-phase search-then-fetch to minimize credit cost:
 //   Phase 1: POST /a2a/fetch with signals + search_only=true (free, metadata only)
 //   Phase 2: POST /a2a/fetch with asset_ids=[selected] (pays for 1 asset only)
+//
+// Caching layers:
+//   1. Search cache: signal fingerprint -> Phase 1 results (avoids repeat searches)
+//   2. Payload cache: asset_id -> full payload (avoids repeat Phase 2 fetches)
 
 const { getNodeId, buildFetch, getHubNodeSecret } = require('./a2aProtocol');
 const { logAssetCall } = require('./assetCallLog');
@@ -13,7 +17,57 @@ const { logAssetCall } = require('./assetCallLog');
 const DEFAULT_MIN_REUSE_SCORE = 0.72;
 const DEFAULT_REUSE_MODE = 'reference'; // 'direct' | 'reference'
 const MAX_STREAK_CAP = 5;
-const TIMEOUT_REASON = 'hub_search_timeout';
+
+const SEARCH_CACHE_TTL_MS = 5 * 60 * 1000;
+const SEARCH_CACHE_MAX = 200;
+const PAYLOAD_CACHE_MAX = 100;
+const MIN_PHASE2_MS = 500;
+
+// --- In-memory caches (per-process lifetime, bounded) ---
+
+const _searchCache = new Map();   // cacheKey -> { ts, value: results[] }
+const _payloadCache = new Map();  // asset_id -> full payload object
+
+function _cacheKey(signals) {
+  return signals.slice().sort().join('|');
+}
+
+function _getSearchCache(key) {
+  const entry = _searchCache.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.ts > SEARCH_CACHE_TTL_MS) {
+    _searchCache.delete(key);
+    return null;
+  }
+  return entry.value;
+}
+
+function _setSearchCache(key, value) {
+  if (_searchCache.size >= SEARCH_CACHE_MAX) {
+    const oldest = _searchCache.keys().next().value;
+    _searchCache.delete(oldest);
+  }
+  _searchCache.set(key, { ts: Date.now(), value });
+}
+
+function _getPayloadCache(assetId) {
+  return _payloadCache.get(assetId) || null;
+}
+
+function _setPayloadCache(assetId, payload) {
+  if (_payloadCache.size >= PAYLOAD_CACHE_MAX) {
+    const oldest = _payloadCache.keys().next().value;
+    _payloadCache.delete(oldest);
+  }
+  _payloadCache.set(assetId, payload);
+}
+
+function clearCaches() {
+  _searchCache.clear();
+  _payloadCache.clear();
+}
+
+// --- Config helpers ---
 
 function getHubUrl() {
   return (process.env.A2A_HUB_URL || '').replace(/\/+$/, '');
@@ -29,6 +83,18 @@ function getMinReuseScore() {
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_MIN_REUSE_SCORE;
 }
 
+function _buildHeaders() {
+  const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
+  const secret = getHubNodeSecret();
+  if (secret) {
+    headers['Authorization'] = 'Bearer ' + secret;
+  } else {
+    const token = process.env.A2A_HUB_TOKEN;
+    if (token) headers['Authorization'] = `Bearer ${token}`;
+  }
+  return headers;
+}
+
 /**
  * Score a hub asset for local reuse quality.
  * rank = confidence * min(max(success_streak, 1), MAX_STREAK_CAP) * (reputation / 100)
@@ -77,7 +143,14 @@ function pickBestMatch(results, threshold) {
  *   Phase 1: search_only=true -> get candidate metadata (free, no credit cost)
  *   Phase 2: asset_ids=[best_match] -> fetch full payload for the selected asset only
  *
- * Falls back to single-call fetch (old behavior) if search_only is not supported.
+ * Caching:
+ *   - Phase 1 results are cached by signal fingerprint for 5 minutes.
+ *   - Phase 2 payloads are cached by asset_id indefinitely (bounded LRU).
+ *   - Both caches reduce Hub load and eliminate redundant network round-trips.
+ *
+ * Timeout: a single deadline spans both phases; Phase 2 is skipped if insufficient
+ * time remains (< 500ms).
+ *
  * Returns { hit: true, match, score, mode } or { hit: false }.
  */
 async function hubSearch(signals, opts) {
@@ -90,56 +163,53 @@ async function hubSearch(signals, opts) {
   if (signalList.length === 0) return { hit: false, reason: 'no_signals' };
 
   const threshold = (opts && Number.isFinite(opts.threshold)) ? opts.threshold : getMinReuseScore();
-  const timeout = (opts && Number.isFinite(opts.timeoutMs)) ? opts.timeoutMs : 8000;
+  const timeoutMs = (opts && Number.isFinite(opts.timeoutMs)) ? opts.timeoutMs : 8000;
+  const deadline = Date.now() + timeoutMs;
+  const runId = (opts && opts.run_id) || null;
 
   try {
-    // Phase 1: search_only to get candidate metadata (free)
-    const searchMsg = buildFetch({ signals: signalList, searchOnly: true });
     const endpoint = hubUrl + '/a2a/fetch';
+    const headers = _buildHeaders();
+    const cacheKey = _cacheKey(signalList);
 
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(TIMEOUT_REASON), timeout);
+    // --- Phase 1: search_only (free) ---
 
-    const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
-    const secret = getHubNodeSecret();
-    if (secret) {
-      headers['Authorization'] = 'Bearer ' + secret;
-    } else {
-      const token = process.env.A2A_HUB_TOKEN;
-      if (token) headers['Authorization'] = `Bearer ${token}`;
-    }
+    let results = _getSearchCache(cacheKey);
+    let cacheHit = !!results;
 
-    const res = await fetch(endpoint, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(searchMsg),
-      signal: controller.signal,
-    });
-    clearTimeout(timer);
+    if (!results) {
+      const searchMsg = buildFetch({ signals: signalList, searchOnly: true });
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), deadline - Date.now());
 
-    if (!res.ok) {
-      logAssetCall({
-        run_id: (opts && opts.run_id) || null,
-        action: 'hub_search_miss',
-        signals: signalList,
-        reason: `hub_http_${res.status}`,
-        via: 'search_then_fetch',
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(searchMsg),
+        signal: controller.signal,
       });
-      return { hit: false, reason: `hub_http_${res.status}` };
-    }
+      clearTimeout(timer);
+
+      if (!res.ok) {
+        logAssetCall({
+          run_id: runId, action: 'hub_search_miss', signals: signalList,
+          reason: `hub_http_${res.status}`, via: 'search_then_fetch',
+        });
+        return { hit: false, reason: `hub_http_${res.status}` };
+      }
 
-    const data = await res.json();
-    const results = (data && data.payload && Array.isArray(data.payload.results))
-      ? data.payload.results
-      : [];
+      const data = await res.json();
+      results = (data && data.payload && Array.isArray(data.payload.results))
+        ? data.payload.results
+        : [];
+
+      _setSearchCache(cacheKey, results);
+    }
 
     if (results.length === 0) {
       logAssetCall({
-        run_id: (opts && opts.run_id) || null,
-        action: 'hub_search_miss',
-        signals: signalList,
-        reason: 'no_results',
-        via: 'search_then_fetch',
+        run_id: runId, action: 'hub_search_miss', signals: signalList,
+        reason: 'no_results', via: 'search_then_fetch',
       });
       return { hit: false, reason: 'no_results' };
     }
@@ -147,9 +217,7 @@ async function hubSearch(signals, opts) {
     const pick = pickBestMatch(results, threshold);
     if (!pick) {
       logAssetCall({
-        run_id: (opts && opts.run_id) || null,
-        action: 'hub_search_miss',
-        signals: signalList,
+        run_id: runId, action: 'hub_search_miss', signals: signalList,
         reason: 'below_threshold',
         extra: { candidates: results.length, threshold },
         via: 'search_then_fetch',
@@ -157,40 +225,52 @@ async function hubSearch(signals, opts) {
       return { hit: false, reason: 'below_threshold', candidates: results.length };
     }
 
-    // Phase 2: fetch full payload for the selected asset only (pays for 1 asset)
+    // --- Phase 2: fetch full payload (paid, but free if already purchased) ---
+
     const selectedAssetId = pick.match.asset_id;
     if (selectedAssetId) {
-      try {
-        const fetchMsg = buildFetch({ assetIds: [selectedAssetId] });
-        const controller2 = new AbortController();
-        const timer2 = setTimeout(() => controller2.abort(TIMEOUT_REASON), timeout);
-
-        const res2 = await fetch(endpoint, {
-          method: 'POST',
-          headers,
-          body: JSON.stringify(fetchMsg),
-          signal: controller2.signal,
-        });
-        clearTimeout(timer2);
-
-        if (res2.ok) {
-          const data2 = await res2.json();
-          const fullResults = (data2 && data2.payload && Array.isArray(data2.payload.results))
-            ? data2.payload.results
-            : [];
-          if (fullResults.length > 0) {
-            pick.match = { ...pick.match, ...fullResults[0] };
+      const cachedPayload = _getPayloadCache(selectedAssetId);
+      if (cachedPayload) {
+        pick.match = { ...pick.match, ...cachedPayload };
+      } else {
+        const remaining = deadline - Date.now();
+        if (remaining > MIN_PHASE2_MS) {
+          try {
+            const fetchMsg = buildFetch({ assetIds: [selectedAssetId] });
+            const controller2 = new AbortController();
+            const timer2 = setTimeout(() => controller2.abort(), remaining);
+
+            const res2 = await fetch(endpoint, {
+              method: 'POST',
+              headers,
+              body: JSON.stringify(fetchMsg),
+              signal: controller2.signal,
+            });
+            clearTimeout(timer2);
+
+            if (res2.ok) {
+              const data2 = await res2.json();
+              const fullResults = (data2 && data2.payload && Array.isArray(data2.payload.results))
+                ? data2.payload.results
+                : [];
+              if (fullResults.length > 0) {
+                _setPayloadCache(selectedAssetId, fullResults[0]);
+                pick.match = { ...pick.match, ...fullResults[0] };
+              }
+            }
+          } catch (fetchErr) {
+            console.log(`[HubSearch] Phase 2 fetch failed (non-fatal): ${fetchErr.message}`);
           }
+        } else {
+          console.log(`[HubSearch] Phase 2 skipped: ${remaining}ms remaining < ${MIN_PHASE2_MS}ms threshold`);
         }
-      } catch (fetchErr) {
-        console.log(`[HubSearch] Phase 2 fetch failed (non-fatal): ${fetchErr.message}`);
       }
     }
 
-    console.log(`[HubSearch] Hit via search+fetch: ${pick.match.asset_id || 'unknown'} (score=${pick.score}, mode=${pick.mode})`);
+    console.log(`[HubSearch] Hit via search+fetch: ${pick.match.asset_id || 'unknown'} (score=${pick.score}, mode=${pick.mode}${cacheHit ? ', search_cached' : ''})`);
 
     logAssetCall({
-      run_id: (opts && opts.run_id) || null,
+      run_id: runId,
       action: 'hub_search_hit',
       asset_id: pick.match.asset_id || null,
       asset_type: pick.match.asset_type || pick.match.type || null,
@@ -199,7 +279,7 @@ async function hubSearch(signals, opts) {
       score: pick.score,
       mode: pick.mode,
       signals: signalList,
-      via: 'search_then_fetch',
+      via: cacheHit ? 'search_cached' : 'search_then_fetch',
     });
 
     return {
@@ -212,11 +292,10 @@ async function hubSearch(signals, opts) {
       chain_id: pick.match.chain_id || null,
     };
   } catch (err) {
-    const isTimeout = err.name === 'AbortError' || (err.cause && err.cause === TIMEOUT_REASON);
-    const reason = isTimeout ? 'timeout' : 'fetch_error';
+    const reason = err.name === 'AbortError' ? 'timeout' : 'fetch_error';
     console.log(`[HubSearch] Failed (non-fatal, ${reason}): ${err.message}`);
     logAssetCall({
-      run_id: (opts && opts.run_id) || null,
+      run_id: runId,
       action: 'hub_search_miss',
       signals: signalList,
       reason,
@@ -234,4 +313,5 @@ module.exports = {
   getReuseMode,
   getMinReuseScore,
   getHubUrl,
+  clearCaches,
 };

package/src/gep/selector.js

@@ -79,6 +79,10 @@ function selectGene(genes, signals, opts) {
   const driftEnabled = !!(opts && opts.driftEnabled);
   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;
+
   // Compute continuous drift intensity based on effective population size
   var driftIntensity = computeDriftIntensity({
     driftEnabled: driftEnabled,
@@ -99,7 +103,7 @@ function selectGene(genes, signals, opts) {
     .filter(x => x.score > 0)
     .sort((a, b) => b.score - a.score);
 
-  if (scored.length === 0) return { selected: null, alternatives: [], driftIntensity: driftIntensity };
+  if (scored.length === 0) return { selected: null, alternatives: [], driftIntensity: driftIntensity, driftMode: 'none' };
 
   // Memory graph preference: only override when the preferred gene is already a match candidate.
   if (preferredGeneId) {
@@ -111,27 +115,68 @@ function selectGene(genes, signals, opts) {
         selected: preferred.gene,
         alternatives: filteredRest.slice(0, 4).map(x => x.gene),
         driftIntensity: driftIntensity,
+        driftMode: 'memory_preferred',
       };
     }
   }
 
   // Low-efficiency suppression: do not repeat low-confidence paths unless drift is active.
   const filtered = useDrift ? scored : scored.filter(x => x.gene && !bannedGeneIds.has(x.gene.id));
-  if (filtered.length === 0) return { selected: null, alternatives: scored.slice(0, 4).map(x => x.gene), driftIntensity: driftIntensity };
+  if (filtered.length === 0) return { selected: null, alternatives: scored.slice(0, 4).map(x => x.gene), driftIntensity: driftIntensity, driftMode: 'none' };
 
-  // Stochastic selection under drift: with probability proportional to driftIntensity,
-  // pick a random gene from the top candidates instead of always picking the best.
+  // 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';
   if (driftIntensity > 0 && filtered.length > 1 && Math.random() < driftIntensity) {
-    // Weighted random selection from top candidates (favor higher-scoring but allow lower)
-    var topN = Math.min(filtered.length, Math.max(2, Math.ceil(filtered.length * driftIntensity)));
-    selectedIdx = Math.floor(Math.random() * topN);
+    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];
+          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; });
+      if (hasGapHits) {
+        // Sort by gap coverage first, then by base score
+        gapScores.sort(function(a, b) {
+          return b.gapHits - a.gapHits || b.baseScore - a.baseScore;
+        });
+        selectedIdx = gapScores[0].idx;
+        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)));
+        // 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);
+        }
+        selectedIdx = Math.floor(Math.random() * topN);
+        driftMode = 'random_weighted';
+      }
+    } else {
+      // No capability gap data: original random drift behavior
+      var topN = Math.min(filtered.length, Math.max(2, Math.ceil(filtered.length * driftIntensity)));
+      selectedIdx = Math.floor(Math.random() * topN);
+      driftMode = 'random';
+    }
   }
 
   return {
     selected: filtered[selectedIdx].gene,
     alternatives: filtered.filter(function(_, i) { return i !== selectedIdx; }).slice(0, 4).map(x => x.gene),
     driftIntensity: driftIntensity,
+    driftMode: driftMode,
   };
 }
 
@@ -182,7 +227,7 @@ function banGenesFromFailedCapsules(failedCapsules, signals, existingBans) {
   return bans;
 }
 
-function selectGeneAndCapsule({ genes, capsules, signals, memoryAdvice, driftEnabled, failedCapsules }) {
+function selectGeneAndCapsule({ genes, capsules, signals, memoryAdvice, driftEnabled, failedCapsules, capabilityGaps, noveltyScore }) {
   const bannedGeneIds =
     memoryAdvice && memoryAdvice.bannedGeneIds instanceof Set ? memoryAdvice.bannedGeneIds : new Set();
   const preferredGeneId = memoryAdvice && memoryAdvice.preferredGeneId ? memoryAdvice.preferredGeneId : null;
@@ -197,6 +242,8 @@ function selectGeneAndCapsule({ genes, capsules, signals, memoryAdvice, driftEna
     bannedGeneIds: effectiveBans,
     preferredGeneId,
     driftEnabled: !!driftEnabled,
+    capabilityGaps: Array.isArray(capabilityGaps) ? capabilityGaps : [],
+    noveltyScore: Number.isFinite(Number(noveltyScore)) ? Number(noveltyScore) : null,
   });
   const capsule = selectCapsule(capsules, signals);
   const selector = buildSelectorDecision({

package/src/gep/solidify.js

@@ -20,6 +20,7 @@ const { buildValidationReport } = require('./validationReport');
 const { logAssetCall } = require('./assetCallLog');
 const { recordNarrative } = require('./narrativeMemory');
 const { isLlmReviewEnabled, runLlmReview } = require('./llmReview');
+const { buildExecutionTrace } = require('./executionTrace');
 
 function nowIso() {
   return new Date().toISOString();
@@ -382,12 +383,12 @@ function readStateForSolidify() {
 }
 
 function writeStateForSolidify(state) {
-  const memoryDir = getMemoryDir();
-  const statePath = path.join(getEvolutionDir(), 'evolution_solidify_state.json');
+  const evolutionDir = getEvolutionDir();
+  const statePath = path.join(evolutionDir, 'evolution_solidify_state.json');
   try {
-    if (!fs.existsSync(memoryDir)) fs.mkdirSync(memoryDir, { recursive: true });
+    if (!fs.existsSync(evolutionDir)) fs.mkdirSync(evolutionDir, { recursive: true });
   } catch (e) {
-    console.warn('[evolver] writeStateForSolidify mkdir failed:', memoryDir, e && e.message || e);
+    console.warn('[evolver] writeStateForSolidify mkdir failed:', evolutionDir, e && e.message || e);
   }
   const tmp = `${statePath}.tmp`;
   fs.writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf8');
@@ -1225,6 +1226,22 @@ function solidify({ intent, summary, dryRun = false, rollbackOnFailure = true }
       memory_graph: memoryGraphPath(),
     },
   };
+  // Build desensitized execution trace for cross-agent experience sharing
+  const executionTrace = buildExecutionTrace({
+    gene: geneUsed,
+    mutation,
+    signals,
+    blast,
+    constraintCheck,
+    validation,
+    canary,
+    outcomeStatus,
+    startedAt: validation.startedAt,
+  });
+  if (executionTrace) {
+    event.execution_trace = executionTrace;
+  }
+
   event.asset_id = computeAssetId(event);
 
   let capsule = null;
@@ -1350,7 +1367,10 @@ function solidify({ intent, summary, dryRun = false, rollbackOnFailure = true }
   state.last_solidify = {
     run_id: runId, at: ts, event_id: event.id, capsule_id: capsuleId, outcome: event.outcome,
   };
-  if (!dryRun) writeStateForSolidify(state);
+  if (!dryRun) {
+    state.solidify_count = (state.solidify_count || 0) + 1;
+    writeStateForSolidify(state);
+  }
 
   if (!dryRun) {
     try {