@evomap/evolver 1.29.8 → 1.30.2

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/skillDistiller.js

@@ -223,32 +223,78 @@ function buildDistillationPrompt(analysis, existingGenes, sampleCapsules) {
   });
 
   return [
-    'You are a Gene synthesis engine for the GEP (Gene Expression Protocol).',
+    'You are a Gene synthesis engine for the GEP (Genome Evolution Protocol).',
+    'Your job is to distill successful evolution capsules into a high-quality, reusable Gene',
+    'that other AI agents can discover, fetch, and execute.',
     '',
-    'Analyze the following successful evolution capsules and extract a reusable Gene.',
+    '## OUTPUT FORMAT',
+    '',
+    'Output ONLY a single valid JSON object (no markdown fences, no explanation).',
+    '',
+    '## GENE ID RULES (CRITICAL)',
+    '',
+    '- The id MUST start with "' + DISTILLED_ID_PREFIX + '" followed by a descriptive kebab-case name.',
+    '- The suffix MUST describe the core capability in 3-6 hyphen-separated words.',
+    '- NEVER include timestamps, numeric IDs, random numbers, tool names (cursor, vscode, etc.), or UUIDs.',
+    '- Good: "gene_distilled_retry-with-exponential-backoff", "gene_distilled_database-migration-rollback"',
+    '- Bad: "gene_distilled_cursor-1773331925711", "gene_distilled_1234567890", "gene_distilled_fix-1"',
+    '',
+    '## SUMMARY RULES',
+    '',
+    '- The "summary" MUST be a clear, human-readable sentence (30-200 chars) describing',
+    '  WHAT capability this Gene provides and WHY it is useful.',
+    '- Write as if for a marketplace listing -- the summary is the first thing other agents see.',
+    '- Good: "Retry failed HTTP requests with exponential backoff, jitter, and circuit breaker to prevent cascade failures"',
+    '- Bad: "Distilled from capsules", "AI agent skill", "cursor automation", "1773331925711"',
+    '- NEVER include timestamps, build numbers, or tool names in the summary.',
+    '',
+    '## SIGNALS_MATCH RULES',
+    '',
+    '- Each signal MUST be a generic, reusable keyword that describes WHEN to trigger this Gene.',
+    '- Use lowercase_snake_case. Signals should be domain terms, not implementation artifacts.',
+    '- NEVER include timestamps, build numbers, tool names, session IDs, or random suffixes.',
+    '- Include 3-7 signals covering both the problem domain and the solution approach.',
+    '- Good: ["http_retry", "request_timeout", "exponential_backoff", "circuit_breaker", "resilience"]',
+    '- Bad: ["cursor_auto_1773331925711", "cli_headless_1773331925711", "bypass_123"]',
+    '',
+    '## STRATEGY RULES',
+    '',
+    '- Strategy steps MUST be actionable, concrete instructions an AI agent can execute.',
+    '- Each step should be a clear imperative sentence starting with a verb.',
+    '- Include 5-10 steps. Each step should be self-contained and specific.',
+    '- Do NOT describe what happened; describe what TO DO.',
+    '- Include rationale or context in parentheses when non-obvious.',
+    '- Where applicable, include inline code examples using backtick notation.',
+    '- Good: "Wrap the HTTP call in a retry loop with `maxRetries=3` and initial delay of 500ms"',
+    '- Bad: "Handle retries", "Fix the issue", "Improve reliability"',
+    '',
+    '## PRECONDITIONS RULES',
+    '',
+    '- List concrete, verifiable conditions that must be true before applying this Gene.',
+    '- Each precondition should be a testable statement, not a vague requirement.',
+    '- Good: "Project uses Node.js >= 18 with ES module support"',
+    '- Bad: "need to fix something"',
+    '',
+    '## CONSTRAINTS',
     '',
-    'RULES:',
-    '- Strategy steps MUST be actionable operations, NOT summaries',
-    '- Each step must be a concrete instruction an AI agent can execute',
-    '- Do NOT describe what happened; describe what TO DO next time',
-    '- The Gene MUST have a unique id starting with "' + DISTILLED_ID_PREFIX + '"',
     '- constraints.max_files MUST be <= ' + DISTILLED_MAX_FILES,
     '- constraints.forbidden_paths MUST include at least [".git", "node_modules"]',
-    '- Output valid Gene JSON only (no markdown, no explanation)',
     '',
-    'GENE ID NAMING RULES (CRITICAL):',
-    '- The id suffix (after "' + DISTILLED_ID_PREFIX + '") MUST be a descriptive kebab-case name',
-    '  derived from the strategy content or signals_match (e.g., "retry-on-timeout", "log-rotation-cleanup")',
-    '- NEVER use timestamps, random numbers, tool names (cursor, vscode, etc.), or UUIDs in the id',
-    '- Good: "gene_distilled_retry-on-timeout", "gene_distilled_cache-invalidation-strategy"',
-    '- Bad: "gene_distilled_cursor-1773331925711", "gene_distilled_1234567890", "gene_distilled_fix-1"',
-    '- The id suffix must be 3+ words separated by hyphens, describing the core capability',
+    '## VALIDATION',
+    '',
+    '- Validation commands MUST start with "node ", "npm ", or "npx " (security constraint).',
+    '- Include commands that actually verify the Gene was applied correctly.',
+    '- Good: "npx tsc --noEmit", "npm test"',
+    '- Bad: "node -v" (proves nothing about the Gene)',
+    '',
+    '## QUALITY BAR',
     '',
-    'SUMMARY RULES:',
-    '- The "summary" field MUST be a clear, human-readable description (10-200 chars)',
-    '- It should describe WHAT the Gene does, not implementation details',
-    '- Good: "Retry failed HTTP requests with exponential backoff and circuit breaker"',
-    '- Bad: "Distilled from capsules", "AI agent skill", "cursor automation"',
+    'Imagine this Gene will be published on a marketplace for thousands of AI agents.',
+    'It should be as professional and useful as a well-written library README.',
+    'Ask yourself: "Would another agent find this Gene by searching for the signals?',
+    'Would the summary make them want to fetch it? Would the strategy be enough to execute?"',
+    '',
+    '---',
     '',
     'SUCCESSFUL CAPSULES (grouped by pattern):',
     JSON.stringify(samples, null, 2),
@@ -260,7 +306,7 @@ function buildDistillationPrompt(analysis, existingGenes, sampleCapsules) {
     JSON.stringify(analysis, null, 2),
     '',
     'Output a single Gene JSON object with these fields:',
-    '{ "type": "Gene", "id": "gene_distilled_<descriptive-kebab-name>", "summary": "<clear human-readable description>", "category": "...", "signals_match": [...], "preconditions": [...], "strategy": [...], "constraints": { "max_files": N, "forbidden_paths": [...] }, "validation": [...] }',
+    '{ "type": "Gene", "id": "gene_distilled_<descriptive-kebab-name>", "summary": "<clear marketplace-quality description>", "category": "repair|optimize|innovate", "signals_match": ["generic_signal_1", ...], "preconditions": ["Concrete condition 1", ...], "strategy": ["Step 1: verb ...", "Step 2: verb ...", ...], "constraints": { "max_files": N, "forbidden_paths": [".git", "node_modules", ...] }, "validation": ["npx tsc --noEmit", ...], "schema_version": "1.6.0" }',
   ].join('\n');
 }
 
@@ -298,6 +344,34 @@ function deriveDescriptiveId(gene) {
   return DISTILLED_ID_PREFIX + unique.slice(0, 5).join('-');
 }
 
+// ---------------------------------------------------------------------------
+// Step 4: sanitizeSignalsMatch -- strip timestamps, random suffixes, tool names
+// ---------------------------------------------------------------------------
+function sanitizeSignalsMatch(signals) {
+  if (!Array.isArray(signals)) return [];
+  var cleaned = [];
+  signals.forEach(function (s) {
+    var sig = String(s || '').trim().toLowerCase();
+    if (!sig) return;
+    // Strip trailing timestamps (10+ digits) and random suffixes
+    sig = sig.replace(/[_-]\d{10,}$/g, '');
+    // Strip leading/trailing underscores/hyphens left over
+    sig = sig.replace(/^[_-]+|[_-]+$/g, '');
+    // Reject signals that are purely numeric
+    if (/^\d+$/.test(sig)) return;
+    // Reject signals that are just a tool name with optional number
+    if (/^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex|bypass|distill)[_-]?\d*$/i.test(sig)) return;
+    // Reject signals shorter than 3 chars after cleaning
+    if (sig.length < 3) return;
+    // Reject signals that still contain long numeric sequences (session IDs, etc.)
+    if (/\d{8,}/.test(sig)) return;
+    cleaned.push(sig);
+  });
+  // Deduplicate
+  var seen = {};
+  return cleaned.filter(function (s) { if (seen[s]) return false; seen[s] = true; return true; });
+}
+
 // ---------------------------------------------------------------------------
 // Step 4: validateSynthesizedGene
 // ---------------------------------------------------------------------------
@@ -311,16 +385,34 @@ function validateSynthesizedGene(gene, existingGenes) {
   if (!Array.isArray(gene.signals_match) || gene.signals_match.length === 0) errors.push('missing or empty signals_match');
   if (!Array.isArray(gene.strategy) || gene.strategy.length === 0) errors.push('missing or empty strategy');
 
+  // --- Signals sanitization (BEFORE id derivation so deriveDescriptiveId uses clean signals) ---
+  if (Array.isArray(gene.signals_match)) {
+    gene.signals_match = sanitizeSignalsMatch(gene.signals_match);
+    if (gene.signals_match.length === 0) {
+      errors.push('signals_match is empty after sanitization (all signals were invalid)');
+    }
+  }
+
+  // --- Summary sanitization (BEFORE id derivation so deriveDescriptiveId uses clean summary) ---
+  if (gene.summary) {
+    gene.summary = gene.summary.replace(/\s*\d{10,}\s*$/g, '').replace(/\.\s*\d{10,}/g, '.').trim();
+  }
+
+  // --- ID sanitization ---
   if (gene.id && !String(gene.id).startsWith(DISTILLED_ID_PREFIX)) {
     gene.id = DISTILLED_ID_PREFIX + String(gene.id).replace(/^gene_/, '');
   }
 
   if (gene.id) {
     var suffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
+    // Strip ALL embedded timestamps (10+ digit sequences) anywhere in the id
+    suffix = suffix.replace(/[-_]?\d{10,}[-_]?/g, '-').replace(/[-_]+/g, '-').replace(/^[-_]+|[-_]+$/g, '');
     var needsRename = /^\d+$/.test(suffix) || /^\d{10,}/.test(suffix)
-      || /^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex)[-_]?\d*/i.test(suffix);
+      || /^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex)[-_]?\d*$/i.test(suffix);
     if (needsRename) {
       gene.id = deriveDescriptiveId(gene);
+    } else {
+      gene.id = DISTILLED_ID_PREFIX + suffix;
     }
     var cleanSuffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
     if (cleanSuffix.replace(/[-_]/g, '').length < 6) {
@@ -328,6 +420,7 @@ function validateSynthesizedGene(gene, existingGenes) {
     }
   }
 
+  // --- Summary fallback (summary was already sanitized above, this handles missing/short) ---
   if (!gene.summary || typeof gene.summary !== 'string' || gene.summary.length < 10) {
     if (Array.isArray(gene.strategy) && gene.strategy.length > 0) {
       gene.summary = String(gene.strategy[0]).slice(0, 200);
@@ -336,6 +429,12 @@ function validateSynthesizedGene(gene, existingGenes) {
     }
   }
 
+  // --- Strategy quality: require minimum 3 steps ---
+  if (Array.isArray(gene.strategy) && gene.strategy.length < 3) {
+    errors.push('strategy must have at least 3 steps for a quality skill');
+  }
+
+  // --- Constraints ---
   if (!gene.constraints || typeof gene.constraints !== 'object') gene.constraints = {};
   if (!Array.isArray(gene.constraints.forbidden_paths) || gene.constraints.forbidden_paths.length === 0) {
     gene.constraints.forbidden_paths = ['.git', 'node_modules'];
@@ -347,6 +446,7 @@ function validateSynthesizedGene(gene, existingGenes) {
     gene.constraints.max_files = DISTILLED_MAX_FILES;
   }
 
+  // --- Validation command sanitization ---
   var ALLOWED_PREFIXES = ['node ', 'npm ', 'npx '];
   if (Array.isArray(gene.validation)) {
     gene.validation = gene.validation.filter(function (cmd) {
@@ -359,11 +459,16 @@ function validateSynthesizedGene(gene, existingGenes) {
     });
   }
 
+  // --- Schema version ---
+  if (!gene.schema_version) gene.schema_version = '1.6.0';
+
+  // --- Duplicate ID check ---
   var existingIds = new Set((existingGenes || []).map(function (g) { return g.id; }));
   if (gene.id && existingIds.has(gene.id)) {
     gene.id = gene.id + '_' + Date.now().toString(36);
   }
 
+  // --- Signal overlap check ---
   if (gene.signals_match && existingGenes && existingGenes.length > 0) {
     var newSet = new Set(gene.signals_match.map(function (s) { return String(s).toLowerCase(); }));
     for (var i = 0; i < existingGenes.length; i++) {
@@ -566,6 +671,7 @@ module.exports = {
   prepareDistillation: prepareDistillation,
   completeDistillation: completeDistillation,
   validateSynthesizedGene: validateSynthesizedGene,
+  sanitizeSignalsMatch: sanitizeSignalsMatch,
   shouldDistill: shouldDistill,
   buildDistillationPrompt: buildDistillationPrompt,
   extractJsonFromLlmResponse: extractJsonFromLlmResponse,